diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/build_env.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/build_env.py new file mode 100644 index 0000000000000000000000000000000000000000..a060ceea2ca68ab0733577849bbe4cadae980d1b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/build_env.py @@ -0,0 +1,218 @@ +"""Build Environment used for isolation during sdist building +""" + +import logging +import os +import sys +import textwrap +from collections import OrderedDict +from distutils.sysconfig import get_python_lib +from sysconfig import get_paths + +from pip._vendor.pkg_resources import Requirement, VersionConflict, WorkingSet + +from pip import __file__ as pip_location +from pip._internal.utils.misc import call_subprocess +from pip._internal.utils.temp_dir import TempDirectory +from pip._internal.utils.typing import MYPY_CHECK_RUNNING +from pip._internal.utils.ui import open_spinner + +if MYPY_CHECK_RUNNING: + from typing import Tuple, Set, Iterable, Optional, List + from pip._internal.index import PackageFinder + +logger = logging.getLogger(__name__) + + +class _Prefix: + + def __init__(self, path): + # type: (str) -> None + self.path = path + self.setup = False + self.bin_dir = get_paths( + 'nt' if os.name == 'nt' else 'posix_prefix', + vars={'base': path, 'platbase': path} + )['scripts'] + # Note: prefer distutils' sysconfig to get the + # library paths so PyPy is correctly supported. + purelib = get_python_lib(plat_specific=False, prefix=path) + platlib = get_python_lib(plat_specific=True, prefix=path) + if purelib == platlib: + self.lib_dirs = [purelib] + else: + self.lib_dirs = [purelib, platlib] + + +class BuildEnvironment(object): + """Creates and manages an isolated environment to install build deps + """ + + def __init__(self): + # type: () -> None + self._temp_dir = TempDirectory(kind="build-env") + self._temp_dir.create() + + self._prefixes = OrderedDict(( + (name, _Prefix(os.path.join(self._temp_dir.path, name))) + for name in ('normal', 'overlay') + )) + + self._bin_dirs = [] # type: List[str] + self._lib_dirs = [] # type: List[str] + for prefix in reversed(list(self._prefixes.values())): + self._bin_dirs.append(prefix.bin_dir) + self._lib_dirs.extend(prefix.lib_dirs) + + # Customize site to: + # - ensure .pth files are honored + # - prevent access to system site packages + system_sites = { + os.path.normcase(site) for site in ( + get_python_lib(plat_specific=False), + get_python_lib(plat_specific=True), + ) + } + self._site_dir = os.path.join(self._temp_dir.path, 'site') + if not os.path.exists(self._site_dir): + os.mkdir(self._site_dir) + with open(os.path.join(self._site_dir, 'sitecustomize.py'), 'w') as fp: + fp.write(textwrap.dedent( + ''' + import os, site, sys + + # First, drop system-sites related paths. + original_sys_path = sys.path[:] + known_paths = set() + for path in {system_sites!r}: + site.addsitedir(path, known_paths=known_paths) + system_paths = set( + os.path.normcase(path) + for path in sys.path[len(original_sys_path):] + ) + original_sys_path = [ + path for path in original_sys_path + if os.path.normcase(path) not in system_paths + ] + sys.path = original_sys_path + + # Second, add lib directories. + # ensuring .pth file are processed. + for path in {lib_dirs!r}: + assert not path in sys.path + site.addsitedir(path) + ''' + ).format(system_sites=system_sites, lib_dirs=self._lib_dirs)) + + def __enter__(self): + self._save_env = { + name: os.environ.get(name, None) + for name in ('PATH', 'PYTHONNOUSERSITE', 'PYTHONPATH') + } + + path = self._bin_dirs[:] + old_path = self._save_env['PATH'] + if old_path: + path.extend(old_path.split(os.pathsep)) + + pythonpath = [self._site_dir] + + os.environ.update({ + 'PATH': os.pathsep.join(path), + 'PYTHONNOUSERSITE': '1', + 'PYTHONPATH': os.pathsep.join(pythonpath), + }) + + def __exit__(self, exc_type, exc_val, exc_tb): + for varname, old_value in self._save_env.items(): + if old_value is None: + os.environ.pop(varname, None) + else: + os.environ[varname] = old_value + + def cleanup(self): + # type: () -> None + self._temp_dir.cleanup() + + def check_requirements(self, reqs): + # type: (Iterable[str]) -> Tuple[Set[Tuple[str, str]], Set[str]] + """Return 2 sets: + - conflicting requirements: set of (installed, wanted) reqs tuples + - missing requirements: set of reqs + """ + missing = set() + conflicting = set() + if reqs: + ws = WorkingSet(self._lib_dirs) + for req in reqs: + try: + if ws.find(Requirement.parse(req)) is None: + missing.add(req) + except VersionConflict as e: + conflicting.add((str(e.args[0].as_requirement()), + str(e.args[1]))) + return conflicting, missing + + def install_requirements( + self, + finder, # type: PackageFinder + requirements, # type: Iterable[str] + prefix_as_string, # type: str + message # type: Optional[str] + ): + # type: (...) -> None + prefix = self._prefixes[prefix_as_string] + assert not prefix.setup + prefix.setup = True + if not requirements: + return + args = [ + sys.executable, os.path.dirname(pip_location), 'install', + '--ignore-installed', '--no-user', '--prefix', prefix.path, + '--no-warn-script-location', + ] # type: List[str] + if logger.getEffectiveLevel() <= logging.DEBUG: + args.append('-v') + for format_control in ('no_binary', 'only_binary'): + formats = getattr(finder.format_control, format_control) + args.extend(('--' + format_control.replace('_', '-'), + ','.join(sorted(formats or {':none:'})))) + + index_urls = finder.index_urls + if index_urls: + args.extend(['-i', index_urls[0]]) + for extra_index in index_urls[1:]: + args.extend(['--extra-index-url', extra_index]) + else: + args.append('--no-index') + for link in finder.find_links: + args.extend(['--find-links', link]) + + for host in finder.trusted_hosts: + args.extend(['--trusted-host', host]) + if finder.allow_all_prereleases: + args.append('--pre') + args.append('--') + args.extend(requirements) + with open_spinner(message) as spinner: + call_subprocess(args, spinner=spinner) + + +class NoOpBuildEnvironment(BuildEnvironment): + """A no-op drop-in replacement for BuildEnvironment + """ + + def __init__(self): + pass + + def __enter__(self): + pass + + def __exit__(self, exc_type, exc_val, exc_tb): + pass + + def cleanup(self): + pass + + def install_requirements(self, finder, requirements, prefix, message): + raise NotImplementedError() diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cache.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cache.py new file mode 100644 index 0000000000000000000000000000000000000000..894624c1dbc54c2c2469870485d30c095a94726c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/cache.py @@ -0,0 +1,224 @@ +"""Cache Management +""" + +import errno +import hashlib +import logging +import os + +from pip._vendor.packaging.utils import canonicalize_name + +from pip._internal.models.link import Link +from pip._internal.utils.compat import expanduser +from pip._internal.utils.misc import path_to_url +from pip._internal.utils.temp_dir import TempDirectory +from pip._internal.utils.typing import MYPY_CHECK_RUNNING +from pip._internal.wheel import InvalidWheelFilename, Wheel + +if MYPY_CHECK_RUNNING: + from typing import Optional, Set, List, Any + from pip._internal.index import FormatControl + +logger = logging.getLogger(__name__) + + +class Cache(object): + """An abstract class - provides cache directories for data from links + + + :param cache_dir: The root of the cache. + :param format_control: An object of FormatControl class to limit + binaries being read from the cache. + :param allowed_formats: which formats of files the cache should store. + ('binary' and 'source' are the only allowed values) + """ + + def __init__(self, cache_dir, format_control, allowed_formats): + # type: (str, FormatControl, Set[str]) -> None + super(Cache, self).__init__() + self.cache_dir = expanduser(cache_dir) if cache_dir else None + self.format_control = format_control + self.allowed_formats = allowed_formats + + _valid_formats = {"source", "binary"} + assert self.allowed_formats.union(_valid_formats) == _valid_formats + + def _get_cache_path_parts(self, link): + # type: (Link) -> List[str] + """Get parts of part that must be os.path.joined with cache_dir + """ + + # We want to generate an url to use as our cache key, we don't want to + # just re-use the URL because it might have other items in the fragment + # and we don't care about those. + key_parts = [link.url_without_fragment] + if link.hash_name is not None and link.hash is not None: + key_parts.append("=".join([link.hash_name, link.hash])) + key_url = "#".join(key_parts) + + # Encode our key url with sha224, we'll use this because it has similar + # security properties to sha256, but with a shorter total output (and + # thus less secure). However the differences don't make a lot of + # difference for our use case here. + hashed = hashlib.sha224(key_url.encode()).hexdigest() + + # We want to nest the directories some to prevent having a ton of top + # level directories where we might run out of sub directories on some + # FS. + parts = [hashed[:2], hashed[2:4], hashed[4:6], hashed[6:]] + + return parts + + def _get_candidates(self, link, package_name): + # type: (Link, Optional[str]) -> List[Any] + can_not_cache = ( + not self.cache_dir or + not package_name or + not link + ) + if can_not_cache: + return [] + + canonical_name = canonicalize_name(package_name) + formats = self.format_control.get_allowed_formats( + canonical_name + ) + if not self.allowed_formats.intersection(formats): + return [] + + root = self.get_path_for_link(link) + try: + return os.listdir(root) + except OSError as err: + if err.errno in {errno.ENOENT, errno.ENOTDIR}: + return [] + raise + + def get_path_for_link(self, link): + # type: (Link) -> str + """Return a directory to store cached items in for link. + """ + raise NotImplementedError() + + def get(self, link, package_name): + # type: (Link, Optional[str]) -> Link + """Returns a link to a cached item if it exists, otherwise returns the + passed link. + """ + raise NotImplementedError() + + def _link_for_candidate(self, link, candidate): + # type: (Link, str) -> Link + root = self.get_path_for_link(link) + path = os.path.join(root, candidate) + + return Link(path_to_url(path)) + + def cleanup(self): + # type: () -> None + pass + + +class SimpleWheelCache(Cache): + """A cache of wheels for future installs. + """ + + def __init__(self, cache_dir, format_control): + # type: (str, FormatControl) -> None + super(SimpleWheelCache, self).__init__( + cache_dir, format_control, {"binary"} + ) + + def get_path_for_link(self, link): + # type: (Link) -> str + """Return a directory to store cached wheels for link + + Because there are M wheels for any one sdist, we provide a directory + to cache them in, and then consult that directory when looking up + cache hits. + + We only insert things into the cache if they have plausible version + numbers, so that we don't contaminate the cache with things that were + not unique. E.g. ./package might have dozens of installs done for it + and build a version of 0.0...and if we built and cached a wheel, we'd + end up using the same wheel even if the source has been edited. + + :param link: The link of the sdist for which this will cache wheels. + """ + parts = self._get_cache_path_parts(link) + + # Store wheels within the root cache_dir + return os.path.join(self.cache_dir, "wheels", *parts) + + def get(self, link, package_name): + # type: (Link, Optional[str]) -> Link + candidates = [] + + for wheel_name in self._get_candidates(link, package_name): + try: + wheel = Wheel(wheel_name) + except InvalidWheelFilename: + continue + if not wheel.supported(): + # Built for a different python/arch/etc + continue + candidates.append((wheel.support_index_min(), wheel_name)) + + if not candidates: + return link + + return self._link_for_candidate(link, min(candidates)[1]) + + +class EphemWheelCache(SimpleWheelCache): + """A SimpleWheelCache that creates it's own temporary cache directory + """ + + def __init__(self, format_control): + # type: (FormatControl) -> None + self._temp_dir = TempDirectory(kind="ephem-wheel-cache") + self._temp_dir.create() + + super(EphemWheelCache, self).__init__( + self._temp_dir.path, format_control + ) + + def cleanup(self): + # type: () -> None + self._temp_dir.cleanup() + + +class WheelCache(Cache): + """Wraps EphemWheelCache and SimpleWheelCache into a single Cache + + This Cache allows for gracefully degradation, using the ephem wheel cache + when a certain link is not found in the simple wheel cache first. + """ + + def __init__(self, cache_dir, format_control): + # type: (str, FormatControl) -> None + super(WheelCache, self).__init__( + cache_dir, format_control, {'binary'} + ) + self._wheel_cache = SimpleWheelCache(cache_dir, format_control) + self._ephem_cache = EphemWheelCache(format_control) + + def get_path_for_link(self, link): + # type: (Link) -> str + return self._wheel_cache.get_path_for_link(link) + + def get_ephem_path_for_link(self, link): + # type: (Link) -> str + return self._ephem_cache.get_path_for_link(link) + + def get(self, link, package_name): + # type: (Link, Optional[str]) -> Link + retval = self._wheel_cache.get(link, package_name) + if retval is link: + retval = self._ephem_cache.get(link, package_name) + return retval + + def cleanup(self): + # type: () -> None + self._wheel_cache.cleanup() + self._ephem_cache.cleanup() diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/configuration.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/configuration.py new file mode 100644 index 0000000000000000000000000000000000000000..437e92eeb3a56bf96d7a7d20aeba95df68d59cf2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/configuration.py @@ -0,0 +1,417 @@ +"""Configuration management setup + +Some terminology: +- name + As written in config files. +- value + Value associated with a name +- key + Name combined with it's section (section.name) +- variant + A single word describing where the configuration key-value pair came from +""" + +import locale +import logging +import os +import sys + +from pip._vendor.six.moves import configparser + +from pip._internal.exceptions import ( + ConfigurationError, ConfigurationFileCouldNotBeLoaded, +) +from pip._internal.utils import appdirs +from pip._internal.utils.compat import WINDOWS, expanduser +from pip._internal.utils.misc import ensure_dir, enum +from pip._internal.utils.typing import MYPY_CHECK_RUNNING + +if MYPY_CHECK_RUNNING: + from typing import ( + Any, Dict, Iterable, List, NewType, Optional, Tuple + ) + + RawConfigParser = configparser.RawConfigParser # Shorthand + Kind = NewType("Kind", str) + +logger = logging.getLogger(__name__) + + +# NOTE: Maybe use the optionx attribute to normalize keynames. +def _normalize_name(name): + # type: (str) -> str + """Make a name consistent regardless of source (environment or file) + """ + name = name.lower().replace('_', '-') + if name.startswith('--'): + name = name[2:] # only prefer long opts + return name + + +def _disassemble_key(name): + # type: (str) -> List[str] + if "." not in name: + error_message = ( + "Key does not contain dot separated section and key. " + "Perhaps you wanted to use 'global.{}' instead?" + ).format(name) + raise ConfigurationError(error_message) + return name.split(".", 1) + + +# The kinds of configurations there are. +kinds = enum( + USER="user", # User Specific + GLOBAL="global", # System Wide + SITE="site", # [Virtual] Environment Specific + ENV="env", # from PIP_CONFIG_FILE + ENV_VAR="env-var", # from Environment Variables +) + + +CONFIG_BASENAME = 'pip.ini' if WINDOWS else 'pip.conf' + + +def get_configuration_files(): + global_config_files = [ + os.path.join(path, CONFIG_BASENAME) + for path in appdirs.site_config_dirs('pip') + ] + + site_config_file = os.path.join(sys.prefix, CONFIG_BASENAME) + legacy_config_file = os.path.join( + expanduser('~'), + 'pip' if WINDOWS else '.pip', + CONFIG_BASENAME, + ) + new_config_file = os.path.join( + appdirs.user_config_dir("pip"), CONFIG_BASENAME + ) + return { + kinds.GLOBAL: global_config_files, + kinds.SITE: [site_config_file], + kinds.USER: [legacy_config_file, new_config_file], + } + + +class Configuration(object): + """Handles management of configuration. + + Provides an interface to accessing and managing configuration files. + + This class converts provides an API that takes "section.key-name" style + keys and stores the value associated with it as "key-name" under the + section "section". + + This allows for a clean interface wherein the both the section and the + key-name are preserved in an easy to manage form in the configuration files + and the data stored is also nice. + """ + + def __init__(self, isolated, load_only=None): + # type: (bool, Kind) -> None + super(Configuration, self).__init__() + + _valid_load_only = [kinds.USER, kinds.GLOBAL, kinds.SITE, None] + if load_only not in _valid_load_only: + raise ConfigurationError( + "Got invalid value for load_only - should be one of {}".format( + ", ".join(map(repr, _valid_load_only[:-1])) + ) + ) + self.isolated = isolated # type: bool + self.load_only = load_only # type: Optional[Kind] + + # The order here determines the override order. + self._override_order = [ + kinds.GLOBAL, kinds.USER, kinds.SITE, kinds.ENV, kinds.ENV_VAR + ] + + self._ignore_env_names = ["version", "help"] + + # Because we keep track of where we got the data from + self._parsers = { + variant: [] for variant in self._override_order + } # type: Dict[Kind, List[Tuple[str, RawConfigParser]]] + self._config = { + variant: {} for variant in self._override_order + } # type: Dict[Kind, Dict[str, Any]] + self._modified_parsers = [] # type: List[Tuple[str, RawConfigParser]] + + def load(self): + # type: () -> None + """Loads configuration from configuration files and environment + """ + self._load_config_files() + if not self.isolated: + self._load_environment_vars() + + def get_file_to_edit(self): + # type: () -> Optional[str] + """Returns the file with highest priority in configuration + """ + assert self.load_only is not None, \ + "Need to be specified a file to be editing" + + try: + return self._get_parser_to_modify()[0] + except IndexError: + return None + + def items(self): + # type: () -> Iterable[Tuple[str, Any]] + """Returns key-value pairs like dict.items() representing the loaded + configuration + """ + return self._dictionary.items() + + def get_value(self, key): + # type: (str) -> Any + """Get a value from the configuration. + """ + try: + return self._dictionary[key] + except KeyError: + raise ConfigurationError("No such key - {}".format(key)) + + def set_value(self, key, value): + # type: (str, Any) -> None + """Modify a value in the configuration. + """ + self._ensure_have_load_only() + + fname, parser = self._get_parser_to_modify() + + if parser is not None: + section, name = _disassemble_key(key) + + # Modify the parser and the configuration + if not parser.has_section(section): + parser.add_section(section) + parser.set(section, name, value) + + self._config[self.load_only][key] = value + self._mark_as_modified(fname, parser) + + def unset_value(self, key): + # type: (str) -> None + """Unset a value in the configuration. + """ + self._ensure_have_load_only() + + if key not in self._config[self.load_only]: + raise ConfigurationError("No such key - {}".format(key)) + + fname, parser = self._get_parser_to_modify() + + if parser is not None: + section, name = _disassemble_key(key) + + # Remove the key in the parser + modified_something = False + if parser.has_section(section): + # Returns whether the option was removed or not + modified_something = parser.remove_option(section, name) + + if modified_something: + # name removed from parser, section may now be empty + section_iter = iter(parser.items(section)) + try: + val = next(section_iter) + except StopIteration: + val = None + + if val is None: + parser.remove_section(section) + + self._mark_as_modified(fname, parser) + else: + raise ConfigurationError( + "Fatal Internal error [id=1]. Please report as a bug." + ) + + del self._config[self.load_only][key] + + def save(self): + # type: () -> None + """Save the current in-memory state. + """ + self._ensure_have_load_only() + + for fname, parser in self._modified_parsers: + logger.info("Writing to %s", fname) + + # Ensure directory exists. + ensure_dir(os.path.dirname(fname)) + + with open(fname, "w") as f: + parser.write(f) + + # + # Private routines + # + + def _ensure_have_load_only(self): + # type: () -> None + if self.load_only is None: + raise ConfigurationError("Needed a specific file to be modifying.") + logger.debug("Will be working with %s variant only", self.load_only) + + @property + def _dictionary(self): + # type: () -> Dict[str, Any] + """A dictionary representing the loaded configuration. + """ + # NOTE: Dictionaries are not populated if not loaded. So, conditionals + # are not needed here. + retval = {} + + for variant in self._override_order: + retval.update(self._config[variant]) + + return retval + + def _load_config_files(self): + # type: () -> None + """Loads configuration from configuration files + """ + config_files = dict(self._iter_config_files()) + if config_files[kinds.ENV][0:1] == [os.devnull]: + logger.debug( + "Skipping loading configuration files due to " + "environment's PIP_CONFIG_FILE being os.devnull" + ) + return + + for variant, files in config_files.items(): + for fname in files: + # If there's specific variant set in `load_only`, load only + # that variant, not the others. + if self.load_only is not None and variant != self.load_only: + logger.debug( + "Skipping file '%s' (variant: %s)", fname, variant + ) + continue + + parser = self._load_file(variant, fname) + + # Keeping track of the parsers used + self._parsers[variant].append((fname, parser)) + + def _load_file(self, variant, fname): + # type: (Kind, str) -> RawConfigParser + logger.debug("For variant '%s', will try loading '%s'", variant, fname) + parser = self._construct_parser(fname) + + for section in parser.sections(): + items = parser.items(section) + self._config[variant].update(self._normalized_keys(section, items)) + + return parser + + def _construct_parser(self, fname): + # type: (str) -> RawConfigParser + parser = configparser.RawConfigParser() + # If there is no such file, don't bother reading it but create the + # parser anyway, to hold the data. + # Doing this is useful when modifying and saving files, where we don't + # need to construct a parser. + if os.path.exists(fname): + try: + parser.read(fname) + except UnicodeDecodeError: + # See https://github.com/pypa/pip/issues/4963 + raise ConfigurationFileCouldNotBeLoaded( + reason="contains invalid {} characters".format( + locale.getpreferredencoding(False) + ), + fname=fname, + ) + except configparser.Error as error: + # See https://github.com/pypa/pip/issues/4893 + raise ConfigurationFileCouldNotBeLoaded(error=error) + return parser + + def _load_environment_vars(self): + # type: () -> None + """Loads configuration from environment variables + """ + self._config[kinds.ENV_VAR].update( + self._normalized_keys(":env:", self._get_environ_vars()) + ) + + def _normalized_keys(self, section, items): + # type: (str, Iterable[Tuple[str, Any]]) -> Dict[str, Any] + """Normalizes items to construct a dictionary with normalized keys. + + This routine is where the names become keys and are made the same + regardless of source - configuration files or environment. + """ + normalized = {} + for name, val in items: + key = section + "." + _normalize_name(name) + normalized[key] = val + return normalized + + def _get_environ_vars(self): + # type: () -> Iterable[Tuple[str, str]] + """Returns a generator with all environmental vars with prefix PIP_""" + for key, val in os.environ.items(): + should_be_yielded = ( + key.startswith("PIP_") and + key[4:].lower() not in self._ignore_env_names + ) + if should_be_yielded: + yield key[4:].lower(), val + + # XXX: This is patched in the tests. + def _iter_config_files(self): + # type: () -> Iterable[Tuple[Kind, List[str]]] + """Yields variant and configuration files associated with it. + + This should be treated like items of a dictionary. + """ + # SMELL: Move the conditions out of this function + + # environment variables have the lowest priority + config_file = os.environ.get('PIP_CONFIG_FILE', None) + if config_file is not None: + yield kinds.ENV, [config_file] + else: + yield kinds.ENV, [] + + config_files = get_configuration_files() + + # at the base we have any global configuration + yield kinds.GLOBAL, config_files[kinds.GLOBAL] + + # per-user configuration next + should_load_user_config = not self.isolated and not ( + config_file and os.path.exists(config_file) + ) + if should_load_user_config: + # The legacy config file is overridden by the new config file + yield kinds.USER, config_files[kinds.USER] + + # finally virtualenv configuration first trumping others + yield kinds.SITE, config_files[kinds.SITE] + + def _get_parser_to_modify(self): + # type: () -> Tuple[str, RawConfigParser] + # Determine which parser to modify + parsers = self._parsers[self.load_only] + if not parsers: + # This should not happen if everything works correctly. + raise ConfigurationError( + "Fatal Internal error [id=2]. Please report as a bug." + ) + + # Use the highest priority parser. + return parsers[-1] + + # XXX: This is patched in the tests. + def _mark_as_modified(self, fname, parser): + # type: (str, RawConfigParser) -> None + file_parser_tuple = (fname, parser) + if file_parser_tuple not in self._modified_parsers: + self._modified_parsers.append(file_parser_tuple) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/download.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/download.py new file mode 100644 index 0000000000000000000000000000000000000000..fc1f4dddde8aaa36a0f336d679b9cdeb899a7685 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/download.py @@ -0,0 +1,1177 @@ +from __future__ import absolute_import + +import cgi +import email.utils +import json +import logging +import mimetypes +import os +import platform +import re +import shutil +import sys + +from pip._vendor import requests, urllib3 +from pip._vendor.cachecontrol import CacheControlAdapter +from pip._vendor.cachecontrol.caches import FileCache +from pip._vendor.lockfile import LockError +from pip._vendor.requests.adapters import BaseAdapter, HTTPAdapter +from pip._vendor.requests.auth import AuthBase, HTTPBasicAuth +from pip._vendor.requests.models import CONTENT_CHUNK_SIZE, Response +from pip._vendor.requests.structures import CaseInsensitiveDict +from pip._vendor.requests.utils import get_netrc_auth +# NOTE: XMLRPC Client is not annotated in typeshed as on 2017-07-17, which is +# why we ignore the type on this import +from pip._vendor.six.moves import xmlrpc_client # type: ignore +from pip._vendor.six.moves.urllib import parse as urllib_parse +from pip._vendor.six.moves.urllib import request as urllib_request + +import pip +from pip._internal.exceptions import HashMismatch, InstallationError +from pip._internal.models.index import PyPI +# Import ssl from compat so the initial import occurs in only one place. +from pip._internal.utils.compat import HAS_TLS, ssl +from pip._internal.utils.encoding import auto_decode +from pip._internal.utils.filesystem import check_path_owner +from pip._internal.utils.glibc import libc_ver +from pip._internal.utils.marker_files import write_delete_marker_file +from pip._internal.utils.misc import ( + ARCHIVE_EXTENSIONS, ask, ask_input, ask_password, ask_path_exists, + backup_dir, consume, display_path, format_size, get_installed_version, + path_to_url, remove_auth_from_url, rmtree, split_auth_netloc_from_url, + splitext, unpack_file, +) +from pip._internal.utils.temp_dir import TempDirectory +from pip._internal.utils.typing import MYPY_CHECK_RUNNING +from pip._internal.utils.ui import DownloadProgressProvider +from pip._internal.vcs import vcs + +if MYPY_CHECK_RUNNING: + from typing import ( + Optional, Tuple, Dict, IO, Text, Union + ) + from optparse import Values + from pip._internal.models.link import Link + from pip._internal.utils.hashes import Hashes + from pip._internal.vcs.versioncontrol import AuthInfo, VersionControl + + Credentials = Tuple[str, str, str] + + +__all__ = ['get_file_content', + 'is_url', 'url_to_path', 'path_to_url', + 'is_archive_file', 'unpack_vcs_link', + 'unpack_file_url', 'is_vcs_url', 'is_file_url', + 'unpack_http_url', 'unpack_url', + 'parse_content_disposition', 'sanitize_content_filename'] + + +logger = logging.getLogger(__name__) + + +try: + import keyring # noqa +except ImportError: + keyring = None +except Exception as exc: + logger.warning("Keyring is skipped due to an exception: %s", + str(exc)) + keyring = None + +# These are environment variables present when running under various +# CI systems. For each variable, some CI systems that use the variable +# are indicated. The collection was chosen so that for each of a number +# of popular systems, at least one of the environment variables is used. +# This list is used to provide some indication of and lower bound for +# CI traffic to PyPI. Thus, it is okay if the list is not comprehensive. +# For more background, see: https://github.com/pypa/pip/issues/5499 +CI_ENVIRONMENT_VARIABLES = ( + # Azure Pipelines + 'BUILD_BUILDID', + # Jenkins + 'BUILD_ID', + # AppVeyor, CircleCI, Codeship, Gitlab CI, Shippable, Travis CI + 'CI', + # Explicit environment variable. + 'PIP_IS_CI', +) + + +def looks_like_ci(): + # type: () -> bool + """ + Return whether it looks like pip is running under CI. + """ + # We don't use the method of checking for a tty (e.g. using isatty()) + # because some CI systems mimic a tty (e.g. Travis CI). Thus that + # method doesn't provide definitive information in either direction. + return any(name in os.environ for name in CI_ENVIRONMENT_VARIABLES) + + +def user_agent(): + """ + Return a string representing the user agent. + """ + data = { + "installer": {"name": "pip", "version": pip.__version__}, + "python": platform.python_version(), + "implementation": { + "name": platform.python_implementation(), + }, + } + + if data["implementation"]["name"] == 'CPython': + data["implementation"]["version"] = platform.python_version() + elif data["implementation"]["name"] == 'PyPy': + if sys.pypy_version_info.releaselevel == 'final': + pypy_version_info = sys.pypy_version_info[:3] + else: + pypy_version_info = sys.pypy_version_info + data["implementation"]["version"] = ".".join( + [str(x) for x in pypy_version_info] + ) + elif data["implementation"]["name"] == 'Jython': + # Complete Guess + data["implementation"]["version"] = platform.python_version() + elif data["implementation"]["name"] == 'IronPython': + # Complete Guess + data["implementation"]["version"] = platform.python_version() + + if sys.platform.startswith("linux"): + from pip._vendor import distro + distro_infos = dict(filter( + lambda x: x[1], + zip(["name", "version", "id"], distro.linux_distribution()), + )) + libc = dict(filter( + lambda x: x[1], + zip(["lib", "version"], libc_ver()), + )) + if libc: + distro_infos["libc"] = libc + if distro_infos: + data["distro"] = distro_infos + + if sys.platform.startswith("darwin") and platform.mac_ver()[0]: + data["distro"] = {"name": "macOS", "version": platform.mac_ver()[0]} + + if platform.system(): + data.setdefault("system", {})["name"] = platform.system() + + if platform.release(): + data.setdefault("system", {})["release"] = platform.release() + + if platform.machine(): + data["cpu"] = platform.machine() + + if HAS_TLS: + data["openssl_version"] = ssl.OPENSSL_VERSION + + setuptools_version = get_installed_version("setuptools") + if setuptools_version is not None: + data["setuptools_version"] = setuptools_version + + # Use None rather than False so as not to give the impression that + # pip knows it is not being run under CI. Rather, it is a null or + # inconclusive result. Also, we include some value rather than no + # value to make it easier to know that the check has been run. + data["ci"] = True if looks_like_ci() else None + + user_data = os.environ.get("PIP_USER_AGENT_USER_DATA") + if user_data is not None: + data["user_data"] = user_data + + return "{data[installer][name]}/{data[installer][version]} {json}".format( + data=data, + json=json.dumps(data, separators=(",", ":"), sort_keys=True), + ) + + +def _get_keyring_auth(url, username): + """Return the tuple auth for a given url from keyring.""" + if not url or not keyring: + return None + + try: + try: + get_credential = keyring.get_credential + except AttributeError: + pass + else: + logger.debug("Getting credentials from keyring for %s", url) + cred = get_credential(url, username) + if cred is not None: + return cred.username, cred.password + return None + + if username: + logger.debug("Getting password from keyring for %s", url) + password = keyring.get_password(url, username) + if password: + return username, password + + except Exception as exc: + logger.warning("Keyring is skipped due to an exception: %s", + str(exc)) + + +class MultiDomainBasicAuth(AuthBase): + + def __init__(self, prompting=True, index_urls=None): + # type: (bool, Optional[Values]) -> None + self.prompting = prompting + self.index_urls = index_urls + self.passwords = {} # type: Dict[str, AuthInfo] + # When the user is prompted to enter credentials and keyring is + # available, we will offer to save them. If the user accepts, + # this value is set to the credentials they entered. After the + # request authenticates, the caller should call + # ``save_credentials`` to save these. + self._credentials_to_save = None # type: Optional[Credentials] + + def _get_index_url(self, url): + """Return the original index URL matching the requested URL. + + Cached or dynamically generated credentials may work against + the original index URL rather than just the netloc. + + The provided url should have had its username and password + removed already. If the original index url had credentials then + they will be included in the return value. + + Returns None if no matching index was found, or if --no-index + was specified by the user. + """ + if not url or not self.index_urls: + return None + + for u in self.index_urls: + prefix = remove_auth_from_url(u).rstrip("/") + "/" + if url.startswith(prefix): + return u + + def _get_new_credentials(self, original_url, allow_netrc=True, + allow_keyring=True): + """Find and return credentials for the specified URL.""" + # Split the credentials and netloc from the url. + url, netloc, url_user_password = split_auth_netloc_from_url( + original_url) + + # Start with the credentials embedded in the url + username, password = url_user_password + if username is not None and password is not None: + logger.debug("Found credentials in url for %s", netloc) + return url_user_password + + # Find a matching index url for this request + index_url = self._get_index_url(url) + if index_url: + # Split the credentials from the url. + index_info = split_auth_netloc_from_url(index_url) + if index_info: + index_url, _, index_url_user_password = index_info + logger.debug("Found index url %s", index_url) + + # If an index URL was found, try its embedded credentials + if index_url and index_url_user_password[0] is not None: + username, password = index_url_user_password + if username is not None and password is not None: + logger.debug("Found credentials in index url for %s", netloc) + return index_url_user_password + + # Get creds from netrc if we still don't have them + if allow_netrc: + netrc_auth = get_netrc_auth(original_url) + if netrc_auth: + logger.debug("Found credentials in netrc for %s", netloc) + return netrc_auth + + # If we don't have a password and keyring is available, use it. + if allow_keyring: + # The index url is more specific than the netloc, so try it first + kr_auth = (_get_keyring_auth(index_url, username) or + _get_keyring_auth(netloc, username)) + if kr_auth: + logger.debug("Found credentials in keyring for %s", netloc) + return kr_auth + + return username, password + + def _get_url_and_credentials(self, original_url): + """Return the credentials to use for the provided URL. + + If allowed, netrc and keyring may be used to obtain the + correct credentials. + + Returns (url_without_credentials, username, password). Note + that even if the original URL contains credentials, this + function may return a different username and password. + """ + url, netloc, _ = split_auth_netloc_from_url(original_url) + + # Use any stored credentials that we have for this netloc + username, password = self.passwords.get(netloc, (None, None)) + + if username is None and password is None: + # No stored credentials. Acquire new credentials without prompting + # the user. (e.g. from netrc, keyring, or the URL itself) + username, password = self._get_new_credentials(original_url) + + if username is not None or password is not None: + # Convert the username and password if they're None, so that + # this netloc will show up as "cached" in the conditional above. + # Further, HTTPBasicAuth doesn't accept None, so it makes sense to + # cache the value that is going to be used. + username = username or "" + password = password or "" + + # Store any acquired credentials. + self.passwords[netloc] = (username, password) + + assert ( + # Credentials were found + (username is not None and password is not None) or + # Credentials were not found + (username is None and password is None) + ), "Could not load credentials from url: {}".format(original_url) + + return url, username, password + + def __call__(self, req): + # Get credentials for this request + url, username, password = self._get_url_and_credentials(req.url) + + # Set the url of the request to the url without any credentials + req.url = url + + if username is not None and password is not None: + # Send the basic auth with this request + req = HTTPBasicAuth(username, password)(req) + + # Attach a hook to handle 401 responses + req.register_hook("response", self.handle_401) + + return req + + # Factored out to allow for easy patching in tests + def _prompt_for_password(self, netloc): + username = ask_input("User for %s: " % netloc) + if not username: + return None, None + auth = _get_keyring_auth(netloc, username) + if auth: + return auth[0], auth[1], False + password = ask_password("Password: ") + return username, password, True + + # Factored out to allow for easy patching in tests + def _should_save_password_to_keyring(self): + if not keyring: + return False + return ask("Save credentials to keyring [y/N]: ", ["y", "n"]) == "y" + + def handle_401(self, resp, **kwargs): + # We only care about 401 responses, anything else we want to just + # pass through the actual response + if resp.status_code != 401: + return resp + + # We are not able to prompt the user so simply return the response + if not self.prompting: + return resp + + parsed = urllib_parse.urlparse(resp.url) + + # Prompt the user for a new username and password + username, password, save = self._prompt_for_password(parsed.netloc) + + # Store the new username and password to use for future requests + self._credentials_to_save = None + if username is not None and password is not None: + self.passwords[parsed.netloc] = (username, password) + + # Prompt to save the password to keyring + if save and self._should_save_password_to_keyring(): + self._credentials_to_save = (parsed.netloc, username, password) + + # Consume content and release the original connection to allow our new + # request to reuse the same one. + resp.content + resp.raw.release_conn() + + # Add our new username and password to the request + req = HTTPBasicAuth(username or "", password or "")(resp.request) + req.register_hook("response", self.warn_on_401) + + # On successful request, save the credentials that were used to + # keyring. (Note that if the user responded "no" above, this member + # is not set and nothing will be saved.) + if self._credentials_to_save: + req.register_hook("response", self.save_credentials) + + # Send our new request + new_resp = resp.connection.send(req, **kwargs) + new_resp.history.append(resp) + + return new_resp + + def warn_on_401(self, resp, **kwargs): + """Response callback to warn about incorrect credentials.""" + if resp.status_code == 401: + logger.warning('401 Error, Credentials not correct for %s', + resp.request.url) + + def save_credentials(self, resp, **kwargs): + """Response callback to save credentials on success.""" + assert keyring is not None, "should never reach here without keyring" + if not keyring: + return + + creds = self._credentials_to_save + self._credentials_to_save = None + if creds and resp.status_code < 400: + try: + logger.info('Saving credentials to keyring') + keyring.set_password(*creds) + except Exception: + logger.exception('Failed to save credentials') + + +class LocalFSAdapter(BaseAdapter): + + def send(self, request, stream=None, timeout=None, verify=None, cert=None, + proxies=None): + pathname = url_to_path(request.url) + + resp = Response() + resp.status_code = 200 + resp.url = request.url + + try: + stats = os.stat(pathname) + except OSError as exc: + resp.status_code = 404 + resp.raw = exc + else: + modified = email.utils.formatdate(stats.st_mtime, usegmt=True) + content_type = mimetypes.guess_type(pathname)[0] or "text/plain" + resp.headers = CaseInsensitiveDict({ + "Content-Type": content_type, + "Content-Length": stats.st_size, + "Last-Modified": modified, + }) + + resp.raw = open(pathname, "rb") + resp.close = resp.raw.close + + return resp + + def close(self): + pass + + +class SafeFileCache(FileCache): + """ + A file based cache which is safe to use even when the target directory may + not be accessible or writable. + """ + + def __init__(self, *args, **kwargs): + super(SafeFileCache, self).__init__(*args, **kwargs) + + # Check to ensure that the directory containing our cache directory + # is owned by the user current executing pip. If it does not exist + # we will check the parent directory until we find one that does exist. + # If it is not owned by the user executing pip then we will disable + # the cache and log a warning. + if not check_path_owner(self.directory): + logger.warning( + "The directory '%s' or its parent directory is not owned by " + "the current user and the cache has been disabled. Please " + "check the permissions and owner of that directory. If " + "executing pip with sudo, you may want sudo's -H flag.", + self.directory, + ) + + # Set our directory to None to disable the Cache + self.directory = None + + def get(self, *args, **kwargs): + # If we don't have a directory, then the cache should be a no-op. + if self.directory is None: + return + + try: + return super(SafeFileCache, self).get(*args, **kwargs) + except (LockError, OSError, IOError): + # We intentionally silence this error, if we can't access the cache + # then we can just skip caching and process the request as if + # caching wasn't enabled. + pass + + def set(self, *args, **kwargs): + # If we don't have a directory, then the cache should be a no-op. + if self.directory is None: + return + + try: + return super(SafeFileCache, self).set(*args, **kwargs) + except (LockError, OSError, IOError): + # We intentionally silence this error, if we can't access the cache + # then we can just skip caching and process the request as if + # caching wasn't enabled. + pass + + def delete(self, *args, **kwargs): + # If we don't have a directory, then the cache should be a no-op. + if self.directory is None: + return + + try: + return super(SafeFileCache, self).delete(*args, **kwargs) + except (LockError, OSError, IOError): + # We intentionally silence this error, if we can't access the cache + # then we can just skip caching and process the request as if + # caching wasn't enabled. + pass + + +class InsecureHTTPAdapter(HTTPAdapter): + + def cert_verify(self, conn, url, verify, cert): + conn.cert_reqs = 'CERT_NONE' + conn.ca_certs = None + + +class PipSession(requests.Session): + + timeout = None # type: Optional[int] + + def __init__(self, *args, **kwargs): + retries = kwargs.pop("retries", 0) + cache = kwargs.pop("cache", None) + insecure_hosts = kwargs.pop("insecure_hosts", []) + index_urls = kwargs.pop("index_urls", None) + + super(PipSession, self).__init__(*args, **kwargs) + + # Attach our User Agent to the request + self.headers["User-Agent"] = user_agent() + + # Attach our Authentication handler to the session + self.auth = MultiDomainBasicAuth(index_urls=index_urls) + + # Create our urllib3.Retry instance which will allow us to customize + # how we handle retries. + retries = urllib3.Retry( + # Set the total number of retries that a particular request can + # have. + total=retries, + + # A 503 error from PyPI typically means that the Fastly -> Origin + # connection got interrupted in some way. A 503 error in general + # is typically considered a transient error so we'll go ahead and + # retry it. + # A 500 may indicate transient error in Amazon S3 + # A 520 or 527 - may indicate transient error in CloudFlare + status_forcelist=[500, 503, 520, 527], + + # Add a small amount of back off between failed requests in + # order to prevent hammering the service. + backoff_factor=0.25, + ) + + # We want to _only_ cache responses on securely fetched origins. We do + # this because we can't validate the response of an insecurely fetched + # origin, and we don't want someone to be able to poison the cache and + # require manual eviction from the cache to fix it. + if cache: + secure_adapter = CacheControlAdapter( + cache=SafeFileCache(cache, use_dir_lock=True), + max_retries=retries, + ) + else: + secure_adapter = HTTPAdapter(max_retries=retries) + + # Our Insecure HTTPAdapter disables HTTPS validation. It does not + # support caching (see above) so we'll use it for all http:// URLs as + # well as any https:// host that we've marked as ignoring TLS errors + # for. + insecure_adapter = InsecureHTTPAdapter(max_retries=retries) + # Save this for later use in add_insecure_host(). + self._insecure_adapter = insecure_adapter + + self.mount("https://", secure_adapter) + self.mount("http://", insecure_adapter) + + # Enable file:// urls + self.mount("file://", LocalFSAdapter()) + + # We want to use a non-validating adapter for any requests which are + # deemed insecure. + for host in insecure_hosts: + self.add_insecure_host(host) + + def add_insecure_host(self, host): + # type: (str) -> None + self.mount('https://{}/'.format(host), self._insecure_adapter) + + def request(self, method, url, *args, **kwargs): + # Allow setting a default timeout on a session + kwargs.setdefault("timeout", self.timeout) + + # Dispatch the actual request + return super(PipSession, self).request(method, url, *args, **kwargs) + + +def get_file_content(url, comes_from=None, session=None): + # type: (str, Optional[str], Optional[PipSession]) -> Tuple[str, Text] + """Gets the content of a file; it may be a filename, file: URL, or + http: URL. Returns (location, content). Content is unicode. + + :param url: File path or url. + :param comes_from: Origin description of requirements. + :param session: Instance of pip.download.PipSession. + """ + if session is None: + raise TypeError( + "get_file_content() missing 1 required keyword argument: 'session'" + ) + + match = _scheme_re.search(url) + if match: + scheme = match.group(1).lower() + if (scheme == 'file' and comes_from and + comes_from.startswith('http')): + raise InstallationError( + 'Requirements file %s references URL %s, which is local' + % (comes_from, url)) + if scheme == 'file': + path = url.split(':', 1)[1] + path = path.replace('\\', '/') + match = _url_slash_drive_re.match(path) + if match: + path = match.group(1) + ':' + path.split('|', 1)[1] + path = urllib_parse.unquote(path) + if path.startswith('/'): + path = '/' + path.lstrip('/') + url = path + else: + # FIXME: catch some errors + resp = session.get(url) + resp.raise_for_status() + return resp.url, resp.text + try: + with open(url, 'rb') as f: + content = auto_decode(f.read()) + except IOError as exc: + raise InstallationError( + 'Could not open requirements file: %s' % str(exc) + ) + return url, content + + +_scheme_re = re.compile(r'^(http|https|file):', re.I) +_url_slash_drive_re = re.compile(r'/*([a-z])\|', re.I) + + +def is_url(name): + # type: (Union[str, Text]) -> bool + """Returns true if the name looks like a URL""" + if ':' not in name: + return False + scheme = name.split(':', 1)[0].lower() + return scheme in ['http', 'https', 'file', 'ftp'] + vcs.all_schemes + + +def url_to_path(url): + # type: (str) -> str + """ + Convert a file: URL to a path. + """ + assert url.startswith('file:'), ( + "You can only turn file: urls into filenames (not %r)" % url) + + _, netloc, path, _, _ = urllib_parse.urlsplit(url) + + if not netloc or netloc == 'localhost': + # According to RFC 8089, same as empty authority. + netloc = '' + elif sys.platform == 'win32': + # If we have a UNC path, prepend UNC share notation. + netloc = '\\\\' + netloc + else: + raise ValueError( + 'non-local file URIs are not supported on this platform: %r' + % url + ) + + path = urllib_request.url2pathname(netloc + path) + return path + + +def is_archive_file(name): + # type: (str) -> bool + """Return True if `name` is a considered as an archive file.""" + ext = splitext(name)[1].lower() + if ext in ARCHIVE_EXTENSIONS: + return True + return False + + +def unpack_vcs_link(link, location): + vcs_backend = _get_used_vcs_backend(link) + vcs_backend.unpack(location, url=link.url) + + +def _get_used_vcs_backend(link): + # type: (Link) -> Optional[VersionControl] + """ + Return a VersionControl object or None. + """ + for vcs_backend in vcs.backends: + if link.scheme in vcs_backend.schemes: + return vcs_backend + return None + + +def is_vcs_url(link): + # type: (Link) -> bool + return bool(_get_used_vcs_backend(link)) + + +def is_file_url(link): + # type: (Link) -> bool + return link.url.lower().startswith('file:') + + +def is_dir_url(link): + # type: (Link) -> bool + """Return whether a file:// Link points to a directory. + + ``link`` must not have any other scheme but file://. Call is_file_url() + first. + + """ + link_path = url_to_path(link.url_without_fragment) + return os.path.isdir(link_path) + + +def _progress_indicator(iterable, *args, **kwargs): + return iterable + + +def _download_url( + resp, # type: Response + link, # type: Link + content_file, # type: IO + hashes, # type: Optional[Hashes] + progress_bar # type: str +): + # type: (...) -> None + try: + total_length = int(resp.headers['content-length']) + except (ValueError, KeyError, TypeError): + total_length = 0 + + cached_resp = getattr(resp, "from_cache", False) + if logger.getEffectiveLevel() > logging.INFO: + show_progress = False + elif cached_resp: + show_progress = False + elif total_length > (40 * 1000): + show_progress = True + elif not total_length: + show_progress = True + else: + show_progress = False + + show_url = link.show_url + + def resp_read(chunk_size): + try: + # Special case for urllib3. + for chunk in resp.raw.stream( + chunk_size, + # We use decode_content=False here because we don't + # want urllib3 to mess with the raw bytes we get + # from the server. If we decompress inside of + # urllib3 then we cannot verify the checksum + # because the checksum will be of the compressed + # file. This breakage will only occur if the + # server adds a Content-Encoding header, which + # depends on how the server was configured: + # - Some servers will notice that the file isn't a + # compressible file and will leave the file alone + # and with an empty Content-Encoding + # - Some servers will notice that the file is + # already compressed and will leave the file + # alone and will add a Content-Encoding: gzip + # header + # - Some servers won't notice anything at all and + # will take a file that's already been compressed + # and compress it again and set the + # Content-Encoding: gzip header + # + # By setting this not to decode automatically we + # hope to eliminate problems with the second case. + decode_content=False): + yield chunk + except AttributeError: + # Standard file-like object. + while True: + chunk = resp.raw.read(chunk_size) + if not chunk: + break + yield chunk + + def written_chunks(chunks): + for chunk in chunks: + content_file.write(chunk) + yield chunk + + progress_indicator = _progress_indicator + + if link.netloc == PyPI.netloc: + url = show_url + else: + url = link.url_without_fragment + + if show_progress: # We don't show progress on cached responses + progress_indicator = DownloadProgressProvider(progress_bar, + max=total_length) + if total_length: + logger.info("Downloading %s (%s)", url, format_size(total_length)) + else: + logger.info("Downloading %s", url) + elif cached_resp: + logger.info("Using cached %s", url) + else: + logger.info("Downloading %s", url) + + logger.debug('Downloading from URL %s', link) + + downloaded_chunks = written_chunks( + progress_indicator( + resp_read(CONTENT_CHUNK_SIZE), + CONTENT_CHUNK_SIZE + ) + ) + if hashes: + hashes.check_against_chunks(downloaded_chunks) + else: + consume(downloaded_chunks) + + +def _copy_file(filename, location, link): + copy = True + download_location = os.path.join(location, link.filename) + if os.path.exists(download_location): + response = ask_path_exists( + 'The file %s exists. (i)gnore, (w)ipe, (b)ackup, (a)abort' % + display_path(download_location), ('i', 'w', 'b', 'a')) + if response == 'i': + copy = False + elif response == 'w': + logger.warning('Deleting %s', display_path(download_location)) + os.remove(download_location) + elif response == 'b': + dest_file = backup_dir(download_location) + logger.warning( + 'Backing up %s to %s', + display_path(download_location), + display_path(dest_file), + ) + shutil.move(download_location, dest_file) + elif response == 'a': + sys.exit(-1) + if copy: + shutil.copy(filename, download_location) + logger.info('Saved %s', display_path(download_location)) + + +def unpack_http_url( + link, # type: Link + location, # type: str + download_dir=None, # type: Optional[str] + session=None, # type: Optional[PipSession] + hashes=None, # type: Optional[Hashes] + progress_bar="on" # type: str +): + # type: (...) -> None + if session is None: + raise TypeError( + "unpack_http_url() missing 1 required keyword argument: 'session'" + ) + + with TempDirectory(kind="unpack") as temp_dir: + # If a download dir is specified, is the file already downloaded there? + already_downloaded_path = None + if download_dir: + already_downloaded_path = _check_download_dir(link, + download_dir, + hashes) + + if already_downloaded_path: + from_path = already_downloaded_path + content_type = mimetypes.guess_type(from_path)[0] + else: + # let's download to a tmp dir + from_path, content_type = _download_http_url(link, + session, + temp_dir.path, + hashes, + progress_bar) + + # unpack the archive to the build dir location. even when only + # downloading archives, they have to be unpacked to parse dependencies + unpack_file(from_path, location, content_type, link) + + # a download dir is specified; let's copy the archive there + if download_dir and not already_downloaded_path: + _copy_file(from_path, download_dir, link) + + if not already_downloaded_path: + os.unlink(from_path) + + +def unpack_file_url( + link, # type: Link + location, # type: str + download_dir=None, # type: Optional[str] + hashes=None # type: Optional[Hashes] +): + # type: (...) -> None + """Unpack link into location. + + If download_dir is provided and link points to a file, make a copy + of the link file inside download_dir. + """ + link_path = url_to_path(link.url_without_fragment) + + # If it's a url to a local directory + if is_dir_url(link): + if os.path.isdir(location): + rmtree(location) + shutil.copytree(link_path, location, symlinks=True) + if download_dir: + logger.info('Link is a directory, ignoring download_dir') + return + + # If --require-hashes is off, `hashes` is either empty, the + # link's embedded hash, or MissingHashes; it is required to + # match. If --require-hashes is on, we are satisfied by any + # hash in `hashes` matching: a URL-based or an option-based + # one; no internet-sourced hash will be in `hashes`. + if hashes: + hashes.check_against_path(link_path) + + # If a download dir is specified, is the file already there and valid? + already_downloaded_path = None + if download_dir: + already_downloaded_path = _check_download_dir(link, + download_dir, + hashes) + + if already_downloaded_path: + from_path = already_downloaded_path + else: + from_path = link_path + + content_type = mimetypes.guess_type(from_path)[0] + + # unpack the archive to the build dir location. even when only downloading + # archives, they have to be unpacked to parse dependencies + unpack_file(from_path, location, content_type, link) + + # a download dir is specified and not already downloaded + if download_dir and not already_downloaded_path: + _copy_file(from_path, download_dir, link) + + +class PipXmlrpcTransport(xmlrpc_client.Transport): + """Provide a `xmlrpclib.Transport` implementation via a `PipSession` + object. + """ + + def __init__(self, index_url, session, use_datetime=False): + xmlrpc_client.Transport.__init__(self, use_datetime) + index_parts = urllib_parse.urlparse(index_url) + self._scheme = index_parts.scheme + self._session = session + + def request(self, host, handler, request_body, verbose=False): + parts = (self._scheme, host, handler, None, None, None) + url = urllib_parse.urlunparse(parts) + try: + headers = {'Content-Type': 'text/xml'} + response = self._session.post(url, data=request_body, + headers=headers, stream=True) + response.raise_for_status() + self.verbose = verbose + return self.parse_response(response.raw) + except requests.HTTPError as exc: + logger.critical( + "HTTP error %s while getting %s", + exc.response.status_code, url, + ) + raise + + +def unpack_url( + link, # type: Link + location, # type: str + download_dir=None, # type: Optional[str] + only_download=False, # type: bool + session=None, # type: Optional[PipSession] + hashes=None, # type: Optional[Hashes] + progress_bar="on" # type: str +): + # type: (...) -> None + """Unpack link. + If link is a VCS link: + if only_download, export into download_dir and ignore location + else unpack into location + for other types of link: + - unpack into location + - if download_dir, copy the file into download_dir + - if only_download, mark location for deletion + + :param hashes: A Hashes object, one of whose embedded hashes must match, + or HashMismatch will be raised. If the Hashes is empty, no matches are + required, and unhashable types of requirements (like VCS ones, which + would ordinarily raise HashUnsupported) are allowed. + """ + # non-editable vcs urls + if is_vcs_url(link): + unpack_vcs_link(link, location) + + # file urls + elif is_file_url(link): + unpack_file_url(link, location, download_dir, hashes=hashes) + + # http urls + else: + if session is None: + session = PipSession() + + unpack_http_url( + link, + location, + download_dir, + session, + hashes=hashes, + progress_bar=progress_bar + ) + if only_download: + write_delete_marker_file(location) + + +def sanitize_content_filename(filename): + # type: (str) -> str + """ + Sanitize the "filename" value from a Content-Disposition header. + """ + return os.path.basename(filename) + + +def parse_content_disposition(content_disposition, default_filename): + # type: (str, str) -> str + """ + Parse the "filename" value from a Content-Disposition header, and + return the default filename if the result is empty. + """ + _type, params = cgi.parse_header(content_disposition) + filename = params.get('filename') + if filename: + # We need to sanitize the filename to prevent directory traversal + # in case the filename contains ".." path parts. + filename = sanitize_content_filename(filename) + return filename or default_filename + + +def _download_http_url( + link, # type: Link + session, # type: PipSession + temp_dir, # type: str + hashes, # type: Optional[Hashes] + progress_bar # type: str +): + # type: (...) -> Tuple[str, str] + """Download link url into temp_dir using provided session""" + target_url = link.url.split('#', 1)[0] + try: + resp = session.get( + target_url, + # We use Accept-Encoding: identity here because requests + # defaults to accepting compressed responses. This breaks in + # a variety of ways depending on how the server is configured. + # - Some servers will notice that the file isn't a compressible + # file and will leave the file alone and with an empty + # Content-Encoding + # - Some servers will notice that the file is already + # compressed and will leave the file alone and will add a + # Content-Encoding: gzip header + # - Some servers won't notice anything at all and will take + # a file that's already been compressed and compress it again + # and set the Content-Encoding: gzip header + # By setting this to request only the identity encoding We're + # hoping to eliminate the third case. Hopefully there does not + # exist a server which when given a file will notice it is + # already compressed and that you're not asking for a + # compressed file and will then decompress it before sending + # because if that's the case I don't think it'll ever be + # possible to make this work. + headers={"Accept-Encoding": "identity"}, + stream=True, + ) + resp.raise_for_status() + except requests.HTTPError as exc: + logger.critical( + "HTTP error %s while getting %s", exc.response.status_code, link, + ) + raise + + content_type = resp.headers.get('content-type', '') + filename = link.filename # fallback + # Have a look at the Content-Disposition header for a better guess + content_disposition = resp.headers.get('content-disposition') + if content_disposition: + filename = parse_content_disposition(content_disposition, filename) + ext = splitext(filename)[1] # type: Optional[str] + if not ext: + ext = mimetypes.guess_extension(content_type) + if ext: + filename += ext + if not ext and link.url != resp.url: + ext = os.path.splitext(resp.url)[1] + if ext: + filename += ext + file_path = os.path.join(temp_dir, filename) + with open(file_path, 'wb') as content_file: + _download_url(resp, link, content_file, hashes, progress_bar) + return file_path, content_type + + +def _check_download_dir(link, download_dir, hashes): + # type: (Link, str, Optional[Hashes]) -> Optional[str] + """ Check download_dir for previously downloaded file with correct hash + If a correct file is found return its path else None + """ + download_path = os.path.join(download_dir, link.filename) + if os.path.exists(download_path): + # If already downloaded, does its hash match? + logger.info('File was already downloaded %s', download_path) + if hashes: + try: + hashes.check_against_path(download_path) + except HashMismatch: + logger.warning( + 'Previously-downloaded file %s has bad hash. ' + 'Re-downloading.', + download_path + ) + os.unlink(download_path) + return None + return download_path + return None diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/exceptions.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..096adcd6c5aadce5c73506c078d8ce9499e020af --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/exceptions.py @@ -0,0 +1,305 @@ +"""Exceptions used throughout package""" +from __future__ import absolute_import + +from itertools import chain, groupby, repeat + +from pip._vendor.six import iteritems + +from pip._internal.utils.typing import MYPY_CHECK_RUNNING + +if MYPY_CHECK_RUNNING: + from typing import Optional + from pip._vendor.pkg_resources import Distribution + from pip._internal.req.req_install import InstallRequirement + + +class PipError(Exception): + """Base pip exception""" + + +class ConfigurationError(PipError): + """General exception in configuration""" + + +class InstallationError(PipError): + """General exception during installation""" + + +class UninstallationError(PipError): + """General exception during uninstallation""" + + +class NoneMetadataError(PipError): + """ + Raised when accessing "METADATA" or "PKG-INFO" metadata for a + pip._vendor.pkg_resources.Distribution object and + `dist.has_metadata('METADATA')` returns True but + `dist.get_metadata('METADATA')` returns None (and similarly for + "PKG-INFO"). + """ + + def __init__(self, dist, metadata_name): + # type: (Distribution, str) -> None + """ + :param dist: A Distribution object. + :param metadata_name: The name of the metadata being accessed + (can be "METADATA" or "PKG-INFO"). + """ + self.dist = dist + self.metadata_name = metadata_name + + def __str__(self): + # type: () -> str + # Use `dist` in the error message because its stringification + # includes more information, like the version and location. + return ( + 'None {} metadata found for distribution: {}'.format( + self.metadata_name, self.dist, + ) + ) + + +class DistributionNotFound(InstallationError): + """Raised when a distribution cannot be found to satisfy a requirement""" + + +class RequirementsFileParseError(InstallationError): + """Raised when a general error occurs parsing a requirements file line.""" + + +class BestVersionAlreadyInstalled(PipError): + """Raised when the most up-to-date version of a package is already + installed.""" + + +class BadCommand(PipError): + """Raised when virtualenv or a command is not found""" + + +class CommandError(PipError): + """Raised when there is an error in command-line arguments""" + + +class PreviousBuildDirError(PipError): + """Raised when there's a previous conflicting build directory""" + + +class InvalidWheelFilename(InstallationError): + """Invalid wheel filename.""" + + +class UnsupportedWheel(InstallationError): + """Unsupported wheel.""" + + +class HashErrors(InstallationError): + """Multiple HashError instances rolled into one for reporting""" + + def __init__(self): + self.errors = [] + + def append(self, error): + self.errors.append(error) + + def __str__(self): + lines = [] + self.errors.sort(key=lambda e: e.order) + for cls, errors_of_cls in groupby(self.errors, lambda e: e.__class__): + lines.append(cls.head) + lines.extend(e.body() for e in errors_of_cls) + if lines: + return '\n'.join(lines) + + def __nonzero__(self): + return bool(self.errors) + + def __bool__(self): + return self.__nonzero__() + + +class HashError(InstallationError): + """ + A failure to verify a package against known-good hashes + + :cvar order: An int sorting hash exception classes by difficulty of + recovery (lower being harder), so the user doesn't bother fretting + about unpinned packages when he has deeper issues, like VCS + dependencies, to deal with. Also keeps error reports in a + deterministic order. + :cvar head: A section heading for display above potentially many + exceptions of this kind + :ivar req: The InstallRequirement that triggered this error. This is + pasted on after the exception is instantiated, because it's not + typically available earlier. + + """ + req = None # type: Optional[InstallRequirement] + head = '' + + def body(self): + """Return a summary of me for display under the heading. + + This default implementation simply prints a description of the + triggering requirement. + + :param req: The InstallRequirement that provoked this error, with + populate_link() having already been called + + """ + return ' %s' % self._requirement_name() + + def __str__(self): + return '%s\n%s' % (self.head, self.body()) + + def _requirement_name(self): + """Return a description of the requirement that triggered me. + + This default implementation returns long description of the req, with + line numbers + + """ + return str(self.req) if self.req else 'unknown package' + + +class VcsHashUnsupported(HashError): + """A hash was provided for a version-control-system-based requirement, but + we don't have a method for hashing those.""" + + order = 0 + head = ("Can't verify hashes for these requirements because we don't " + "have a way to hash version control repositories:") + + +class DirectoryUrlHashUnsupported(HashError): + """A hash was provided for a version-control-system-based requirement, but + we don't have a method for hashing those.""" + + order = 1 + head = ("Can't verify hashes for these file:// requirements because they " + "point to directories:") + + +class HashMissing(HashError): + """A hash was needed for a requirement but is absent.""" + + order = 2 + head = ('Hashes are required in --require-hashes mode, but they are ' + 'missing from some requirements. Here is a list of those ' + 'requirements along with the hashes their downloaded archives ' + 'actually had. Add lines like these to your requirements files to ' + 'prevent tampering. (If you did not enable --require-hashes ' + 'manually, note that it turns on automatically when any package ' + 'has a hash.)') + + def __init__(self, gotten_hash): + """ + :param gotten_hash: The hash of the (possibly malicious) archive we + just downloaded + """ + self.gotten_hash = gotten_hash + + def body(self): + # Dodge circular import. + from pip._internal.utils.hashes import FAVORITE_HASH + + package = None + if self.req: + # In the case of URL-based requirements, display the original URL + # seen in the requirements file rather than the package name, + # so the output can be directly copied into the requirements file. + package = (self.req.original_link if self.req.original_link + # In case someone feeds something downright stupid + # to InstallRequirement's constructor. + else getattr(self.req, 'req', None)) + return ' %s --hash=%s:%s' % (package or 'unknown package', + FAVORITE_HASH, + self.gotten_hash) + + +class HashUnpinned(HashError): + """A requirement had a hash specified but was not pinned to a specific + version.""" + + order = 3 + head = ('In --require-hashes mode, all requirements must have their ' + 'versions pinned with ==. These do not:') + + +class HashMismatch(HashError): + """ + Distribution file hash values don't match. + + :ivar package_name: The name of the package that triggered the hash + mismatch. Feel free to write to this after the exception is raise to + improve its error message. + + """ + order = 4 + head = ('THESE PACKAGES DO NOT MATCH THE HASHES FROM THE REQUIREMENTS ' + 'FILE. If you have updated the package versions, please update ' + 'the hashes. Otherwise, examine the package contents carefully; ' + 'someone may have tampered with them.') + + def __init__(self, allowed, gots): + """ + :param allowed: A dict of algorithm names pointing to lists of allowed + hex digests + :param gots: A dict of algorithm names pointing to hashes we + actually got from the files under suspicion + """ + self.allowed = allowed + self.gots = gots + + def body(self): + return ' %s:\n%s' % (self._requirement_name(), + self._hash_comparison()) + + def _hash_comparison(self): + """ + Return a comparison of actual and expected hash values. + + Example:: + + Expected sha256 abcdeabcdeabcdeabcdeabcdeabcdeabcdeabcdeabcde + or 123451234512345123451234512345123451234512345 + Got bcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdefbcdef + + """ + def hash_then_or(hash_name): + # For now, all the decent hashes have 6-char names, so we can get + # away with hard-coding space literals. + return chain([hash_name], repeat(' or')) + + lines = [] + for hash_name, expecteds in iteritems(self.allowed): + prefix = hash_then_or(hash_name) + lines.extend((' Expected %s %s' % (next(prefix), e)) + for e in expecteds) + lines.append(' Got %s\n' % + self.gots[hash_name].hexdigest()) + prefix = ' or' + return '\n'.join(lines) + + +class UnsupportedPythonVersion(InstallationError): + """Unsupported python version according to Requires-Python package + metadata.""" + + +class ConfigurationFileCouldNotBeLoaded(ConfigurationError): + """When there are errors while loading a configuration file + """ + + def __init__(self, reason="could not be loaded", fname=None, error=None): + super(ConfigurationFileCouldNotBeLoaded, self).__init__(error) + self.reason = reason + self.fname = fname + self.error = error + + def __str__(self): + if self.fname is not None: + message_part = " in {}.".format(self.fname) + else: + assert self.error is not None + message_part = ".\n{}\n".format(self.error.message) + return "Configuration file {}{}".format(self.reason, message_part) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/index.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/index.py new file mode 100644 index 0000000000000000000000000000000000000000..a1aaad59c88abb4530d49058f21d7cee43d4aa73 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/index.py @@ -0,0 +1,1508 @@ +"""Routines related to PyPI, indexes""" +from __future__ import absolute_import + +import cgi +import itertools +import logging +import mimetypes +import os +import re + +from pip._vendor import html5lib, requests, six +from pip._vendor.distlib.compat import unescape +from pip._vendor.packaging import specifiers +from pip._vendor.packaging.utils import canonicalize_name +from pip._vendor.packaging.version import parse as parse_version +from pip._vendor.requests.exceptions import HTTPError, RetryError, SSLError +from pip._vendor.six.moves.urllib import parse as urllib_parse +from pip._vendor.six.moves.urllib import request as urllib_request + +from pip._internal.download import is_url, url_to_path +from pip._internal.exceptions import ( + BestVersionAlreadyInstalled, DistributionNotFound, InvalidWheelFilename, + UnsupportedWheel, +) +from pip._internal.models.candidate import InstallationCandidate +from pip._internal.models.format_control import FormatControl +from pip._internal.models.link import Link +from pip._internal.models.selection_prefs import SelectionPreferences +from pip._internal.models.target_python import TargetPython +from pip._internal.utils.compat import ipaddress +from pip._internal.utils.logging import indent_log +from pip._internal.utils.misc import ( + ARCHIVE_EXTENSIONS, SUPPORTED_EXTENSIONS, WHEEL_EXTENSION, path_to_url, + redact_password_from_url, +) +from pip._internal.utils.packaging import check_requires_python +from pip._internal.utils.typing import MYPY_CHECK_RUNNING +from pip._internal.wheel import Wheel + +if MYPY_CHECK_RUNNING: + from logging import Logger + from typing import ( + Any, Callable, FrozenSet, Iterable, Iterator, List, MutableMapping, + Optional, Sequence, Set, Text, Tuple, Union, + ) + import xml.etree.ElementTree + from pip._vendor.packaging.version import _BaseVersion + from pip._vendor.requests import Response + from pip._internal.models.search_scope import SearchScope + from pip._internal.req import InstallRequirement + from pip._internal.download import PipSession + from pip._internal.pep425tags import Pep425Tag + from pip._internal.utils.hashes import Hashes + + BuildTag = Tuple[Any, ...] # either empty tuple or Tuple[int, str] + CandidateSortingKey = ( + Tuple[int, int, int, _BaseVersion, BuildTag, Optional[int]] + ) + HTMLElement = xml.etree.ElementTree.Element + SecureOrigin = Tuple[str, str, Optional[str]] + + +__all__ = ['FormatControl', 'FoundCandidates', 'PackageFinder'] + + +SECURE_ORIGINS = [ + # protocol, hostname, port + # Taken from Chrome's list of secure origins (See: http://bit.ly/1qrySKC) + ("https", "*", "*"), + ("*", "localhost", "*"), + ("*", "127.0.0.0/8", "*"), + ("*", "::1/128", "*"), + ("file", "*", None), + # ssh is always secure. + ("ssh", "*", "*"), +] # type: List[SecureOrigin] + + +logger = logging.getLogger(__name__) + + +def _match_vcs_scheme(url): + # type: (str) -> Optional[str] + """Look for VCS schemes in the URL. + + Returns the matched VCS scheme, or None if there's no match. + """ + from pip._internal.vcs import vcs + for scheme in vcs.schemes: + if url.lower().startswith(scheme) and url[len(scheme)] in '+:': + return scheme + return None + + +def _is_url_like_archive(url): + # type: (str) -> bool + """Return whether the URL looks like an archive. + """ + filename = Link(url).filename + for bad_ext in ARCHIVE_EXTENSIONS: + if filename.endswith(bad_ext): + return True + return False + + +class _NotHTML(Exception): + def __init__(self, content_type, request_desc): + # type: (str, str) -> None + super(_NotHTML, self).__init__(content_type, request_desc) + self.content_type = content_type + self.request_desc = request_desc + + +def _ensure_html_header(response): + # type: (Response) -> None + """Check the Content-Type header to ensure the response contains HTML. + + Raises `_NotHTML` if the content type is not text/html. + """ + content_type = response.headers.get("Content-Type", "") + if not content_type.lower().startswith("text/html"): + raise _NotHTML(content_type, response.request.method) + + +class _NotHTTP(Exception): + pass + + +def _ensure_html_response(url, session): + # type: (str, PipSession) -> None + """Send a HEAD request to the URL, and ensure the response contains HTML. + + Raises `_NotHTTP` if the URL is not available for a HEAD request, or + `_NotHTML` if the content type is not text/html. + """ + scheme, netloc, path, query, fragment = urllib_parse.urlsplit(url) + if scheme not in {'http', 'https'}: + raise _NotHTTP() + + resp = session.head(url, allow_redirects=True) + resp.raise_for_status() + + _ensure_html_header(resp) + + +def _get_html_response(url, session): + # type: (str, PipSession) -> Response + """Access an HTML page with GET, and return the response. + + This consists of three parts: + + 1. If the URL looks suspiciously like an archive, send a HEAD first to + check the Content-Type is HTML, to avoid downloading a large file. + Raise `_NotHTTP` if the content type cannot be determined, or + `_NotHTML` if it is not HTML. + 2. Actually perform the request. Raise HTTP exceptions on network failures. + 3. Check the Content-Type header to make sure we got HTML, and raise + `_NotHTML` otherwise. + """ + if _is_url_like_archive(url): + _ensure_html_response(url, session=session) + + logger.debug('Getting page %s', redact_password_from_url(url)) + + resp = session.get( + url, + headers={ + "Accept": "text/html", + # We don't want to blindly returned cached data for + # /simple/, because authors generally expecting that + # twine upload && pip install will function, but if + # they've done a pip install in the last ~10 minutes + # it won't. Thus by setting this to zero we will not + # blindly use any cached data, however the benefit of + # using max-age=0 instead of no-cache, is that we will + # still support conditional requests, so we will still + # minimize traffic sent in cases where the page hasn't + # changed at all, we will just always incur the round + # trip for the conditional GET now instead of only + # once per 10 minutes. + # For more information, please see pypa/pip#5670. + "Cache-Control": "max-age=0", + }, + ) + resp.raise_for_status() + + # The check for archives above only works if the url ends with + # something that looks like an archive. However that is not a + # requirement of an url. Unless we issue a HEAD request on every + # url we cannot know ahead of time for sure if something is HTML + # or not. However we can check after we've downloaded it. + _ensure_html_header(resp) + + return resp + + +def _handle_get_page_fail( + link, # type: Link + reason, # type: Union[str, Exception] + meth=None # type: Optional[Callable[..., None]] +): + # type: (...) -> None + if meth is None: + meth = logger.debug + meth("Could not fetch URL %s: %s - skipping", link, reason) + + +def _get_html_page(link, session=None): + # type: (Link, Optional[PipSession]) -> Optional[HTMLPage] + if session is None: + raise TypeError( + "_get_html_page() missing 1 required keyword argument: 'session'" + ) + + url = link.url.split('#', 1)[0] + + # Check for VCS schemes that do not support lookup as web pages. + vcs_scheme = _match_vcs_scheme(url) + if vcs_scheme: + logger.debug('Cannot look at %s URL %s', vcs_scheme, link) + return None + + # Tack index.html onto file:// URLs that point to directories + scheme, _, path, _, _, _ = urllib_parse.urlparse(url) + if (scheme == 'file' and os.path.isdir(urllib_request.url2pathname(path))): + # add trailing slash if not present so urljoin doesn't trim + # final segment + if not url.endswith('/'): + url += '/' + url = urllib_parse.urljoin(url, 'index.html') + logger.debug(' file: URL is directory, getting %s', url) + + try: + resp = _get_html_response(url, session=session) + except _NotHTTP: + logger.debug( + 'Skipping page %s because it looks like an archive, and cannot ' + 'be checked by HEAD.', link, + ) + except _NotHTML as exc: + logger.debug( + 'Skipping page %s because the %s request got Content-Type: %s', + link, exc.request_desc, exc.content_type, + ) + except HTTPError as exc: + _handle_get_page_fail(link, exc) + except RetryError as exc: + _handle_get_page_fail(link, exc) + except SSLError as exc: + reason = "There was a problem confirming the ssl certificate: " + reason += str(exc) + _handle_get_page_fail(link, reason, meth=logger.info) + except requests.ConnectionError as exc: + _handle_get_page_fail(link, "connection error: %s" % exc) + except requests.Timeout: + _handle_get_page_fail(link, "timed out") + else: + return HTMLPage(resp.content, resp.url, resp.headers) + return None + + +def _check_link_requires_python( + link, # type: Link + version_info, # type: Tuple[int, int, int] + ignore_requires_python=False, # type: bool +): + # type: (...) -> bool + """ + Return whether the given Python version is compatible with a link's + "Requires-Python" value. + + :param version_info: A 3-tuple of ints representing the Python + major-minor-micro version to check. + :param ignore_requires_python: Whether to ignore the "Requires-Python" + value if the given Python version isn't compatible. + """ + try: + is_compatible = check_requires_python( + link.requires_python, version_info=version_info, + ) + except specifiers.InvalidSpecifier: + logger.debug( + "Ignoring invalid Requires-Python (%r) for link: %s", + link.requires_python, link, + ) + else: + if not is_compatible: + version = '.'.join(map(str, version_info)) + if not ignore_requires_python: + logger.debug( + 'Link requires a different Python (%s not in: %r): %s', + version, link.requires_python, link, + ) + return False + + logger.debug( + 'Ignoring failed Requires-Python check (%s not in: %r) ' + 'for link: %s', + version, link.requires_python, link, + ) + + return True + + +class LinkEvaluator(object): + + """ + Responsible for evaluating links for a particular project. + """ + + _py_version_re = re.compile(r'-py([123]\.?[0-9]?)$') + + # Don't include an allow_yanked default value to make sure each call + # site considers whether yanked releases are allowed. This also causes + # that decision to be made explicit in the calling code, which helps + # people when reading the code. + def __init__( + self, + project_name, # type: str + canonical_name, # type: str + formats, # type: FrozenSet + target_python, # type: TargetPython + allow_yanked, # type: bool + ignore_requires_python=None, # type: Optional[bool] + ): + # type: (...) -> None + """ + :param project_name: The user supplied package name. + :param canonical_name: The canonical package name. + :param formats: The formats allowed for this package. Should be a set + with 'binary' or 'source' or both in it. + :param target_python: The target Python interpreter to use when + evaluating link compatibility. This is used, for example, to + check wheel compatibility, as well as when checking the Python + version, e.g. the Python version embedded in a link filename + (or egg fragment) and against an HTML link's optional PEP 503 + "data-requires-python" attribute. + :param allow_yanked: Whether files marked as yanked (in the sense + of PEP 592) are permitted to be candidates for install. + :param ignore_requires_python: Whether to ignore incompatible + PEP 503 "data-requires-python" values in HTML links. Defaults + to False. + """ + if ignore_requires_python is None: + ignore_requires_python = False + + self._allow_yanked = allow_yanked + self._canonical_name = canonical_name + self._ignore_requires_python = ignore_requires_python + self._formats = formats + self._target_python = target_python + + self.project_name = project_name + + def evaluate_link(self, link): + # type: (Link) -> Tuple[bool, Optional[Text]] + """ + Determine whether a link is a candidate for installation. + + :return: A tuple (is_candidate, result), where `result` is (1) a + version string if `is_candidate` is True, and (2) if + `is_candidate` is False, an optional string to log the reason + the link fails to qualify. + """ + version = None + if link.is_yanked and not self._allow_yanked: + reason = link.yanked_reason or '' + # Mark this as a unicode string to prevent "UnicodeEncodeError: + # 'ascii' codec can't encode character" in Python 2 when + # the reason contains non-ascii characters. + return (False, u'yanked for reason: {}'.format(reason)) + + if link.egg_fragment: + egg_info = link.egg_fragment + ext = link.ext + else: + egg_info, ext = link.splitext() + if not ext: + return (False, 'not a file') + if ext not in SUPPORTED_EXTENSIONS: + return (False, 'unsupported archive format: %s' % ext) + if "binary" not in self._formats and ext == WHEEL_EXTENSION: + reason = 'No binaries permitted for %s' % self.project_name + return (False, reason) + if "macosx10" in link.path and ext == '.zip': + return (False, 'macosx10 one') + if ext == WHEEL_EXTENSION: + try: + wheel = Wheel(link.filename) + except InvalidWheelFilename: + return (False, 'invalid wheel filename') + if canonicalize_name(wheel.name) != self._canonical_name: + reason = 'wrong project name (not %s)' % self.project_name + return (False, reason) + + supported_tags = self._target_python.get_tags() + if not wheel.supported(supported_tags): + # Include the wheel's tags in the reason string to + # simplify troubleshooting compatibility issues. + file_tags = wheel.get_formatted_file_tags() + reason = ( + "none of the wheel's tags match: {}".format( + ', '.join(file_tags) + ) + ) + return (False, reason) + + version = wheel.version + + # This should be up by the self.ok_binary check, but see issue 2700. + if "source" not in self._formats and ext != WHEEL_EXTENSION: + return (False, 'No sources permitted for %s' % self.project_name) + + if not version: + version = _extract_version_from_fragment( + egg_info, self._canonical_name, + ) + if not version: + return ( + False, 'Missing project version for %s' % self.project_name, + ) + + match = self._py_version_re.search(version) + if match: + version = version[:match.start()] + py_version = match.group(1) + if py_version != self._target_python.py_version: + return (False, 'Python version is incorrect') + + supports_python = _check_link_requires_python( + link, version_info=self._target_python.py_version_info, + ignore_requires_python=self._ignore_requires_python, + ) + if not supports_python: + # Return None for the reason text to suppress calling + # _log_skipped_link(). + return (False, None) + + logger.debug('Found link %s, version: %s', link, version) + + return (True, version) + + +def filter_unallowed_hashes( + candidates, # type: List[InstallationCandidate] + hashes, # type: Hashes + project_name, # type: str +): + # type: (...) -> List[InstallationCandidate] + """ + Filter out candidates whose hashes aren't allowed, and return a new + list of candidates. + + If at least one candidate has an allowed hash, then all candidates with + either an allowed hash or no hash specified are returned. Otherwise, + the given candidates are returned. + + Including the candidates with no hash specified when there is a match + allows a warning to be logged if there is a more preferred candidate + with no hash specified. Returning all candidates in the case of no + matches lets pip report the hash of the candidate that would otherwise + have been installed (e.g. permitting the user to more easily update + their requirements file with the desired hash). + """ + if not hashes: + logger.debug( + 'Given no hashes to check %s links for project %r: ' + 'discarding no candidates', + len(candidates), + project_name, + ) + # Make sure we're not returning back the given value. + return list(candidates) + + matches_or_no_digest = [] + # Collect the non-matches for logging purposes. + non_matches = [] + match_count = 0 + for candidate in candidates: + link = candidate.link + if not link.has_hash: + pass + elif link.is_hash_allowed(hashes=hashes): + match_count += 1 + else: + non_matches.append(candidate) + continue + + matches_or_no_digest.append(candidate) + + if match_count: + filtered = matches_or_no_digest + else: + # Make sure we're not returning back the given value. + filtered = list(candidates) + + if len(filtered) == len(candidates): + discard_message = 'discarding no candidates' + else: + discard_message = 'discarding {} non-matches:\n {}'.format( + len(non_matches), + '\n '.join(str(candidate.link) for candidate in non_matches) + ) + + logger.debug( + 'Checked %s links for project %r against %s hashes ' + '(%s matches, %s no digest): %s', + len(candidates), + project_name, + hashes.digest_count, + match_count, + len(matches_or_no_digest) - match_count, + discard_message + ) + + return filtered + + +class CandidatePreferences(object): + + """ + Encapsulates some of the preferences for filtering and sorting + InstallationCandidate objects. + """ + + def __init__( + self, + prefer_binary=False, # type: bool + allow_all_prereleases=False, # type: bool + ): + # type: (...) -> None + """ + :param allow_all_prereleases: Whether to allow all pre-releases. + """ + self.allow_all_prereleases = allow_all_prereleases + self.prefer_binary = prefer_binary + + +class CandidateEvaluator(object): + + """ + Responsible for filtering and sorting candidates for installation based + on what tags are valid. + """ + + @classmethod + def create( + cls, + project_name, # type: str + target_python=None, # type: Optional[TargetPython] + prefer_binary=False, # type: bool + allow_all_prereleases=False, # type: bool + specifier=None, # type: Optional[specifiers.BaseSpecifier] + hashes=None, # type: Optional[Hashes] + ): + # type: (...) -> CandidateEvaluator + """Create a CandidateEvaluator object. + + :param target_python: The target Python interpreter to use when + checking compatibility. If None (the default), a TargetPython + object will be constructed from the running Python. + :param hashes: An optional collection of allowed hashes. + """ + if target_python is None: + target_python = TargetPython() + if specifier is None: + specifier = specifiers.SpecifierSet() + + supported_tags = target_python.get_tags() + + return cls( + project_name=project_name, + supported_tags=supported_tags, + specifier=specifier, + prefer_binary=prefer_binary, + allow_all_prereleases=allow_all_prereleases, + hashes=hashes, + ) + + def __init__( + self, + project_name, # type: str + supported_tags, # type: List[Pep425Tag] + specifier, # type: specifiers.BaseSpecifier + prefer_binary=False, # type: bool + allow_all_prereleases=False, # type: bool + hashes=None, # type: Optional[Hashes] + ): + # type: (...) -> None + """ + :param supported_tags: The PEP 425 tags supported by the target + Python in order of preference (most preferred first). + """ + self._allow_all_prereleases = allow_all_prereleases + self._hashes = hashes + self._prefer_binary = prefer_binary + self._project_name = project_name + self._specifier = specifier + self._supported_tags = supported_tags + + def get_applicable_candidates( + self, + candidates, # type: List[InstallationCandidate] + ): + # type: (...) -> List[InstallationCandidate] + """ + Return the applicable candidates from a list of candidates. + """ + # Using None infers from the specifier instead. + allow_prereleases = self._allow_all_prereleases or None + specifier = self._specifier + versions = { + str(v) for v in specifier.filter( + # We turn the version object into a str here because otherwise + # when we're debundled but setuptools isn't, Python will see + # packaging.version.Version and + # pkg_resources._vendor.packaging.version.Version as different + # types. This way we'll use a str as a common data interchange + # format. If we stop using the pkg_resources provided specifier + # and start using our own, we can drop the cast to str(). + (str(c.version) for c in candidates), + prereleases=allow_prereleases, + ) + } + + # Again, converting version to str to deal with debundling. + applicable_candidates = [ + c for c in candidates if str(c.version) in versions + ] + + return filter_unallowed_hashes( + candidates=applicable_candidates, + hashes=self._hashes, + project_name=self._project_name, + ) + + def make_found_candidates( + self, + candidates, # type: List[InstallationCandidate] + ): + # type: (...) -> FoundCandidates + """ + Create and return a `FoundCandidates` instance. + + :param specifier: An optional object implementing `filter` + (e.g. `packaging.specifiers.SpecifierSet`) to filter applicable + versions. + """ + applicable_candidates = self.get_applicable_candidates(candidates) + + return FoundCandidates( + candidates, + applicable_candidates=applicable_candidates, + evaluator=self, + ) + + def _sort_key(self, candidate): + # type: (InstallationCandidate) -> CandidateSortingKey + """ + Function to pass as the `key` argument to a call to sorted() to sort + InstallationCandidates by preference. + + Returns a tuple such that tuples sorting as greater using Python's + default comparison operator are more preferred. + + The preference is as follows: + + First and foremost, candidates with allowed (matching) hashes are + always preferred over candidates without matching hashes. This is + because e.g. if the only candidate with an allowed hash is yanked, + we still want to use that candidate. + + Second, excepting hash considerations, candidates that have been + yanked (in the sense of PEP 592) are always less preferred than + candidates that haven't been yanked. Then: + + If not finding wheels, they are sorted by version only. + If finding wheels, then the sort order is by version, then: + 1. existing installs + 2. wheels ordered via Wheel.support_index_min(self._supported_tags) + 3. source archives + If prefer_binary was set, then all wheels are sorted above sources. + + Note: it was considered to embed this logic into the Link + comparison operators, but then different sdist links + with the same version, would have to be considered equal + """ + valid_tags = self._supported_tags + support_num = len(valid_tags) + build_tag = tuple() # type: BuildTag + binary_preference = 0 + link = candidate.link + if link.is_wheel: + # can raise InvalidWheelFilename + wheel = Wheel(link.filename) + if not wheel.supported(valid_tags): + raise UnsupportedWheel( + "%s is not a supported wheel for this platform. It " + "can't be sorted." % wheel.filename + ) + if self._prefer_binary: + binary_preference = 1 + pri = -(wheel.support_index_min(valid_tags)) + if wheel.build_tag is not None: + match = re.match(r'^(\d+)(.*)$', wheel.build_tag) + build_tag_groups = match.groups() + build_tag = (int(build_tag_groups[0]), build_tag_groups[1]) + else: # sdist + pri = -(support_num) + has_allowed_hash = int(link.is_hash_allowed(self._hashes)) + yank_value = -1 * int(link.is_yanked) # -1 for yanked. + return ( + has_allowed_hash, yank_value, binary_preference, candidate.version, + build_tag, pri, + ) + + def get_best_candidate( + self, + candidates, # type: List[InstallationCandidate] + ): + # type: (...) -> Optional[InstallationCandidate] + """ + Return the best candidate per the instance's sort order, or None if + no candidate is acceptable. + """ + if not candidates: + return None + + best_candidate = max(candidates, key=self._sort_key) + + # Log a warning per PEP 592 if necessary before returning. + link = best_candidate.link + if link.is_yanked: + reason = link.yanked_reason or '' + msg = ( + # Mark this as a unicode string to prevent + # "UnicodeEncodeError: 'ascii' codec can't encode character" + # in Python 2 when the reason contains non-ascii characters. + u'The candidate selected for download or install is a ' + 'yanked version: {candidate}\n' + 'Reason for being yanked: {reason}' + ).format(candidate=best_candidate, reason=reason) + logger.warning(msg) + + return best_candidate + + +class FoundCandidates(object): + """A collection of candidates, returned by `PackageFinder.find_candidates`. + + This class is only intended to be instantiated by CandidateEvaluator's + `make_found_candidates()` method. + """ + + def __init__( + self, + candidates, # type: List[InstallationCandidate] + applicable_candidates, # type: List[InstallationCandidate] + evaluator, # type: CandidateEvaluator + ): + # type: (...) -> None + """ + :param candidates: A sequence of all available candidates found. + :param applicable_candidates: The applicable candidates. + :param evaluator: A CandidateEvaluator object to sort applicable + candidates by order of preference. + """ + self._applicable_candidates = applicable_candidates + self._candidates = candidates + self._evaluator = evaluator + + def iter_all(self): + # type: () -> Iterable[InstallationCandidate] + """Iterate through all candidates. + """ + return iter(self._candidates) + + def iter_applicable(self): + # type: () -> Iterable[InstallationCandidate] + """Iterate through the applicable candidates. + """ + return iter(self._applicable_candidates) + + def get_best(self): + # type: () -> Optional[InstallationCandidate] + """Return the best candidate available, or None if no applicable + candidates are found. + """ + candidates = list(self.iter_applicable()) + return self._evaluator.get_best_candidate(candidates) + + +class PackageFinder(object): + """This finds packages. + + This is meant to match easy_install's technique for looking for + packages, by reading pages and looking for appropriate links. + """ + + def __init__( + self, + search_scope, # type: SearchScope + session, # type: PipSession + target_python, # type: TargetPython + allow_yanked, # type: bool + format_control=None, # type: Optional[FormatControl] + trusted_hosts=None, # type: Optional[List[str]] + candidate_prefs=None, # type: CandidatePreferences + ignore_requires_python=None, # type: Optional[bool] + ): + # type: (...) -> None + """ + This constructor is primarily meant to be used by the create() class + method and from tests. + + :param session: The Session to use to make requests. + :param format_control: A FormatControl object, used to control + the selection of source packages / binary packages when consulting + the index and links. + :param candidate_prefs: Options to use when creating a + CandidateEvaluator object. + """ + if trusted_hosts is None: + trusted_hosts = [] + if candidate_prefs is None: + candidate_prefs = CandidatePreferences() + + format_control = format_control or FormatControl(set(), set()) + + self._allow_yanked = allow_yanked + self._candidate_prefs = candidate_prefs + self._ignore_requires_python = ignore_requires_python + self._target_python = target_python + + self.search_scope = search_scope + self.session = session + self.format_control = format_control + self.trusted_hosts = trusted_hosts + + # These are boring links that have already been logged somehow. + self._logged_links = set() # type: Set[Link] + + # Don't include an allow_yanked default value to make sure each call + # site considers whether yanked releases are allowed. This also causes + # that decision to be made explicit in the calling code, which helps + # people when reading the code. + @classmethod + def create( + cls, + search_scope, # type: SearchScope + selection_prefs, # type: SelectionPreferences + trusted_hosts=None, # type: Optional[List[str]] + session=None, # type: Optional[PipSession] + target_python=None, # type: Optional[TargetPython] + ): + # type: (...) -> PackageFinder + """Create a PackageFinder. + + :param selection_prefs: The candidate selection preferences, as a + SelectionPreferences object. + :param trusted_hosts: Domains not to emit warnings for when not using + HTTPS. + :param session: The Session to use to make requests. + :param target_python: The target Python interpreter to use when + checking compatibility. If None (the default), a TargetPython + object will be constructed from the running Python. + """ + if session is None: + raise TypeError( + "PackageFinder.create() missing 1 required keyword argument: " + "'session'" + ) + if target_python is None: + target_python = TargetPython() + + candidate_prefs = CandidatePreferences( + prefer_binary=selection_prefs.prefer_binary, + allow_all_prereleases=selection_prefs.allow_all_prereleases, + ) + + return cls( + candidate_prefs=candidate_prefs, + search_scope=search_scope, + session=session, + target_python=target_python, + allow_yanked=selection_prefs.allow_yanked, + format_control=selection_prefs.format_control, + trusted_hosts=trusted_hosts, + ignore_requires_python=selection_prefs.ignore_requires_python, + ) + + @property + def find_links(self): + # type: () -> List[str] + return self.search_scope.find_links + + @property + def index_urls(self): + # type: () -> List[str] + return self.search_scope.index_urls + + @property + def allow_all_prereleases(self): + # type: () -> bool + return self._candidate_prefs.allow_all_prereleases + + def set_allow_all_prereleases(self): + # type: () -> None + self._candidate_prefs.allow_all_prereleases = True + + def add_trusted_host(self, host, source=None): + # type: (str, Optional[str]) -> None + """ + :param source: An optional source string, for logging where the host + string came from. + """ + # It is okay to add a previously added host because PipSession stores + # the resulting prefixes in a dict. + msg = 'adding trusted host: {!r}'.format(host) + if source is not None: + msg += ' (from {})'.format(source) + logger.info(msg) + self.session.add_insecure_host(host) + if host in self.trusted_hosts: + return + + self.trusted_hosts.append(host) + + def iter_secure_origins(self): + # type: () -> Iterator[SecureOrigin] + for secure_origin in SECURE_ORIGINS: + yield secure_origin + for host in self.trusted_hosts: + yield ('*', host, '*') + + @staticmethod + def _sort_locations(locations, expand_dir=False): + # type: (Sequence[str], bool) -> Tuple[List[str], List[str]] + """ + Sort locations into "files" (archives) and "urls", and return + a pair of lists (files,urls) + """ + files = [] + urls = [] + + # puts the url for the given file path into the appropriate list + def sort_path(path): + url = path_to_url(path) + if mimetypes.guess_type(url, strict=False)[0] == 'text/html': + urls.append(url) + else: + files.append(url) + + for url in locations: + + is_local_path = os.path.exists(url) + is_file_url = url.startswith('file:') + + if is_local_path or is_file_url: + if is_local_path: + path = url + else: + path = url_to_path(url) + if os.path.isdir(path): + if expand_dir: + path = os.path.realpath(path) + for item in os.listdir(path): + sort_path(os.path.join(path, item)) + elif is_file_url: + urls.append(url) + else: + logger.warning( + "Path '{0}' is ignored: " + "it is a directory.".format(path), + ) + elif os.path.isfile(path): + sort_path(path) + else: + logger.warning( + "Url '%s' is ignored: it is neither a file " + "nor a directory.", url, + ) + elif is_url(url): + # Only add url with clear scheme + urls.append(url) + else: + logger.warning( + "Url '%s' is ignored. It is either a non-existing " + "path or lacks a specific scheme.", url, + ) + + return files, urls + + def _validate_secure_origin(self, logger, location): + # type: (Logger, Link) -> bool + # Determine if this url used a secure transport mechanism + parsed = urllib_parse.urlparse(str(location)) + origin = (parsed.scheme, parsed.hostname, parsed.port) + + # The protocol to use to see if the protocol matches. + # Don't count the repository type as part of the protocol: in + # cases such as "git+ssh", only use "ssh". (I.e., Only verify against + # the last scheme.) + protocol = origin[0].rsplit('+', 1)[-1] + + # Determine if our origin is a secure origin by looking through our + # hardcoded list of secure origins, as well as any additional ones + # configured on this PackageFinder instance. + for secure_origin in self.iter_secure_origins(): + if protocol != secure_origin[0] and secure_origin[0] != "*": + continue + + try: + # We need to do this decode dance to ensure that we have a + # unicode object, even on Python 2.x. + addr = ipaddress.ip_address( + origin[1] + if ( + isinstance(origin[1], six.text_type) or + origin[1] is None + ) + else origin[1].decode("utf8") + ) + network = ipaddress.ip_network( + secure_origin[1] + if isinstance(secure_origin[1], six.text_type) + # setting secure_origin[1] to proper Union[bytes, str] + # creates problems in other places + else secure_origin[1].decode("utf8") # type: ignore + ) + except ValueError: + # We don't have both a valid address or a valid network, so + # we'll check this origin against hostnames. + if (origin[1] and + origin[1].lower() != secure_origin[1].lower() and + secure_origin[1] != "*"): + continue + else: + # We have a valid address and network, so see if the address + # is contained within the network. + if addr not in network: + continue + + # Check to see if the port patches + if (origin[2] != secure_origin[2] and + secure_origin[2] != "*" and + secure_origin[2] is not None): + continue + + # If we've gotten here, then this origin matches the current + # secure origin and we should return True + return True + + # If we've gotten to this point, then the origin isn't secure and we + # will not accept it as a valid location to search. We will however + # log a warning that we are ignoring it. + logger.warning( + "The repository located at %s is not a trusted or secure host and " + "is being ignored. If this repository is available via HTTPS we " + "recommend you use HTTPS instead, otherwise you may silence " + "this warning and allow it anyway with '--trusted-host %s'.", + parsed.hostname, + parsed.hostname, + ) + + return False + + def make_link_evaluator(self, project_name): + # type: (str) -> LinkEvaluator + canonical_name = canonicalize_name(project_name) + formats = self.format_control.get_allowed_formats(canonical_name) + + return LinkEvaluator( + project_name=project_name, + canonical_name=canonical_name, + formats=formats, + target_python=self._target_python, + allow_yanked=self._allow_yanked, + ignore_requires_python=self._ignore_requires_python, + ) + + def find_all_candidates(self, project_name): + # type: (str) -> List[InstallationCandidate] + """Find all available InstallationCandidate for project_name + + This checks index_urls and find_links. + All versions found are returned as an InstallationCandidate list. + + See LinkEvaluator.evaluate_link() for details on which files + are accepted. + """ + search_scope = self.search_scope + index_locations = search_scope.get_index_urls_locations(project_name) + index_file_loc, index_url_loc = self._sort_locations(index_locations) + fl_file_loc, fl_url_loc = self._sort_locations( + self.find_links, expand_dir=True, + ) + + file_locations = (Link(url) for url in itertools.chain( + index_file_loc, fl_file_loc, + )) + + # We trust every url that the user has given us whether it was given + # via --index-url or --find-links. + # We want to filter out any thing which does not have a secure origin. + url_locations = [ + link for link in itertools.chain( + (Link(url) for url in index_url_loc), + (Link(url) for url in fl_url_loc), + ) + if self._validate_secure_origin(logger, link) + ] + + logger.debug('%d location(s) to search for versions of %s:', + len(url_locations), project_name) + + for location in url_locations: + logger.debug('* %s', location) + + link_evaluator = self.make_link_evaluator(project_name) + find_links_versions = self._package_versions( + link_evaluator, + # We trust every directly linked archive in find_links + (Link(url, '-f') for url in self.find_links), + ) + + page_versions = [] + for page in self._get_pages(url_locations, project_name): + logger.debug('Analyzing links from page %s', page.url) + with indent_log(): + page_versions.extend( + self._package_versions(link_evaluator, page.iter_links()) + ) + + file_versions = self._package_versions(link_evaluator, file_locations) + if file_versions: + file_versions.sort(reverse=True) + logger.debug( + 'Local files found: %s', + ', '.join([ + url_to_path(candidate.link.url) + for candidate in file_versions + ]) + ) + + # This is an intentional priority ordering + return file_versions + find_links_versions + page_versions + + def make_candidate_evaluator( + self, + project_name, # type: str + specifier=None, # type: Optional[specifiers.BaseSpecifier] + hashes=None, # type: Optional[Hashes] + ): + # type: (...) -> CandidateEvaluator + """Create a CandidateEvaluator object to use. + """ + candidate_prefs = self._candidate_prefs + return CandidateEvaluator.create( + project_name=project_name, + target_python=self._target_python, + prefer_binary=candidate_prefs.prefer_binary, + allow_all_prereleases=candidate_prefs.allow_all_prereleases, + specifier=specifier, + hashes=hashes, + ) + + def find_candidates( + self, + project_name, # type: str + specifier=None, # type: Optional[specifiers.BaseSpecifier] + hashes=None, # type: Optional[Hashes] + ): + # type: (...) -> FoundCandidates + """Find matches for the given project and specifier. + + :param specifier: An optional object implementing `filter` + (e.g. `packaging.specifiers.SpecifierSet`) to filter applicable + versions. + + :return: A `FoundCandidates` instance. + """ + candidates = self.find_all_candidates(project_name) + candidate_evaluator = self.make_candidate_evaluator( + project_name=project_name, + specifier=specifier, + hashes=hashes, + ) + return candidate_evaluator.make_found_candidates(candidates) + + def find_requirement(self, req, upgrade): + # type: (InstallRequirement, bool) -> Optional[Link] + """Try to find a Link matching req + + Expects req, an InstallRequirement and upgrade, a boolean + Returns a Link if found, + Raises DistributionNotFound or BestVersionAlreadyInstalled otherwise + """ + hashes = req.hashes(trust_internet=False) + candidates = self.find_candidates( + req.name, specifier=req.specifier, hashes=hashes, + ) + best_candidate = candidates.get_best() + + installed_version = None # type: Optional[_BaseVersion] + if req.satisfied_by is not None: + installed_version = parse_version(req.satisfied_by.version) + + def _format_versions(cand_iter): + # This repeated parse_version and str() conversion is needed to + # handle different vendoring sources from pip and pkg_resources. + # If we stop using the pkg_resources provided specifier and start + # using our own, we can drop the cast to str(). + return ", ".join(sorted( + {str(c.version) for c in cand_iter}, + key=parse_version, + )) or "none" + + if installed_version is None and best_candidate is None: + logger.critical( + 'Could not find a version that satisfies the requirement %s ' + '(from versions: %s)', + req, + _format_versions(candidates.iter_all()), + ) + + raise DistributionNotFound( + 'No matching distribution found for %s' % req + ) + + best_installed = False + if installed_version and ( + best_candidate is None or + best_candidate.version <= installed_version): + best_installed = True + + if not upgrade and installed_version is not None: + if best_installed: + logger.debug( + 'Existing installed version (%s) is most up-to-date and ' + 'satisfies requirement', + installed_version, + ) + else: + logger.debug( + 'Existing installed version (%s) satisfies requirement ' + '(most up-to-date version is %s)', + installed_version, + best_candidate.version, + ) + return None + + if best_installed: + # We have an existing version, and its the best version + logger.debug( + 'Installed version (%s) is most up-to-date (past versions: ' + '%s)', + installed_version, + _format_versions(candidates.iter_applicable()), + ) + raise BestVersionAlreadyInstalled + + logger.debug( + 'Using version %s (newest of versions: %s)', + best_candidate.version, + _format_versions(candidates.iter_applicable()), + ) + return best_candidate.link + + def _get_pages(self, locations, project_name): + # type: (Iterable[Link], str) -> Iterable[HTMLPage] + """ + Yields (page, page_url) from the given locations, skipping + locations that have errors. + """ + seen = set() # type: Set[Link] + for location in locations: + if location in seen: + continue + seen.add(location) + + page = _get_html_page(location, session=self.session) + if page is None: + continue + + yield page + + def _sort_links(self, links): + # type: (Iterable[Link]) -> List[Link] + """ + Returns elements of links in order, non-egg links first, egg links + second, while eliminating duplicates + """ + eggs, no_eggs = [], [] + seen = set() # type: Set[Link] + for link in links: + if link not in seen: + seen.add(link) + if link.egg_fragment: + eggs.append(link) + else: + no_eggs.append(link) + return no_eggs + eggs + + def _log_skipped_link(self, link, reason): + # type: (Link, Text) -> None + if link not in self._logged_links: + # Mark this as a unicode string to prevent "UnicodeEncodeError: + # 'ascii' codec can't encode character" in Python 2 when + # the reason contains non-ascii characters. + # Also, put the link at the end so the reason is more visible + # and because the link string is usually very long. + logger.debug(u'Skipping link: %s: %s', reason, link) + self._logged_links.add(link) + + def get_install_candidate(self, link_evaluator, link): + # type: (LinkEvaluator, Link) -> Optional[InstallationCandidate] + """ + If the link is a candidate for install, convert it to an + InstallationCandidate and return it. Otherwise, return None. + """ + is_candidate, result = link_evaluator.evaluate_link(link) + if not is_candidate: + if result: + self._log_skipped_link(link, reason=result) + return None + + return InstallationCandidate( + project=link_evaluator.project_name, + link=link, + # Convert the Text result to str since InstallationCandidate + # accepts str. + version=str(result), + ) + + def _package_versions(self, link_evaluator, links): + # type: (LinkEvaluator, Iterable[Link]) -> List[InstallationCandidate] + result = [] + for link in self._sort_links(links): + candidate = self.get_install_candidate(link_evaluator, link) + if candidate is not None: + result.append(candidate) + return result + + +def _find_name_version_sep(fragment, canonical_name): + # type: (str, str) -> int + """Find the separator's index based on the package's canonical name. + + :param fragment: A + filename "fragment" (stem) or + egg fragment. + :param canonical_name: The package's canonical name. + + This function is needed since the canonicalized name does not necessarily + have the same length as the egg info's name part. An example:: + + >>> fragment = 'foo__bar-1.0' + >>> canonical_name = 'foo-bar' + >>> _find_name_version_sep(fragment, canonical_name) + 8 + """ + # Project name and version must be separated by one single dash. Find all + # occurrences of dashes; if the string in front of it matches the canonical + # name, this is the one separating the name and version parts. + for i, c in enumerate(fragment): + if c != "-": + continue + if canonicalize_name(fragment[:i]) == canonical_name: + return i + raise ValueError("{} does not match {}".format(fragment, canonical_name)) + + +def _extract_version_from_fragment(fragment, canonical_name): + # type: (str, str) -> Optional[str] + """Parse the version string from a + filename + "fragment" (stem) or egg fragment. + + :param fragment: The string to parse. E.g. foo-2.1 + :param canonical_name: The canonicalized name of the package this + belongs to. + """ + try: + version_start = _find_name_version_sep(fragment, canonical_name) + 1 + except ValueError: + return None + version = fragment[version_start:] + if not version: + return None + return version + + +def _determine_base_url(document, page_url): + """Determine the HTML document's base URL. + + This looks for a ```` tag in the HTML document. If present, its href + attribute denotes the base URL of anchor tags in the document. If there is + no such tag (or if it does not have a valid href attribute), the HTML + file's URL is used as the base URL. + + :param document: An HTML document representation. The current + implementation expects the result of ``html5lib.parse()``. + :param page_url: The URL of the HTML document. + """ + for base in document.findall(".//base"): + href = base.get("href") + if href is not None: + return href + return page_url + + +def _get_encoding_from_headers(headers): + """Determine if we have any encoding information in our headers. + """ + if headers and "Content-Type" in headers: + content_type, params = cgi.parse_header(headers["Content-Type"]) + if "charset" in params: + return params['charset'] + return None + + +def _clean_link(url): + # type: (str) -> str + """Makes sure a link is fully encoded. That is, if a ' ' shows up in + the link, it will be rewritten to %20 (while not over-quoting + % or other characters).""" + # Split the URL into parts according to the general structure + # `scheme://netloc/path;parameters?query#fragment`. Note that the + # `netloc` can be empty and the URI will then refer to a local + # filesystem path. + result = urllib_parse.urlparse(url) + # In both cases below we unquote prior to quoting to make sure + # nothing is double quoted. + if result.netloc == "": + # On Windows the path part might contain a drive letter which + # should not be quoted. On Linux where drive letters do not + # exist, the colon should be quoted. We rely on urllib.request + # to do the right thing here. + path = urllib_request.pathname2url( + urllib_request.url2pathname(result.path)) + else: + # In addition to the `/` character we protect `@` so that + # revision strings in VCS URLs are properly parsed. + path = urllib_parse.quote(urllib_parse.unquote(result.path), safe="/@") + return urllib_parse.urlunparse(result._replace(path=path)) + + +def _create_link_from_element( + anchor, # type: HTMLElement + page_url, # type: str + base_url, # type: str +): + # type: (...) -> Optional[Link] + """ + Convert an anchor element in a simple repository page to a Link. + """ + href = anchor.get("href") + if not href: + return None + + url = _clean_link(urllib_parse.urljoin(base_url, href)) + pyrequire = anchor.get('data-requires-python') + pyrequire = unescape(pyrequire) if pyrequire else None + + yanked_reason = anchor.get('data-yanked') + if yanked_reason: + # This is a unicode string in Python 2 (and 3). + yanked_reason = unescape(yanked_reason) + + link = Link( + url, + comes_from=page_url, + requires_python=pyrequire, + yanked_reason=yanked_reason, + ) + + return link + + +class HTMLPage(object): + """Represents one page, along with its URL""" + + def __init__(self, content, url, headers=None): + # type: (bytes, str, MutableMapping[str, str]) -> None + self.content = content + self.url = url + self.headers = headers + + def __str__(self): + return redact_password_from_url(self.url) + + def iter_links(self): + # type: () -> Iterable[Link] + """Yields all links in the page""" + document = html5lib.parse( + self.content, + transport_encoding=_get_encoding_from_headers(self.headers), + namespaceHTMLElements=False, + ) + base_url = _determine_base_url(document, self.url) + for anchor in document.findall(".//a"): + link = _create_link_from_element( + anchor, + page_url=self.url, + base_url=base_url, + ) + if link is None: + continue + yield link diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/legacy_resolve.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/legacy_resolve.py new file mode 100644 index 0000000000000000000000000000000000000000..1d9229cb62100f18afd3ad90a0659abaf461a8fe --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_internal/legacy_resolve.py @@ -0,0 +1,457 @@ +"""Dependency Resolution + +The dependency resolution in pip is performed as follows: + +for top-level requirements: + a. only one spec allowed per project, regardless of conflicts or not. + otherwise a "double requirement" exception is raised + b. they override sub-dependency requirements. +for sub-dependencies + a. "first found, wins" (where the order is breadth first) +""" + +import logging +import sys +from collections import defaultdict +from itertools import chain + +from pip._vendor.packaging import specifiers + +from pip._internal.exceptions import ( + BestVersionAlreadyInstalled, DistributionNotFound, HashError, HashErrors, + UnsupportedPythonVersion, +) +from pip._internal.req.constructors import install_req_from_req_string +from pip._internal.utils.logging import indent_log +from pip._internal.utils.misc import ( + dist_in_usersite, ensure_dir, normalize_version_info, +) +from pip._internal.utils.packaging import ( + check_requires_python, get_requires_python, +) +from pip._internal.utils.typing import MYPY_CHECK_RUNNING + +if MYPY_CHECK_RUNNING: + from typing import DefaultDict, List, Optional, Set, Tuple + from pip._vendor import pkg_resources + + from pip._internal.cache import WheelCache + from pip._internal.distributions import AbstractDistribution + from pip._internal.download import PipSession + from pip._internal.index import PackageFinder + from pip._internal.operations.prepare import RequirementPreparer + from pip._internal.req.req_install import InstallRequirement + from pip._internal.req.req_set import RequirementSet + +logger = logging.getLogger(__name__) + + +def _check_dist_requires_python( + dist, # type: pkg_resources.Distribution + version_info, # type: Tuple[int, int, int] + ignore_requires_python=False, # type: bool +): + # type: (...) -> None + """ + Check whether the given Python version is compatible with a distribution's + "Requires-Python" value. + + :param version_info: A 3-tuple of ints representing the Python + major-minor-micro version to check. + :param ignore_requires_python: Whether to ignore the "Requires-Python" + value if the given Python version isn't compatible. + + :raises UnsupportedPythonVersion: When the given Python version isn't + compatible. + """ + requires_python = get_requires_python(dist) + try: + is_compatible = check_requires_python( + requires_python, version_info=version_info, + ) + except specifiers.InvalidSpecifier as exc: + logger.warning( + "Package %r has an invalid Requires-Python: %s", + dist.project_name, exc, + ) + return + + if is_compatible: + return + + version = '.'.join(map(str, version_info)) + if ignore_requires_python: + logger.debug( + 'Ignoring failed Requires-Python check for package %r: ' + '%s not in %r', + dist.project_name, version, requires_python, + ) + return + + raise UnsupportedPythonVersion( + 'Package {!r} requires a different Python: {} not in {!r}'.format( + dist.project_name, version, requires_python, + )) + + +class Resolver(object): + """Resolves which packages need to be installed/uninstalled to perform \ + the requested operation without breaking the requirements of any package. + """ + + _allowed_strategies = {"eager", "only-if-needed", "to-satisfy-only"} + + def __init__( + self, + preparer, # type: RequirementPreparer + session, # type: PipSession + finder, # type: PackageFinder + wheel_cache, # type: Optional[WheelCache] + use_user_site, # type: bool + ignore_dependencies, # type: bool + ignore_installed, # type: bool + ignore_requires_python, # type: bool + force_reinstall, # type: bool + isolated, # type: bool + upgrade_strategy, # type: str + use_pep517=None, # type: Optional[bool] + py_version_info=None, # type: Optional[Tuple[int, ...]] + ): + # type: (...) -> None + super(Resolver, self).__init__() + assert upgrade_strategy in self._allowed_strategies + + if py_version_info is None: + py_version_info = sys.version_info[:3] + else: + py_version_info = normalize_version_info(py_version_info) + + self._py_version_info = py_version_info + + self.preparer = preparer + self.finder = finder + self.session = session + + # NOTE: This would eventually be replaced with a cache that can give + # information about both sdist and wheels transparently. + self.wheel_cache = wheel_cache + + # This is set in resolve + self.require_hashes = None # type: Optional[bool] + + self.upgrade_strategy = upgrade_strategy + self.force_reinstall = force_reinstall + self.isolated = isolated + self.ignore_dependencies = ignore_dependencies + self.ignore_installed = ignore_installed + self.ignore_requires_python = ignore_requires_python + self.use_user_site = use_user_site + self.use_pep517 = use_pep517 + + self._discovered_dependencies = \ + defaultdict(list) # type: DefaultDict[str, List] + + def resolve(self, requirement_set): + # type: (RequirementSet) -> None + """Resolve what operations need to be done + + As a side-effect of this method, the packages (and their dependencies) + are downloaded, unpacked and prepared for installation. This + preparation is done by ``pip.operations.prepare``. + + Once PyPI has static dependency metadata available, it would be + possible to move the preparation to become a step separated from + dependency resolution. + """ + # make the wheelhouse + if self.preparer.wheel_download_dir: + ensure_dir(self.preparer.wheel_download_dir) + + # If any top-level requirement has a hash specified, enter + # hash-checking mode, which requires hashes from all. + root_reqs = ( + requirement_set.unnamed_requirements + + list(requirement_set.requirements.values()) + ) + self.require_hashes = ( + requirement_set.require_hashes or + any(req.has_hash_options for req in root_reqs) + ) + + # Display where finder is looking for packages + search_scope = self.finder.search_scope + locations = search_scope.get_formatted_locations() + if locations: + logger.info(locations) + + # Actually prepare the files, and collect any exceptions. Most hash + # exceptions cannot be checked ahead of time, because + # req.populate_link() needs to be called before we can make decisions + # based on link type. + discovered_reqs = [] # type: List[InstallRequirement] + hash_errors = HashErrors() + for req in chain(root_reqs, discovered_reqs): + try: + discovered_reqs.extend( + self._resolve_one(requirement_set, req) + ) + except HashError as exc: + exc.req = req + hash_errors.append(exc) + + if hash_errors: + raise hash_errors + + def _is_upgrade_allowed(self, req): + # type: (InstallRequirement) -> bool + if self.upgrade_strategy == "to-satisfy-only": + return False + elif self.upgrade_strategy == "eager": + return True + else: + assert self.upgrade_strategy == "only-if-needed" + return req.is_direct + + def _set_req_to_reinstall(self, req): + # type: (InstallRequirement) -> None + """ + Set a requirement to be installed. + """ + # Don't uninstall the conflict if doing a user install and the + # conflict is not a user install. + if not self.use_user_site or dist_in_usersite(req.satisfied_by): + req.conflicts_with = req.satisfied_by + req.satisfied_by = None + + # XXX: Stop passing requirement_set for options + def _check_skip_installed(self, req_to_install): + # type: (InstallRequirement) -> Optional[str] + """Check if req_to_install should be skipped. + + This will check if the req is installed, and whether we should upgrade + or reinstall it, taking into account all the relevant user options. + + After calling this req_to_install will only have satisfied_by set to + None if the req_to_install is to be upgraded/reinstalled etc. Any + other value will be a dist recording the current thing installed that + satisfies the requirement. + + Note that for vcs urls and the like we can't assess skipping in this + routine - we simply identify that we need to pull the thing down, + then later on it is pulled down and introspected to assess upgrade/ + reinstalls etc. + + :return: A text reason for why it was skipped, or None. + """ + if self.ignore_installed: + return None + + req_to_install.check_if_exists(self.use_user_site) + if not req_to_install.satisfied_by: + return None + + if self.force_reinstall: + self._set_req_to_reinstall(req_to_install) + return None + + if not self._is_upgrade_allowed(req_to_install): + if self.upgrade_strategy == "only-if-needed": + return 'already satisfied, skipping upgrade' + return 'already satisfied' + + # Check for the possibility of an upgrade. For link-based + # requirements we have to pull the tree down and inspect to assess + # the version #, so it's handled way down. + if not req_to_install.link: + try: + self.finder.find_requirement(req_to_install, upgrade=True) + except BestVersionAlreadyInstalled: + # Then the best version is installed. + return 'already up-to-date' + except DistributionNotFound: + # No distribution found, so we squash the error. It will + # be raised later when we re-try later to do the install. + # Why don't we just raise here? + pass + + self._set_req_to_reinstall(req_to_install) + return None + + def _get_abstract_dist_for(self, req): + # type: (InstallRequirement) -> AbstractDistribution + """Takes a InstallRequirement and returns a single AbstractDist \ + representing a prepared variant of the same. + """ + assert self.require_hashes is not None, ( + "require_hashes should have been set in Resolver.resolve()" + ) + + if req.editable: + return self.preparer.prepare_editable_requirement( + req, self.require_hashes, self.use_user_site, self.finder, + ) + + # satisfied_by is only evaluated by calling _check_skip_installed, + # so it must be None here. + assert req.satisfied_by is None + skip_reason = self._check_skip_installed(req) + + if req.satisfied_by: + return self.preparer.prepare_installed_requirement( + req, self.require_hashes, skip_reason + ) + + upgrade_allowed = self._is_upgrade_allowed(req) + abstract_dist = self.preparer.prepare_linked_requirement( + req, self.session, self.finder, upgrade_allowed, + self.require_hashes + ) + + # NOTE + # The following portion is for determining if a certain package is + # going to be re-installed/upgraded or not and reporting to the user. + # This should probably get cleaned up in a future refactor. + + # req.req is only avail after unpack for URL + # pkgs repeat check_if_exists to uninstall-on-upgrade + # (#14) + if not self.ignore_installed: + req.check_if_exists(self.use_user_site) + + if req.satisfied_by: + should_modify = ( + self.upgrade_strategy != "to-satisfy-only" or + self.force_reinstall or + self.ignore_installed or + req.link.scheme == 'file' + ) + if should_modify: + self._set_req_to_reinstall(req) + else: + logger.info( + 'Requirement already satisfied (use --upgrade to upgrade):' + ' %s', req, + ) + + return abstract_dist + + def _resolve_one( + self, + requirement_set, # type: RequirementSet + req_to_install # type: InstallRequirement + ): + # type: (...) -> List[InstallRequirement] + """Prepare a single requirements file. + + :return: A list of additional InstallRequirements to also install. + """ + # Tell user what we are doing for this requirement: + # obtain (editable), skipping, processing (local url), collecting + # (remote url or package name) + if req_to_install.constraint or req_to_install.prepared: + return [] + + req_to_install.prepared = True + + # register tmp src for cleanup in case something goes wrong + requirement_set.reqs_to_cleanup.append(req_to_install) + + abstract_dist = self._get_abstract_dist_for(req_to_install) + + # Parse and return dependencies + dist = abstract_dist.get_pkg_resources_distribution() + # This will raise UnsupportedPythonVersion if the given Python + # version isn't compatible with the distribution's Requires-Python. + _check_dist_requires_python( + dist, version_info=self._py_version_info, + ignore_requires_python=self.ignore_requires_python, + ) + + more_reqs = [] # type: List[InstallRequirement] + + def add_req(subreq, extras_requested): + sub_install_req = install_req_from_req_string( + str(subreq), + req_to_install, + isolated=self.isolated, + wheel_cache=self.wheel_cache, + use_pep517=self.use_pep517 + ) + parent_req_name = req_to_install.name + to_scan_again, add_to_parent = requirement_set.add_requirement( + sub_install_req, + parent_req_name=parent_req_name, + extras_requested=extras_requested, + ) + if parent_req_name and add_to_parent: + self._discovered_dependencies[parent_req_name].append( + add_to_parent + ) + more_reqs.extend(to_scan_again) + + with indent_log(): + # We add req_to_install before its dependencies, so that we + # can refer to it when adding dependencies. + if not requirement_set.has_requirement(req_to_install.name): + # 'unnamed' requirements will get added here + req_to_install.is_direct = True + requirement_set.add_requirement( + req_to_install, parent_req_name=None, + ) + + if not self.ignore_dependencies: + if req_to_install.extras: + logger.debug( + "Installing extra requirements: %r", + ','.join(req_to_install.extras), + ) + missing_requested = sorted( + set(req_to_install.extras) - set(dist.extras) + ) + for missing in missing_requested: + logger.warning( + '%s does not provide the extra \'%s\'', + dist, missing + ) + + available_requested = sorted( + set(dist.extras) & set(req_to_install.extras) + ) + for subreq in dist.requires(available_requested): + add_req(subreq, extras_requested=available_requested) + + if not req_to_install.editable and not req_to_install.satisfied_by: + # XXX: --no-install leads this to report 'Successfully + # downloaded' for only non-editable reqs, even though we took + # action on them. + requirement_set.successfully_downloaded.append(req_to_install) + + return more_reqs + + def get_installation_order(self, req_set): + # type: (RequirementSet) -> List[InstallRequirement] + """Create the installation order. + + The installation order is topological - requirements are installed + before the requiring thing. We break cycles at an arbitrary point, + and make no other guarantees. + """ + # The current implementation, which we may change at any point + # installs the user specified things in the order given, except when + # dependencies must come earlier to achieve topological order. + order = [] + ordered_reqs = set() # type: Set[InstallRequirement] + + def schedule(req): + if req.satisfied_by or req in ordered_reqs: + return + if req.constraint: + return + ordered_reqs.add(req) + for dep in self._discovered_dependencies[req.name]: + schedule(dep) + order.append(req) + + for install_req in req_set.requirements.values(): + schedule(install_req) + return order diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8fdee66ffe66d7ca8bb6545587e21039cd8b25cb --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/__init__.py @@ -0,0 +1,11 @@ +"""CacheControl import Interface. + +Make it easy to import from cachecontrol without long namespaces. +""" +__author__ = "Eric Larson" +__email__ = "eric@ionrock.org" +__version__ = "0.12.5" + +from .wrapper import CacheControl +from .adapter import CacheControlAdapter +from .controller import CacheController diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/_cmd.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/_cmd.py new file mode 100644 index 0000000000000000000000000000000000000000..f1e0ad94a1ce2cd06bf381845fafbecbd9846f88 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/_cmd.py @@ -0,0 +1,57 @@ +import logging + +from pip._vendor import requests + +from pip._vendor.cachecontrol.adapter import CacheControlAdapter +from pip._vendor.cachecontrol.cache import DictCache +from pip._vendor.cachecontrol.controller import logger + +from argparse import ArgumentParser + + +def setup_logging(): + logger.setLevel(logging.DEBUG) + handler = logging.StreamHandler() + logger.addHandler(handler) + + +def get_session(): + adapter = CacheControlAdapter( + DictCache(), cache_etags=True, serializer=None, heuristic=None + ) + sess = requests.Session() + sess.mount("http://", adapter) + sess.mount("https://", adapter) + + sess.cache_controller = adapter.controller + return sess + + +def get_args(): + parser = ArgumentParser() + parser.add_argument("url", help="The URL to try and cache") + return parser.parse_args() + + +def main(args=None): + args = get_args() + sess = get_session() + + # Make a request to get a response + resp = sess.get(args.url) + + # Turn on logging + setup_logging() + + # try setting the cache + sess.cache_controller.cache_response(resp.request, resp.raw) + + # Now try to get it + if sess.cache_controller.cached_request(resp.request): + print("Cached!") + else: + print("Not cached :(") + + +if __name__ == "__main__": + main() diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/serialize.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/serialize.py new file mode 100644 index 0000000000000000000000000000000000000000..ec43ff27a873e96c3cb5f0964fedbb110e57b1f3 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/serialize.py @@ -0,0 +1,186 @@ +import base64 +import io +import json +import zlib + +from pip._vendor import msgpack +from pip._vendor.requests.structures import CaseInsensitiveDict + +from .compat import HTTPResponse, pickle, text_type + + +def _b64_decode_bytes(b): + return base64.b64decode(b.encode("ascii")) + + +def _b64_decode_str(s): + return _b64_decode_bytes(s).decode("utf8") + + +class Serializer(object): + + def dumps(self, request, response, body=None): + response_headers = CaseInsensitiveDict(response.headers) + + if body is None: + body = response.read(decode_content=False) + + # NOTE: 99% sure this is dead code. I'm only leaving it + # here b/c I don't have a test yet to prove + # it. Basically, before using + # `cachecontrol.filewrapper.CallbackFileWrapper`, + # this made an effort to reset the file handle. The + # `CallbackFileWrapper` short circuits this code by + # setting the body as the content is consumed, the + # result being a `body` argument is *always* passed + # into cache_response, and in turn, + # `Serializer.dump`. + response._fp = io.BytesIO(body) + + # NOTE: This is all a bit weird, but it's really important that on + # Python 2.x these objects are unicode and not str, even when + # they contain only ascii. The problem here is that msgpack + # understands the difference between unicode and bytes and we + # have it set to differentiate between them, however Python 2 + # doesn't know the difference. Forcing these to unicode will be + # enough to have msgpack know the difference. + data = { + u"response": { + u"body": body, + u"headers": dict( + (text_type(k), text_type(v)) for k, v in response.headers.items() + ), + u"status": response.status, + u"version": response.version, + u"reason": text_type(response.reason), + u"strict": response.strict, + u"decode_content": response.decode_content, + } + } + + # Construct our vary headers + data[u"vary"] = {} + if u"vary" in response_headers: + varied_headers = response_headers[u"vary"].split(",") + for header in varied_headers: + header = text_type(header).strip() + header_value = request.headers.get(header, None) + if header_value is not None: + header_value = text_type(header_value) + data[u"vary"][header] = header_value + + return b",".join([b"cc=4", msgpack.dumps(data, use_bin_type=True)]) + + def loads(self, request, data): + # Short circuit if we've been given an empty set of data + if not data: + return + + # Determine what version of the serializer the data was serialized + # with + try: + ver, data = data.split(b",", 1) + except ValueError: + ver = b"cc=0" + + # Make sure that our "ver" is actually a version and isn't a false + # positive from a , being in the data stream. + if ver[:3] != b"cc=": + data = ver + data + ver = b"cc=0" + + # Get the version number out of the cc=N + ver = ver.split(b"=", 1)[-1].decode("ascii") + + # Dispatch to the actual load method for the given version + try: + return getattr(self, "_loads_v{}".format(ver))(request, data) + + except AttributeError: + # This is a version we don't have a loads function for, so we'll + # just treat it as a miss and return None + return + + def prepare_response(self, request, cached): + """Verify our vary headers match and construct a real urllib3 + HTTPResponse object. + """ + # Special case the '*' Vary value as it means we cannot actually + # determine if the cached response is suitable for this request. + if "*" in cached.get("vary", {}): + return + + # Ensure that the Vary headers for the cached response match our + # request + for header, value in cached.get("vary", {}).items(): + if request.headers.get(header, None) != value: + return + + body_raw = cached["response"].pop("body") + + headers = CaseInsensitiveDict(data=cached["response"]["headers"]) + if headers.get("transfer-encoding", "") == "chunked": + headers.pop("transfer-encoding") + + cached["response"]["headers"] = headers + + try: + body = io.BytesIO(body_raw) + except TypeError: + # This can happen if cachecontrol serialized to v1 format (pickle) + # using Python 2. A Python 2 str(byte string) will be unpickled as + # a Python 3 str (unicode string), which will cause the above to + # fail with: + # + # TypeError: 'str' does not support the buffer interface + body = io.BytesIO(body_raw.encode("utf8")) + + return HTTPResponse(body=body, preload_content=False, **cached["response"]) + + def _loads_v0(self, request, data): + # The original legacy cache data. This doesn't contain enough + # information to construct everything we need, so we'll treat this as + # a miss. + return + + def _loads_v1(self, request, data): + try: + cached = pickle.loads(data) + except ValueError: + return + + return self.prepare_response(request, cached) + + def _loads_v2(self, request, data): + try: + cached = json.loads(zlib.decompress(data).decode("utf8")) + except (ValueError, zlib.error): + return + + # We need to decode the items that we've base64 encoded + cached["response"]["body"] = _b64_decode_bytes(cached["response"]["body"]) + cached["response"]["headers"] = dict( + (_b64_decode_str(k), _b64_decode_str(v)) + for k, v in cached["response"]["headers"].items() + ) + cached["response"]["reason"] = _b64_decode_str(cached["response"]["reason"]) + cached["vary"] = dict( + (_b64_decode_str(k), _b64_decode_str(v) if v is not None else v) + for k, v in cached["vary"].items() + ) + + return self.prepare_response(request, cached) + + def _loads_v3(self, request, data): + # Due to Python 2 encoding issues, it's impossible to know for sure + # exactly how to load v3 entries, thus we'll treat these as a miss so + # that they get rewritten out as v4 entries. + return + + def _loads_v4(self, request, data): + try: + cached = msgpack.loads(data, encoding="utf-8") + except ValueError: + return + + return self.prepare_response(request, cached) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/wrapper.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/wrapper.py new file mode 100644 index 0000000000000000000000000000000000000000..265bfc8bc1ee4328465f88d894a43e3cdfac11e0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/cachecontrol/wrapper.py @@ -0,0 +1,29 @@ +from .adapter import CacheControlAdapter +from .cache import DictCache + + +def CacheControl( + sess, + cache=None, + cache_etags=True, + serializer=None, + heuristic=None, + controller_class=None, + adapter_class=None, + cacheable_methods=None, +): + + cache = cache or DictCache() + adapter_class = adapter_class or CacheControlAdapter + adapter = adapter_class( + cache, + cache_etags=cache_etags, + serializer=serializer, + heuristic=heuristic, + controller_class=controller_class, + cacheable_methods=cacheable_methods, + ) + sess.mount("http://", adapter) + sess.mount("https://", adapter) + + return sess diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..8ccb14e24adf56704cc3ffb455bf28882989ad01 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/__init__.py @@ -0,0 +1,3 @@ +from .core import where + +__version__ = "2019.06.16" diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/__main__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/__main__.py new file mode 100644 index 0000000000000000000000000000000000000000..ae2aff5c804e56e500ad1e7657c73f856beb9a58 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/__main__.py @@ -0,0 +1,2 @@ +from pip._vendor.certifi import where +print(where()) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/cacert.pem b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/cacert.pem new file mode 100644 index 0000000000000000000000000000000000000000..9ca290f5eee07ee2a81047814daafa1150e8a026 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/cacert.pem @@ -0,0 +1,4618 @@ + +# Issuer: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA +# Subject: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA +# Label: "GlobalSign Root CA" +# Serial: 4835703278459707669005204 +# MD5 Fingerprint: 3e:45:52:15:09:51:92:e1:b7:5d:37:9f:b1:87:29:8a +# SHA1 Fingerprint: b1:bc:96:8b:d4:f4:9d:62:2a:a8:9a:81:f2:15:01:52:a4:1d:82:9c +# SHA256 Fingerprint: eb:d4:10:40:e4:bb:3e:c7:42:c9:e3:81:d3:1e:f2:a4:1a:48:b6:68:5c:96:e7:ce:f3:c1:df:6c:d4:33:1c:99 +-----BEGIN CERTIFICATE----- +MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG +A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv +b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw +MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i +YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT +aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ +jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp +xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp +1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG +snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ +U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8 +9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E +BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B +AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz +yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE +38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP +AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad +DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME +HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A== +-----END CERTIFICATE----- + +# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2 +# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2 +# Label: "GlobalSign Root CA - R2" +# Serial: 4835703278459682885658125 +# MD5 Fingerprint: 94:14:77:7e:3e:5e:fd:8f:30:bd:41:b0:cf:e7:d0:30 +# SHA1 Fingerprint: 75:e0:ab:b6:13:85:12:27:1c:04:f8:5f:dd:de:38:e4:b7:24:2e:fe +# SHA256 Fingerprint: ca:42:dd:41:74:5f:d0:b8:1e:b9:02:36:2c:f9:d8:bf:71:9d:a1:bd:1b:1e:fc:94:6f:5b:4c:99:f4:2c:1b:9e +-----BEGIN CERTIFICATE----- +MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G +A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp +Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1 +MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG +A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL +v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8 +eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq +tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd +C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa +zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB +mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH +V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n +bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG +3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs +J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO +291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS +ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd +AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7 +TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg== +-----END CERTIFICATE----- + +# Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only +# Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only +# Label: "Verisign Class 3 Public Primary Certification Authority - G3" +# Serial: 206684696279472310254277870180966723415 +# MD5 Fingerprint: cd:68:b6:a7:c7:c4:ce:75:e0:1d:4f:57:44:61:92:09 +# SHA1 Fingerprint: 13:2d:0d:45:53:4b:69:97:cd:b2:d5:c3:39:e2:55:76:60:9b:5c:c6 +# SHA256 Fingerprint: eb:04:cf:5e:b1:f3:9a:fa:76:2f:2b:b1:20:f2:96:cb:a5:20:c1:b9:7d:b1:58:95:65:b8:1c:b9:a1:7b:72:44 +-----BEGIN CERTIFICATE----- +MIIEGjCCAwICEQCbfgZJoz5iudXukEhxKe9XMA0GCSqGSIb3DQEBBQUAMIHKMQsw +CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl +cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu +LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT +aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp +dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD +VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT +aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ +bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu +IENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMu6nFL8eB8aHm8b +N3O9+MlrlBIwT/A2R/XQkQr1F8ilYcEWQE37imGQ5XYgwREGfassbqb1EUGO+i2t +KmFZpGcmTNDovFJbcCAEWNF6yaRpvIMXZK0Fi7zQWM6NjPXr8EJJC52XJ2cybuGu +kxUccLwgTS8Y3pKI6GyFVxEa6X7jJhFUokWWVYPKMIno3Nij7SqAP395ZVc+FSBm +CC+Vk7+qRy+oRpfwEuL+wgorUeZ25rdGt+INpsyow0xZVYnm6FNcHOqd8GIWC6fJ +Xwzw3sJ2zq/3avL6QaaiMxTJ5Xpj055iN9WFZZ4O5lMkdBteHRJTW8cs54NJOxWu +imi5V5cCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAERSWwauSCPc/L8my/uRan2Te +2yFPhpk0djZX3dAVL8WtfxUfN2JzPtTnX84XA9s1+ivbrmAJXx5fj267Cz3qWhMe +DGBvtcC1IyIuBwvLqXTLR7sdwdela8wv0kL9Sd2nic9TutoAWii/gt/4uhMdUIaC +/Y4wjylGsB49Ndo4YhYYSq3mtlFs3q9i6wHQHiT+eo8SGhJouPtmmRQURVyu565p +F4ErWjfJXir0xuKhXFSbplQAz/DxwceYMBo7Nhbbo27q/a2ywtrvAkcTisDxszGt +TxzhT5yvDwyd93gN2PQ1VoDat20Xj50egWTh/sVFuq1ruQp6Tk9LhO5L8X3dEQ== +-----END CERTIFICATE----- + +# Issuer: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited +# Subject: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited +# Label: "Entrust.net Premium 2048 Secure Server CA" +# Serial: 946069240 +# MD5 Fingerprint: ee:29:31:bc:32:7e:9a:e6:e8:b5:f7:51:b4:34:71:90 +# SHA1 Fingerprint: 50:30:06:09:1d:97:d4:f5:ae:39:f7:cb:e7:92:7d:7d:65:2d:34:31 +# SHA256 Fingerprint: 6d:c4:71:72:e0:1c:bc:b0:bf:62:58:0d:89:5f:e2:b8:ac:9a:d4:f8:73:80:1e:0c:10:b9:c8:37:d2:1e:b1:77 +-----BEGIN CERTIFICATE----- +MIIEKjCCAxKgAwIBAgIEOGPe+DANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML +RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp +bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5 +IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0yOTA3 +MjQxNDE1MTJaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3 +LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp +YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG +A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq +K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe +sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX +MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT +XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/ +HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH +4QIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV +HQ4EFgQUVeSB0RGAvtiJuQijMfmhJAkWuXAwDQYJKoZIhvcNAQEFBQADggEBADub +j1abMOdTmXx6eadNl9cZlZD7Bh/KM3xGY4+WZiT6QBshJ8rmcnPyT/4xmf3IDExo +U8aAghOY+rat2l098c5u9hURlIIM7j+VrxGrD9cv3h8Dj1csHsm7mhpElesYT6Yf +zX1XEC+bBAlahLVu2B064dae0Wx5XnkcFMXj0EyTO2U87d89vqbllRrDtRnDvV5b +u/8j72gZyxKTJ1wDLW8w0B62GqzeWvfRqqgnpv55gcR5mTNXuhKwqeBCbJPKVt7+ +bYQLCIt+jerXmCHG8+c8eS9enNFMFY3h7CI3zJpDC5fcgJCNs2ebb0gIFVbPv/Er +fF6adulZkMV8gzURZVE= +-----END CERTIFICATE----- + +# Issuer: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust +# Subject: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust +# Label: "Baltimore CyberTrust Root" +# Serial: 33554617 +# MD5 Fingerprint: ac:b6:94:a5:9c:17:e0:d7:91:52:9b:b1:97:06:a6:e4 +# SHA1 Fingerprint: d4:de:20:d0:5e:66:fc:53:fe:1a:50:88:2c:78:db:28:52:ca:e4:74 +# SHA256 Fingerprint: 16:af:57:a9:f6:76:b0:ab:12:60:95:aa:5e:ba:de:f2:2a:b3:11:19:d6:44:ac:95:cd:4b:93:db:f3:f2:6a:eb +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ +RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD +VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX +DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y +ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy +VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr +mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr +IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK +mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu +XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy +dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye +jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1 +BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3 +DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92 +9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx +jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0 +Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz +ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS +R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp +-----END CERTIFICATE----- + +# Issuer: CN=AddTrust External CA Root O=AddTrust AB OU=AddTrust External TTP Network +# Subject: CN=AddTrust External CA Root O=AddTrust AB OU=AddTrust External TTP Network +# Label: "AddTrust External Root" +# Serial: 1 +# MD5 Fingerprint: 1d:35:54:04:85:78:b0:3f:42:42:4d:bf:20:73:0a:3f +# SHA1 Fingerprint: 02:fa:f3:e2:91:43:54:68:60:78:57:69:4d:f5:e4:5b:68:85:18:68 +# SHA256 Fingerprint: 68:7f:a4:51:38:22:78:ff:f0:c8:b1:1f:8d:43:d5:76:67:1c:6e:b2:bc:ea:b4:13:fb:83:d9:65:d0:6d:2f:f2 +-----BEGIN CERTIFICATE----- +MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU +MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs +IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290 +MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux +FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h +bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v +dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt +H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9 +uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX +mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX +a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN +E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0 +WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD +VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0 +Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU +cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx +IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN +AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH +YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5 +6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC +Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX +c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a +mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ= +-----END CERTIFICATE----- + +# Issuer: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc. +# Subject: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc. +# Label: "Entrust Root Certification Authority" +# Serial: 1164660820 +# MD5 Fingerprint: d6:a5:c3:ed:5d:dd:3e:00:c1:3d:87:92:1f:1d:3f:e4 +# SHA1 Fingerprint: b3:1e:b1:b7:40:e3:6c:84:02:da:dc:37:d4:4d:f5:d4:67:49:52:f9 +# SHA256 Fingerprint: 73:c1:76:43:4f:1b:c6:d5:ad:f4:5b:0e:76:e7:27:28:7c:8d:e5:76:16:c1:e6:e6:14:1a:2b:2c:bc:7d:8e:4c +-----BEGIN CERTIFICATE----- +MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC +VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0 +Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW +KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl +cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw +NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw +NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy +ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV +BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ +KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo +Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4 +4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9 +KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI +rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi +94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB +sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi +gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo +kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE +vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA +A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t +O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua +AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP +9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/ +eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m +0vdXcDazv/wor3ElhVsT/h5/WrQ8 +-----END CERTIFICATE----- + +# Issuer: CN=GeoTrust Global CA O=GeoTrust Inc. +# Subject: CN=GeoTrust Global CA O=GeoTrust Inc. +# Label: "GeoTrust Global CA" +# Serial: 144470 +# MD5 Fingerprint: f7:75:ab:29:fb:51:4e:b7:77:5e:ff:05:3c:99:8e:f5 +# SHA1 Fingerprint: de:28:f4:a4:ff:e5:b9:2f:a3:c5:03:d1:a3:49:a7:f9:96:2a:82:12 +# SHA256 Fingerprint: ff:85:6a:2d:25:1d:cd:88:d3:66:56:f4:50:12:67:98:cf:ab:aa:de:40:79:9c:72:2d:e4:d2:b5:db:36:a7:3a +-----BEGIN CERTIFICATE----- +MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT +MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i +YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG +EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg +R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9 +9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq +fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv +iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU +1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+ +bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW +MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA +ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l +uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn +Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS +tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF +PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un +hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV +5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw== +-----END CERTIFICATE----- + +# Issuer: CN=GeoTrust Universal CA O=GeoTrust Inc. +# Subject: CN=GeoTrust Universal CA O=GeoTrust Inc. +# Label: "GeoTrust Universal CA" +# Serial: 1 +# MD5 Fingerprint: 92:65:58:8b:a2:1a:31:72:73:68:5c:b4:a5:7a:07:48 +# SHA1 Fingerprint: e6:21:f3:35:43:79:05:9a:4b:68:30:9d:8a:2f:74:22:15:87:ec:79 +# SHA256 Fingerprint: a0:45:9b:9f:63:b2:25:59:f5:fa:5d:4c:6d:b3:f9:f7:2f:f1:93:42:03:35:78:f0:73:bf:1d:1b:46:cb:b9:12 +-----BEGIN CERTIFICATE----- +MIIFaDCCA1CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEeMBwGA1UEAxMVR2VvVHJ1c3QgVW5pdmVy +c2FsIENBMB4XDTA0MDMwNDA1MDAwMFoXDTI5MDMwNDA1MDAwMFowRTELMAkGA1UE +BhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xHjAcBgNVBAMTFUdlb1RydXN0 +IFVuaXZlcnNhbCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKYV +VaCjxuAfjJ0hUNfBvitbtaSeodlyWL0AG0y/YckUHUWCq8YdgNY96xCcOq9tJPi8 +cQGeBvV8Xx7BDlXKg5pZMK4ZyzBIle0iN430SppyZj6tlcDgFgDgEB8rMQ7XlFTT +QjOgNB0eRXbdT8oYN+yFFXoZCPzVx5zw8qkuEKmS5j1YPakWaDwvdSEYfyh3peFh +F7em6fgemdtzbvQKoiFs7tqqhZJmr/Z6a4LauiIINQ/PQvE1+mrufislzDoR5G2v +c7J2Ha3QsnhnGqQ5HFELZ1aD/ThdDc7d8Lsrlh/eezJS/R27tQahsiFepdaVaH/w +mZ7cRQg+59IJDTWU3YBOU5fXtQlEIGQWFwMCTFMNaN7VqnJNk22CDtucvc+081xd +VHppCZbW2xHBjXWotM85yM48vCR85mLK4b19p71XZQvk/iXttmkQ3CgaRr0BHdCX +teGYO8A3ZNY9lO4L4fUorgtWv3GLIylBjobFS1J72HGrH4oVpjuDWtdYAVHGTEHZ +f9hBZ3KiKN9gg6meyHv8U3NyWfWTehd2Ds735VzZC1U0oqpbtWpU5xPKV+yXbfRe +Bi9Fi1jUIxaS5BZuKGNZMN9QAZxjiRqf2xeUgnA3wySemkfWWspOqGmJch+RbNt+ +nhutxx9z3SxPGWX9f5NAEC7S8O08ni4oPmkmM8V7AgMBAAGjYzBhMA8GA1UdEwEB +/wQFMAMBAf8wHQYDVR0OBBYEFNq7LqqwDLiIJlF0XG0D08DYj3rWMB8GA1UdIwQY +MBaAFNq7LqqwDLiIJlF0XG0D08DYj3rWMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG +9w0BAQUFAAOCAgEAMXjmx7XfuJRAyXHEqDXsRh3ChfMoWIawC/yOsjmPRFWrZIRc +aanQmjg8+uUfNeVE44B5lGiku8SfPeE0zTBGi1QrlaXv9z+ZhP015s8xxtxqv6fX +IwjhmF7DWgh2qaavdy+3YL1ERmrvl/9zlcGO6JP7/TG37FcREUWbMPEaiDnBTzyn +ANXH/KttgCJwpQzgXQQpAvvLoJHRfNbDflDVnVi+QTjruXU8FdmbyUqDWcDaU/0z +uzYYm4UPFd3uLax2k7nZAY1IEKj79TiG8dsKxr2EoyNB3tZ3b4XUhRxQ4K5RirqN +Pnbiucon8l+f725ZDQbYKxek0nxru18UGkiPGkzns0ccjkxFKyDuSN/n3QmOGKja +QI2SJhFTYXNd673nxE0pN2HrrDktZy4W1vUAg4WhzH92xH3kt0tm7wNFYGm2DFKW +koRepqO1pD4r2czYG0eq8kTaT/kD6PAUyz/zg97QwVTjt+gKN02LIFkDMBmhLMi9 +ER/frslKxfMnZmaGrGiR/9nmUxwPi1xpZQomyB40w11Re9epnAahNt3ViZS82eQt +DF4JbAiXfKM9fJP/P6EUp8+1Xevb2xzEdt+Iub1FBZUbrvxGakyvSOPOrg/Sfuvm +bJxPgWp6ZKy7PtXny3YuxadIwVyQD8vIP/rmMuGNG2+k5o7Y+SlIis5z/iw= +-----END CERTIFICATE----- + +# Issuer: CN=GeoTrust Universal CA 2 O=GeoTrust Inc. +# Subject: CN=GeoTrust Universal CA 2 O=GeoTrust Inc. +# Label: "GeoTrust Universal CA 2" +# Serial: 1 +# MD5 Fingerprint: 34:fc:b8:d0:36:db:9e:14:b3:c2:f2:db:8f:e4:94:c7 +# SHA1 Fingerprint: 37:9a:19:7b:41:85:45:35:0c:a6:03:69:f3:3c:2e:af:47:4f:20:79 +# SHA256 Fingerprint: a0:23:4f:3b:c8:52:7c:a5:62:8e:ec:81:ad:5d:69:89:5d:a5:68:0d:c9:1d:1c:b8:47:7f:33:f8:78:b9:5b:0b +-----BEGIN CERTIFICATE----- +MIIFbDCCA1SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBHMQswCQYDVQQGEwJVUzEW +MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1c3QgVW5pdmVy +c2FsIENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMjkwMzA0MDUwMDAwWjBHMQswCQYD +VQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1 +c3QgVW5pdmVyc2FsIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC +AQCzVFLByT7y2dyxUxpZKeexw0Uo5dfR7cXFS6GqdHtXr0om/Nj1XqduGdt0DE81 +WzILAePb63p3NeqqWuDW6KFXlPCQo3RWlEQwAx5cTiuFJnSCegx2oG9NzkEtoBUG +FF+3Qs17j1hhNNwqCPkuwwGmIkQcTAeC5lvO0Ep8BNMZcyfwqph/Lq9O64ceJHdq +XbboW0W63MOhBW9Wjo8QJqVJwy7XQYci4E+GymC16qFjwAGXEHm9ADwSbSsVsaxL +se4YuU6W3Nx2/zu+z18DwPw76L5GG//aQMJS9/7jOvdqdzXQ2o3rXhhqMcceujwb +KNZrVMaqW9eiLBsZzKIC9ptZvTdrhrVtgrrY6slWvKk2WP0+GfPtDCapkzj4T8Fd +IgbQl+rhrcZV4IErKIM6+vR7IVEAvlI4zs1meaj0gVbi0IMJR1FbUGrP20gaXT73 +y/Zl92zxlfgCOzJWgjl6W70viRu/obTo/3+NjN8D8WBOWBFM66M/ECuDmgFz2ZRt +hAAnZqzwcEAJQpKtT5MNYQlRJNiS1QuUYbKHsu3/mjX/hVTK7URDrBs8FmtISgoc +QIgfksILAAX/8sgCSqSqqcyZlpwvWOB94b67B9xfBHJcMTTD7F8t4D1kkCLm0ey4 +Lt1ZrtmhN79UNdxzMk+MBB4zsslG8dhcyFVQyWi9qLo2CQIDAQABo2MwYTAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAfBgNV +HSMEGDAWgBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAOBgNVHQ8BAf8EBAMCAYYwDQYJ +KoZIhvcNAQEFBQADggIBAGbBxiPz2eAubl/oz66wsCVNK/g7WJtAJDday6sWSf+z +dXkzoS9tcBc0kf5nfo/sm+VegqlVHy/c1FEHEv6sFj4sNcZj/NwQ6w2jqtB8zNHQ +L1EuxBRa3ugZ4T7GzKQp5y6EqgYweHZUcyiYWTjgAA1i00J9IZ+uPTqM1fp3DRgr +Fg5fNuH8KrUwJM/gYwx7WBr+mbpCErGR9Hxo4sjoryzqyX6uuyo9DRXcNJW2GHSo +ag/HtPQTxORb7QrSpJdMKu0vbBKJPfEncKpqA1Ihn0CoZ1Dy81of398j9tx4TuaY +T1U6U+Pv8vSfx3zYWK8pIpe44L2RLrB27FcRz+8pRPPphXpgY+RdM4kX2TGq2tbz +GDVyz4crL2MjhF2EjD9XoIj8mZEoJmmZ1I+XRL6O1UixpCgp8RW04eWe3fiPpm8m +1wk8OhwRDqZsN/etRIcsKMfYdIKz0G9KV7s1KSegi+ghp4dkNl3M2Basx7InQJJV +OCiNUW7dFGdTbHFcJoRNdVq2fmBWqU2t+5sel/MN2dKXVHfaPRK34B7vCAas+YWH +6aLcr34YEoP9VhdBLtUpgn2Z9DH2canPLAEnpQW5qrJITirvn5NSUZU8UnOOVkwX +QMAJKOSLakhT2+zNVVXxxvjpoixMptEmX36vWkzaH6byHCx+rgIW0lbQL1dTR+iS +-----END CERTIFICATE----- + +# Issuer: CN=AAA Certificate Services O=Comodo CA Limited +# Subject: CN=AAA Certificate Services O=Comodo CA Limited +# Label: "Comodo AAA Services root" +# Serial: 1 +# MD5 Fingerprint: 49:79:04:b0:eb:87:19:ac:47:b0:bc:11:51:9b:74:d0 +# SHA1 Fingerprint: d1:eb:23:a4:6d:17:d6:8f:d9:25:64:c2:f1:f1:60:17:64:d8:e3:49 +# SHA256 Fingerprint: d7:a7:a0:fb:5d:7e:27:31:d7:71:e9:48:4e:bc:de:f7:1d:5f:0c:3e:0a:29:48:78:2b:c8:3e:e0:ea:69:9e:f4 +-----BEGIN CERTIFICATE----- +MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb +MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow +GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj +YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL +MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE +BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM +GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP +ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua +BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe +3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4 +YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR +rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm +ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU +oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF +MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v +QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t +b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF +AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q +GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz +Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2 +G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi +l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3 +smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg== +-----END CERTIFICATE----- + +# Issuer: CN=QuoVadis Root Certification Authority O=QuoVadis Limited OU=Root Certification Authority +# Subject: CN=QuoVadis Root Certification Authority O=QuoVadis Limited OU=Root Certification Authority +# Label: "QuoVadis Root CA" +# Serial: 985026699 +# MD5 Fingerprint: 27:de:36:fe:72:b7:00:03:00:9d:f4:f0:1e:6c:04:24 +# SHA1 Fingerprint: de:3f:40:bd:50:93:d3:9b:6c:60:f6:da:bc:07:62:01:00:89:76:c9 +# SHA256 Fingerprint: a4:5e:de:3b:bb:f0:9c:8a:e1:5c:72:ef:c0:72:68:d6:93:a2:1c:99:6f:d5:1e:67:ca:07:94:60:fd:6d:88:73 +-----BEGIN CERTIFICATE----- +MIIF0DCCBLigAwIBAgIEOrZQizANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJC +TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDElMCMGA1UECxMcUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eTEuMCwGA1UEAxMlUXVvVmFkaXMgUm9vdCBDZXJ0 +aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wMTAzMTkxODMzMzNaFw0yMTAzMTcxODMz +MzNaMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMSUw +IwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYDVQQDEyVR +dW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAv2G1lVO6V/z68mcLOhrfEYBklbTRvM16z/Yp +li4kVEAkOPcahdxYTMukJ0KX0J+DisPkBgNbAKVRHnAEdOLB1Dqr1607BxgFjv2D +rOpm2RgbaIr1VxqYuvXtdj182d6UajtLF8HVj71lODqV0D1VNk7feVcxKh7YWWVJ +WCCYfqtffp/p1k3sg3Spx2zY7ilKhSoGFPlU5tPaZQeLYzcS19Dsw3sgQUSj7cug +F+FxZc4dZjH3dgEZyH0DWLaVSR2mEiboxgx24ONmy+pdpibu5cxfvWenAScOospU +xbF6lR1xHkopigPcakXBpBlebzbNw6Kwt/5cOOJSvPhEQ+aQuwIDAQABo4ICUjCC +Ak4wPQYIKwYBBQUHAQEEMTAvMC0GCCsGAQUFBzABhiFodHRwczovL29jc3AucXVv +dmFkaXNvZmZzaG9yZS5jb20wDwYDVR0TAQH/BAUwAwEB/zCCARoGA1UdIASCAREw +ggENMIIBCQYJKwYBBAG+WAABMIH7MIHUBggrBgEFBQcCAjCBxxqBxFJlbGlhbmNl +IG9uIHRoZSBRdW9WYWRpcyBSb290IENlcnRpZmljYXRlIGJ5IGFueSBwYXJ0eSBh +c3N1bWVzIGFjY2VwdGFuY2Ugb2YgdGhlIHRoZW4gYXBwbGljYWJsZSBzdGFuZGFy +ZCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB1c2UsIGNlcnRpZmljYXRpb24gcHJh +Y3RpY2VzLCBhbmQgdGhlIFF1b1ZhZGlzIENlcnRpZmljYXRlIFBvbGljeS4wIgYI +KwYBBQUHAgEWFmh0dHA6Ly93d3cucXVvdmFkaXMuYm0wHQYDVR0OBBYEFItLbe3T +KbkGGew5Oanwl4Rqy+/fMIGuBgNVHSMEgaYwgaOAFItLbe3TKbkGGew5Oanwl4Rq +y+/foYGEpIGBMH8xCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1p +dGVkMSUwIwYDVQQLExxSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MS4wLAYD +VQQDEyVRdW9WYWRpcyBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggQ6tlCL +MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOCAQEAitQUtf70mpKnGdSk +fnIYj9lofFIk3WdvOXrEql494liwTXCYhGHoG+NpGA7O+0dQoE7/8CQfvbLO9Sf8 +7C9TqnN7Az10buYWnuulLsS/VidQK2K6vkscPFVcQR0kvoIgR13VRH56FmjffU1R +cHhXHTMe/QKZnAzNCgVPx7uOpHX6Sm2xgI4JVrmcGmD+XcHXetwReNDWXcG31a0y +mQM6isxUJTkxgXsTIlG6Rmyhu576BGxJJnSP0nPrzDCi5upZIof4l/UO/erMkqQW +xFIY6iHOsfHmhIHluqmGKPJDWl0Snawe2ajlCmqnf6CHKc/yiU3U7MXi5nrQNiOK +SnQ2+Q== +-----END CERTIFICATE----- + +# Issuer: CN=QuoVadis Root CA 2 O=QuoVadis Limited +# Subject: CN=QuoVadis Root CA 2 O=QuoVadis Limited +# Label: "QuoVadis Root CA 2" +# Serial: 1289 +# MD5 Fingerprint: 5e:39:7b:dd:f8:ba:ec:82:e9:ac:62:ba:0c:54:00:2b +# SHA1 Fingerprint: ca:3a:fb:cf:12:40:36:4b:44:b2:16:20:88:80:48:39:19:93:7c:f7 +# SHA256 Fingerprint: 85:a0:dd:7d:d7:20:ad:b7:ff:05:f8:3d:54:2b:20:9d:c7:ff:45:28:f7:d6:77:b1:83:89:fe:a5:e5:c4:9e:86 +-----BEGIN CERTIFICATE----- +MIIFtzCCA5+gAwIBAgICBQkwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x +GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv +b3QgQ0EgMjAeFw0wNjExMjQxODI3MDBaFw0zMTExMjQxODIzMzNaMEUxCzAJBgNV +BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W +YWRpcyBSb290IENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCa +GMpLlA0ALa8DKYrwD4HIrkwZhR0In6spRIXzL4GtMh6QRr+jhiYaHv5+HBg6XJxg +Fyo6dIMzMH1hVBHL7avg5tKifvVrbxi3Cgst/ek+7wrGsxDp3MJGF/hd/aTa/55J +WpzmM+Yklvc/ulsrHHo1wtZn/qtmUIttKGAr79dgw8eTvI02kfN/+NsRE8Scd3bB +rrcCaoF6qUWD4gXmuVbBlDePSHFjIuwXZQeVikvfj8ZaCuWw419eaxGrDPmF60Tp ++ARz8un+XJiM9XOva7R+zdRcAitMOeGylZUtQofX1bOQQ7dsE/He3fbE+Ik/0XX1 +ksOR1YqI0JDs3G3eicJlcZaLDQP9nL9bFqyS2+r+eXyt66/3FsvbzSUr5R/7mp/i +Ucw6UwxI5g69ybR2BlLmEROFcmMDBOAENisgGQLodKcftslWZvB1JdxnwQ5hYIiz +PtGo/KPaHbDRsSNU30R2be1B2MGyIrZTHN81Hdyhdyox5C315eXbyOD/5YDXC2Og +/zOhD7osFRXql7PSorW+8oyWHhqPHWykYTe5hnMz15eWniN9gqRMgeKh0bpnX5UH +oycR7hYQe7xFSkyyBNKr79X9DFHOUGoIMfmR2gyPZFwDwzqLID9ujWc9Otb+fVuI +yV77zGHcizN300QyNQliBJIWENieJ0f7OyHj+OsdWwIDAQABo4GwMIGtMA8GA1Ud +EwEB/wQFMAMBAf8wCwYDVR0PBAQDAgEGMB0GA1UdDgQWBBQahGK8SEwzJQTU7tD2 +A8QZRtGUazBuBgNVHSMEZzBlgBQahGK8SEwzJQTU7tD2A8QZRtGUa6FJpEcwRTEL +MAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMT +ElF1b1ZhZGlzIFJvb3QgQ0EgMoICBQkwDQYJKoZIhvcNAQEFBQADggIBAD4KFk2f +BluornFdLwUvZ+YTRYPENvbzwCYMDbVHZF34tHLJRqUDGCdViXh9duqWNIAXINzn +g/iN/Ae42l9NLmeyhP3ZRPx3UIHmfLTJDQtyU/h2BwdBR5YM++CCJpNVjP4iH2Bl +fF/nJrP3MpCYUNQ3cVX2kiF495V5+vgtJodmVjB3pjd4M1IQWK4/YY7yarHvGH5K +WWPKjaJW1acvvFYfzznB4vsKqBUsfU16Y8Zsl0Q80m/DShcK+JDSV6IZUaUtl0Ha +B0+pUNqQjZRG4T7wlP0QADj1O+hA4bRuVhogzG9Yje0uRY/W6ZM/57Es3zrWIozc +hLsib9D45MY56QSIPMO661V6bYCZJPVsAfv4l7CUW+v90m/xd2gNNWQjrLhVoQPR +TUIZ3Ph1WVaj+ahJefivDrkRoHy3au000LYmYjgahwz46P0u05B/B5EqHdZ+XIWD +mbA4CD/pXvk1B+TJYm5Xf6dQlfe6yJvmjqIBxdZmv3lh8zwc4bmCXF2gw+nYSL0Z +ohEUGW6yhhtoPkg3Goi3XZZenMfvJ2II4pEZXNLxId26F0KCl3GBUzGpn/Z9Yr9y +4aOTHcyKJloJONDO1w2AFrR4pTqHTI2KpdVGl/IsELm8VCLAAVBpQ570su9t+Oza +8eOx79+Rj1QqCyXBJhnEUhAFZdWCEOrCMc0u +-----END CERTIFICATE----- + +# Issuer: CN=QuoVadis Root CA 3 O=QuoVadis Limited +# Subject: CN=QuoVadis Root CA 3 O=QuoVadis Limited +# Label: "QuoVadis Root CA 3" +# Serial: 1478 +# MD5 Fingerprint: 31:85:3c:62:94:97:63:b9:aa:fd:89:4e:af:6f:e0:cf +# SHA1 Fingerprint: 1f:49:14:f7:d8:74:95:1d:dd:ae:02:c0:be:fd:3a:2d:82:75:51:85 +# SHA256 Fingerprint: 18:f1:fc:7f:20:5d:f8:ad:dd:eb:7f:e0:07:dd:57:e3:af:37:5a:9c:4d:8d:73:54:6b:f4:f1:fe:d1:e1:8d:35 +-----BEGIN CERTIFICATE----- +MIIGnTCCBIWgAwIBAgICBcYwDQYJKoZIhvcNAQEFBQAwRTELMAkGA1UEBhMCQk0x +GTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxGzAZBgNVBAMTElF1b1ZhZGlzIFJv +b3QgQ0EgMzAeFw0wNjExMjQxOTExMjNaFw0zMTExMjQxOTA2NDRaMEUxCzAJBgNV +BAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBMaW1pdGVkMRswGQYDVQQDExJRdW9W +YWRpcyBSb290IENBIDMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDM +V0IWVJzmmNPTTe7+7cefQzlKZbPoFog02w1ZkXTPkrgEQK0CSzGrvI2RaNggDhoB +4hp7Thdd4oq3P5kazethq8Jlph+3t723j/z9cI8LoGe+AaJZz3HmDyl2/7FWeUUr +H556VOijKTVopAFPD6QuN+8bv+OPEKhyq1hX51SGyMnzW9os2l2ObjyjPtr7guXd +8lyyBTNvijbO0BNO/79KDDRMpsMhvVAEVeuxu537RR5kFd5VAYwCdrXLoT9Cabwv +vWhDFlaJKjdhkf2mrk7AyxRllDdLkgbvBNDInIjbC3uBr7E9KsRlOni27tyAsdLT +mZw67mtaa7ONt9XOnMK+pUsvFrGeaDsGb659n/je7Mwpp5ijJUMv7/FfJuGITfhe +btfZFG4ZM2mnO4SJk8RTVROhUXhA+LjJou57ulJCg54U7QVSWllWp5f8nT8KKdjc +T5EOE7zelaTfi5m+rJsziO+1ga8bxiJTyPbH7pcUsMV8eFLI8M5ud2CEpukqdiDt +WAEXMJPpGovgc2PZapKUSU60rUqFxKMiMPwJ7Wgic6aIDFUhWMXhOp8q3crhkODZ +c6tsgLjoC2SToJyMGf+z0gzskSaHirOi4XCPLArlzW1oUevaPwV/izLmE1xr/l9A +4iLItLRkT9a6fUg+qGkM17uGcclzuD87nSVL2v9A6wIDAQABo4IBlTCCAZEwDwYD +VR0TAQH/BAUwAwEB/zCB4QYDVR0gBIHZMIHWMIHTBgkrBgEEAb5YAAMwgcUwgZMG +CCsGAQUFBwICMIGGGoGDQW55IHVzZSBvZiB0aGlzIENlcnRpZmljYXRlIGNvbnN0 +aXR1dGVzIGFjY2VwdGFuY2Ugb2YgdGhlIFF1b1ZhZGlzIFJvb3QgQ0EgMyBDZXJ0 +aWZpY2F0ZSBQb2xpY3kgLyBDZXJ0aWZpY2F0aW9uIFByYWN0aWNlIFN0YXRlbWVu +dC4wLQYIKwYBBQUHAgEWIWh0dHA6Ly93d3cucXVvdmFkaXNnbG9iYWwuY29tL2Nw +czALBgNVHQ8EBAMCAQYwHQYDVR0OBBYEFPLAE+CCQz777i9nMpY1XNu4ywLQMG4G +A1UdIwRnMGWAFPLAE+CCQz777i9nMpY1XNu4ywLQoUmkRzBFMQswCQYDVQQGEwJC +TTEZMBcGA1UEChMQUXVvVmFkaXMgTGltaXRlZDEbMBkGA1UEAxMSUXVvVmFkaXMg +Um9vdCBDQSAzggIFxjANBgkqhkiG9w0BAQUFAAOCAgEAT62gLEz6wPJv92ZVqyM0 +7ucp2sNbtrCD2dDQ4iH782CnO11gUyeim/YIIirnv6By5ZwkajGxkHon24QRiSem +d1o417+shvzuXYO8BsbRd2sPbSQvS3pspweWyuOEn62Iix2rFo1bZhfZFvSLgNLd ++LJ2w/w4E6oM3kJpK27zPOuAJ9v1pkQNn1pVWQvVDVJIxa6f8i+AxeoyUDUSly7B +4f/xI4hROJ/yZlZ25w9Rl6VSDE1JUZU2Pb+iSwwQHYaZTKrzchGT5Or2m9qoXadN +t54CrnMAyNojA+j56hl0YgCUyyIgvpSnWbWCar6ZeXqp8kokUvd0/bpO5qgdAm6x +DYBEwa7TIzdfu4V8K5Iu6H6li92Z4b8nby1dqnuH/grdS/yO9SbkbnBCbjPsMZ57 +k8HkyWkaPcBrTiJt7qtYTcbQQcEr6k8Sh17rRdhs9ZgC06DYVYoGmRmioHfRMJ6s +zHXug/WwYjnPbFfiTNKRCw51KBuav/0aQ/HKd/s7j2G4aSgWQgRecCocIdiP4b0j +Wy10QJLZYxkNc91pvGJHvOB0K7Lrfb5BG7XARsWhIstfTsEokt4YutUqKLsRixeT +mJlglFwjz1onl14LBQaTNx47aTbrqZ5hHY8y2o4M1nQ+ewkk2gF3R8Q7zTSMmfXK +4SVhM7JZG+Ju1zdXtg2pEto= +-----END CERTIFICATE----- + +# Issuer: O=SECOM Trust.net OU=Security Communication RootCA1 +# Subject: O=SECOM Trust.net OU=Security Communication RootCA1 +# Label: "Security Communication Root CA" +# Serial: 0 +# MD5 Fingerprint: f1:bc:63:6a:54:e0:b5:27:f5:cd:e7:1a:e3:4d:6e:4a +# SHA1 Fingerprint: 36:b1:2b:49:f9:81:9e:d7:4c:9e:bc:38:0f:c6:56:8f:5d:ac:b2:f7 +# SHA256 Fingerprint: e7:5e:72:ed:9f:56:0e:ec:6e:b4:80:00:73:a4:3f:c3:ad:19:19:5a:39:22:82:01:78:95:97:4a:99:02:6b:6c +-----BEGIN CERTIFICATE----- +MIIDWjCCAkKgAwIBAgIBADANBgkqhkiG9w0BAQUFADBQMQswCQYDVQQGEwJKUDEY +MBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYDVQQLEx5TZWN1cml0eSBDb21t +dW5pY2F0aW9uIFJvb3RDQTEwHhcNMDMwOTMwMDQyMDQ5WhcNMjMwOTMwMDQyMDQ5 +WjBQMQswCQYDVQQGEwJKUDEYMBYGA1UEChMPU0VDT00gVHJ1c3QubmV0MScwJQYD +VQQLEx5TZWN1cml0eSBDb21tdW5pY2F0aW9uIFJvb3RDQTEwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQCzs/5/022x7xZ8V6UMbXaKL0u/ZPtM7orw8yl8 +9f/uKuDp6bpbZCKamm8sOiZpUQWZJtzVHGpxxpp9Hp3dfGzGjGdnSj74cbAZJ6kJ +DKaVv0uMDPpVmDvY6CKhS3E4eayXkmmziX7qIWgGmBSWh9JhNrxtJ1aeV+7AwFb9 +Ms+k2Y7CI9eNqPPYJayX5HA49LY6tJ07lyZDo6G8SVlyTCMwhwFY9k6+HGhWZq/N +QV3Is00qVUarH9oe4kA92819uZKAnDfdDJZkndwi92SL32HeFZRSFaB9UslLqCHJ +xrHty8OVYNEP8Ktw+N/LTX7s1vqr2b1/VPKl6Xn62dZ2JChzAgMBAAGjPzA9MB0G +A1UdDgQWBBSgc0mZaNyFW2XjmygvV5+9M7wHSDALBgNVHQ8EBAMCAQYwDwYDVR0T +AQH/BAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAQEAaECpqLvkT115swW1F7NgE+vG +kl3g0dNq/vu+m22/xwVtWSDEHPC32oRYAmP6SBbvT6UL90qY8j+eG61Ha2POCEfr +Uj94nK9NrvjVT8+amCoQQTlSxN3Zmw7vkwGusi7KaEIkQmywszo+zenaSMQVy+n5 +Bw+SUEmK3TGXX8npN6o7WWWXlDLJs58+OmJYxUmtYg5xpTKqL8aJdkNAExNnPaJU +JRDL8Try2frbSVa7pv6nQTXD4IhhyYjH3zYQIphZ6rBK+1YWc26sTfcioU+tHXot +RSflMMFe8toTyyVCUZVHA4xsIcx0Qu1T/zOLjw9XARYvz6buyXAiFL39vmwLAw== +-----END CERTIFICATE----- + +# Issuer: CN=Sonera Class2 CA O=Sonera +# Subject: CN=Sonera Class2 CA O=Sonera +# Label: "Sonera Class 2 Root CA" +# Serial: 29 +# MD5 Fingerprint: a3:ec:75:0f:2e:88:df:fa:48:01:4e:0b:5c:48:6f:fb +# SHA1 Fingerprint: 37:f7:6d:e6:07:7c:90:c5:b1:3e:93:1a:b7:41:10:b4:f2:e4:9a:27 +# SHA256 Fingerprint: 79:08:b4:03:14:c1:38:10:0b:51:8d:07:35:80:7f:fb:fc:f8:51:8a:00:95:33:71:05:ba:38:6b:15:3d:d9:27 +-----BEGIN CERTIFICATE----- +MIIDIDCCAgigAwIBAgIBHTANBgkqhkiG9w0BAQUFADA5MQswCQYDVQQGEwJGSTEP +MA0GA1UEChMGU29uZXJhMRkwFwYDVQQDExBTb25lcmEgQ2xhc3MyIENBMB4XDTAx +MDQwNjA3Mjk0MFoXDTIxMDQwNjA3Mjk0MFowOTELMAkGA1UEBhMCRkkxDzANBgNV +BAoTBlNvbmVyYTEZMBcGA1UEAxMQU29uZXJhIENsYXNzMiBDQTCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAJAXSjWdyvANlsdE+hY3/Ei9vX+ALTU74W+o +Z6m/AxxNjG8yR9VBaKQTBME1DJqEQ/xcHf+Js+gXGM2RX/uJ4+q/Tl18GybTdXnt +5oTjV+WtKcT0OijnpXuENmmz/V52vaMtmdOQTiMofRhj8VQ7Jp12W5dCsv+u8E7s +3TmVToMGf+dJQMjFAbJUWmYdPfz56TwKnoG4cPABi+QjVHzIrviQHgCWctRUz2Ej +vOr7nQKV0ba5cTppCD8PtOFCx4j1P5iop7oc4HFx71hXgVB6XGt0Rg6DA5jDjqhu +8nYybieDwnPz3BjotJPqdURrBGAgcVeHnfO+oJAjPYok4doh28MCAwEAAaMzMDEw +DwYDVR0TAQH/BAUwAwEB/zARBgNVHQ4ECgQISqCqWITTXjwwCwYDVR0PBAQDAgEG +MA0GCSqGSIb3DQEBBQUAA4IBAQBazof5FnIVV0sd2ZvnoiYw7JNn39Yt0jSv9zil +zqsWuasvfDXLrNAPtEwr/IDva4yRXzZ299uzGxnq9LIR/WFxRL8oszodv7ND6J+/ +3DEIcbCdjdY0RzKQxmUk96BKfARzjzlvF4xytb1LyHr4e4PDKE6cCepnP7JnBBvD +FNr450kkkdAdavphOe9r5yF1BgfYErQhIHBCcYHaPJo2vqZbDWpsmh+Re/n570K6 +Tk6ezAyNlNzZRZxe7EJQY670XcSxEtzKO6gunRRaBXW37Ndj4ro1tgQIkejanZz2 +ZrUYrAqmVCY0M9IbwdR/GjqOC6oybtv8TyWf2TLHllpwrN9M +-----END CERTIFICATE----- + +# Issuer: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com +# Subject: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com +# Label: "XRamp Global CA Root" +# Serial: 107108908803651509692980124233745014957 +# MD5 Fingerprint: a1:0b:44:b3:ca:10:d8:00:6e:9d:0f:d8:0f:92:0a:d1 +# SHA1 Fingerprint: b8:01:86:d1:eb:9c:86:a5:41:04:cf:30:54:f3:4c:52:b7:e5:58:c6 +# SHA256 Fingerprint: ce:cd:dc:90:50:99:d8:da:df:c5:b1:d2:09:b7:37:cb:e2:c1:8c:fb:2c:10:c0:ff:0b:cf:0d:32:86:fc:1a:a2 +-----BEGIN CERTIFICATE----- +MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB +gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk +MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY +UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx +NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3 +dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy +dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB +dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6 +38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP +KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q +DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4 +qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa +JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi +PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P +BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs +jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0 +eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD +ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR +vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt +qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa +IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy +i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ +O+7ETPTsJ3xCwnR8gooJybQDJbw= +-----END CERTIFICATE----- + +# Issuer: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority +# Subject: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority +# Label: "Go Daddy Class 2 CA" +# Serial: 0 +# MD5 Fingerprint: 91:de:06:25:ab:da:fd:32:17:0c:bb:25:17:2a:84:67 +# SHA1 Fingerprint: 27:96:ba:e6:3f:18:01:e2:77:26:1b:a0:d7:77:70:02:8f:20:ee:e4 +# SHA256 Fingerprint: c3:84:6b:f2:4b:9e:93:ca:64:27:4c:0e:c6:7c:1e:cc:5e:02:4f:fc:ac:d2:d7:40:19:35:0e:81:fe:54:6a:e4 +-----BEGIN CERTIFICATE----- +MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh +MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE +YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3 +MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo +ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg +MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN +ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA +PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w +wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi +EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY +avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+ +YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE +sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h +/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5 +IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD +ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy +OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P +TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ +HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER +dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf +ReYNnyicsbkqWletNw+vHX/bvZ8= +-----END CERTIFICATE----- + +# Issuer: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority +# Subject: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority +# Label: "Starfield Class 2 CA" +# Serial: 0 +# MD5 Fingerprint: 32:4a:4b:bb:c8:63:69:9b:be:74:9a:c6:dd:1d:46:24 +# SHA1 Fingerprint: ad:7e:1c:28:b0:64:ef:8f:60:03:40:20:14:c3:d0:e3:37:0e:b5:8a +# SHA256 Fingerprint: 14:65:fa:20:53:97:b8:76:fa:a6:f0:a9:95:8e:55:90:e4:0f:cc:7f:aa:4f:b7:c2:c8:67:75:21:fb:5f:b6:58 +-----BEGIN CERTIFICATE----- +MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl +MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp +U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw +NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE +ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp +ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3 +DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf +8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN ++lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0 +X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa +K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA +1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G +A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR +zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0 +YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD +bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w +DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3 +L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D +eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl +xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp +VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY +WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q= +-----END CERTIFICATE----- + +# Issuer: O=Government Root Certification Authority +# Subject: O=Government Root Certification Authority +# Label: "Taiwan GRCA" +# Serial: 42023070807708724159991140556527066870 +# MD5 Fingerprint: 37:85:44:53:32:45:1f:20:f0:f3:95:e1:25:c4:43:4e +# SHA1 Fingerprint: f4:8b:11:bf:de:ab:be:94:54:20:71:e6:41:de:6b:be:88:2b:40:b9 +# SHA256 Fingerprint: 76:00:29:5e:ef:e8:5b:9e:1f:d6:24:db:76:06:2a:aa:ae:59:81:8a:54:d2:77:4c:d4:c0:b2:c0:11:31:e1:b3 +-----BEGIN CERTIFICATE----- +MIIFcjCCA1qgAwIBAgIQH51ZWtcvwgZEpYAIaeNe9jANBgkqhkiG9w0BAQUFADA/ +MQswCQYDVQQGEwJUVzEwMC4GA1UECgwnR292ZXJubWVudCBSb290IENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5MB4XDTAyMTIwNTEzMjMzM1oXDTMyMTIwNTEzMjMzM1ow +PzELMAkGA1UEBhMCVFcxMDAuBgNVBAoMJ0dvdmVybm1lbnQgUm9vdCBDZXJ0aWZp +Y2F0aW9uIEF1dGhvcml0eTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIB +AJoluOzMonWoe/fOW1mKydGGEghU7Jzy50b2iPN86aXfTEc2pBsBHH8eV4qNw8XR +IePaJD9IK/ufLqGU5ywck9G/GwGHU5nOp/UKIXZ3/6m3xnOUT0b3EEk3+qhZSV1q +gQdW8or5BtD3cCJNtLdBuTK4sfCxw5w/cP1T3YGq2GN49thTbqGsaoQkclSGxtKy +yhwOeYHWtXBiCAEuTk8O1RGvqa/lmr/czIdtJuTJV6L7lvnM4T9TjGxMfptTCAts +F/tnyMKtsc2AtJfcdgEWFelq16TheEfOhtX7MfP6Mb40qij7cEwdScevLJ1tZqa2 +jWR+tSBqnTuBto9AAGdLiYa4zGX+FVPpBMHWXx1E1wovJ5pGfaENda1UhhXcSTvx +ls4Pm6Dso3pdvtUqdULle96ltqqvKKyskKw4t9VoNSZ63Pc78/1Fm9G7Q3hub/FC +VGqY8A2tl+lSXunVanLeavcbYBT0peS2cWeqH+riTcFCQP5nRhc4L0c/cZyu5SHK +YS1tB6iEfC3uUSXxY5Ce/eFXiGvviiNtsea9P63RPZYLhY3Naye7twWb7LuRqQoH +EgKXTiCQ8P8NHuJBO9NAOueNXdpm5AKwB1KYXA6OM5zCppX7VRluTI6uSw+9wThN +Xo+EHWbNxWCWtFJaBYmOlXqYwZE8lSOyDvR5tMl8wUohAgMBAAGjajBoMB0GA1Ud +DgQWBBTMzO/MKWCkO7GStjz6MmKPrCUVOzAMBgNVHRMEBTADAQH/MDkGBGcqBwAE +MTAvMC0CAQAwCQYFKw4DAhoFADAHBgVnKgMAAAQUA5vwIhP/lSg209yewDL7MTqK +UWUwDQYJKoZIhvcNAQEFBQADggIBAECASvomyc5eMN1PhnR2WPWus4MzeKR6dBcZ +TulStbngCnRiqmjKeKBMmo4sIy7VahIkv9Ro04rQ2JyftB8M3jh+Vzj8jeJPXgyf +qzvS/3WXy6TjZwj/5cAWtUgBfen5Cv8b5Wppv3ghqMKnI6mGq3ZW6A4M9hPdKmaK +ZEk9GhiHkASfQlK3T8v+R0F2Ne//AHY2RTKbxkaFXeIksB7jSJaYV0eUVXoPQbFE +JPPB/hprv4j9wabak2BegUqZIJxIZhm1AHlUD7gsL0u8qV1bYH+Mh6XgUmMqvtg7 +hUAV/h62ZT/FS9p+tXo1KaMuephgIqP0fSdOLeq0dDzpD6QzDxARvBMB1uUO07+1 +EqLhRSPAzAhuYbeJq4PjJB7mXQfnHyA+z2fI56wwbSdLaG5LKlwCCDTb+HbkZ6Mm +nD+iMsJKxYEYMRBWqoTvLQr/uB930r+lWKBi5NdLkXWNiYCYfm3LU05er/ayl4WX +udpVBrkk7tfGOB5jGxI7leFYrPLfhNVfmS8NVVvmONsuP3LpSIXLuykTjx44Vbnz +ssQwmSNOXfJIoRIM3BKQCZBUkQM8R+XVyWXgt0t97EfTsws+rZ7QdAAO671RrcDe +LMDDav7v3Aun+kbfYNucpllQdSNpc5Oy+fwC00fmcc4QAu4njIT/rEUNE1yDMuAl +pYYsfPQS +-----END CERTIFICATE----- + +# Issuer: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com +# Subject: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com +# Label: "DigiCert Assured ID Root CA" +# Serial: 17154717934120587862167794914071425081 +# MD5 Fingerprint: 87:ce:0b:7b:2a:0e:49:00:e1:58:71:9b:37:a8:93:72 +# SHA1 Fingerprint: 05:63:b8:63:0d:62:d7:5a:bb:c8:ab:1e:4b:df:b5:a8:99:b2:4d:43 +# SHA256 Fingerprint: 3e:90:99:b5:01:5e:8f:48:6c:00:bc:ea:9d:11:1e:e7:21:fa:ba:35:5a:89:bc:f1:df:69:56:1e:3d:c6:32:5c +-----BEGIN CERTIFICATE----- +MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv +b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG +EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl +cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c +JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP +mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+ +wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4 +VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/ +AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB +AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW +BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun +pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC +dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf +fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm +NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx +H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe ++o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g== +-----END CERTIFICATE----- + +# Issuer: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com +# Subject: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com +# Label: "DigiCert Global Root CA" +# Serial: 10944719598952040374951832963794454346 +# MD5 Fingerprint: 79:e4:a9:84:0d:7d:3a:96:d7:c0:4f:e2:43:4c:89:2e +# SHA1 Fingerprint: a8:98:5d:3a:65:e5:e5:c4:b2:d7:d6:6d:40:c6:dd:2f:b1:9c:54:36 +# SHA256 Fingerprint: 43:48:a0:e9:44:4c:78:cb:26:5e:05:8d:5e:89:44:b4:d8:4f:96:62:bd:26:db:25:7f:89:34:a4:43:c7:01:61 +-----BEGIN CERTIFICATE----- +MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD +QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT +MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j +b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB +CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97 +nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt +43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P +T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4 +gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO +BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR +TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw +DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr +hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg +06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF +PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls +YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk +CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4= +-----END CERTIFICATE----- + +# Issuer: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com +# Subject: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com +# Label: "DigiCert High Assurance EV Root CA" +# Serial: 3553400076410547919724730734378100087 +# MD5 Fingerprint: d4:74:de:57:5c:39:b2:d3:9c:85:83:c5:c0:65:49:8a +# SHA1 Fingerprint: 5f:b7:ee:06:33:e2:59:db:ad:0c:4c:9a:e6:d3:8f:1a:61:c7:dc:25 +# SHA256 Fingerprint: 74:31:e5:f4:c3:c1:ce:46:90:77:4f:0b:61:e0:54:40:88:3b:a9:a0:1e:d0:0b:a6:ab:d7:80:6e:d3:b1:18:cf +-----BEGIN CERTIFICATE----- +MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j +ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL +MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3 +LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug +RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm ++9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW +PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM +xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB +Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3 +hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg +EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF +MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA +FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec +nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z +eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF +hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2 +Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe +vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep ++OkuE6N36B9K +-----END CERTIFICATE----- + +# Issuer: CN=Class 2 Primary CA O=Certplus +# Subject: CN=Class 2 Primary CA O=Certplus +# Label: "Certplus Class 2 Primary CA" +# Serial: 177770208045934040241468760488327595043 +# MD5 Fingerprint: 88:2c:8c:52:b8:a2:3c:f3:f7:bb:03:ea:ae:ac:42:0b +# SHA1 Fingerprint: 74:20:74:41:72:9c:dd:92:ec:79:31:d8:23:10:8d:c2:81:92:e2:bb +# SHA256 Fingerprint: 0f:99:3c:8a:ef:97:ba:af:56:87:14:0e:d5:9a:d1:82:1b:b4:af:ac:f0:aa:9a:58:b5:d5:7a:33:8a:3a:fb:cb +-----BEGIN CERTIFICATE----- +MIIDkjCCAnqgAwIBAgIRAIW9S/PY2uNp9pTXX8OlRCMwDQYJKoZIhvcNAQEFBQAw +PTELMAkGA1UEBhMCRlIxETAPBgNVBAoTCENlcnRwbHVzMRswGQYDVQQDExJDbGFz +cyAyIFByaW1hcnkgQ0EwHhcNOTkwNzA3MTcwNTAwWhcNMTkwNzA2MjM1OTU5WjA9 +MQswCQYDVQQGEwJGUjERMA8GA1UEChMIQ2VydHBsdXMxGzAZBgNVBAMTEkNsYXNz +IDIgUHJpbWFyeSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANxQ +ltAS+DXSCHh6tlJw/W/uz7kRy1134ezpfgSN1sxvc0NXYKwzCkTsA18cgCSR5aiR +VhKC9+Ar9NuuYS6JEI1rbLqzAr3VNsVINyPi8Fo3UjMXEuLRYE2+L0ER4/YXJQyL +kcAbmXuZVg2v7tK8R1fjeUl7NIknJITesezpWE7+Tt9avkGtrAjFGA7v0lPubNCd +EgETjdyAYveVqUSISnFOYFWe2yMZeVYHDD9jC1yw4r5+FfyUM1hBOHTE4Y+L3yas +H7WLO7dDWWuwJKZtkIvEcupdM5i3y95ee++U8Rs+yskhwcWYAqqi9lt3m/V+llU0 +HGdpwPFC40es/CgcZlUCAwEAAaOBjDCBiTAPBgNVHRMECDAGAQH/AgEKMAsGA1Ud +DwQEAwIBBjAdBgNVHQ4EFgQU43Mt38sOKAze3bOkynm4jrvoMIkwEQYJYIZIAYb4 +QgEBBAQDAgEGMDcGA1UdHwQwMC4wLKAqoCiGJmh0dHA6Ly93d3cuY2VydHBsdXMu +Y29tL0NSTC9jbGFzczIuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQCnVM+IRBnL39R/ +AN9WM2K191EBkOvDP9GIROkkXe/nFL0gt5o8AP5tn9uQ3Nf0YtaLcF3n5QRIqWh8 +yfFC82x/xXp8HVGIutIKPidd3i1RTtMTZGnkLuPT55sJmabglZvOGtd/vjzOUrMR +FcEPF80Du5wlFbqidon8BvEY0JNLDnyCt6X09l/+7UCmnYR0ObncHoUW2ikbhiMA +ybuJfm6AiB4vFLQDJKgybwOaRywwvlbGp0ICcBvqQNi6BQNwB6SW//1IMwrh3KWB +kJtN3X3n57LNXMhqlfil9o3EXXgIvnsG1knPGTZQIy4I5p4FTUcY1Rbpsda2ENW7 +l7+ijrRU +-----END CERTIFICATE----- + +# Issuer: CN=DST Root CA X3 O=Digital Signature Trust Co. +# Subject: CN=DST Root CA X3 O=Digital Signature Trust Co. +# Label: "DST Root CA X3" +# Serial: 91299735575339953335919266965803778155 +# MD5 Fingerprint: 41:03:52:dc:0f:f7:50:1b:16:f0:02:8e:ba:6f:45:c5 +# SHA1 Fingerprint: da:c9:02:4f:54:d8:f6:df:94:93:5f:b1:73:26:38:ca:6a:d7:7c:13 +# SHA256 Fingerprint: 06:87:26:03:31:a7:24:03:d9:09:f1:05:e6:9b:cf:0d:32:e1:bd:24:93:ff:c6:d9:20:6d:11:bc:d6:77:07:39 +-----BEGIN CERTIFICATE----- +MIIDSjCCAjKgAwIBAgIQRK+wgNajJ7qJMDmGLvhAazANBgkqhkiG9w0BAQUFADA/ +MSQwIgYDVQQKExtEaWdpdGFsIFNpZ25hdHVyZSBUcnVzdCBDby4xFzAVBgNVBAMT +DkRTVCBSb290IENBIFgzMB4XDTAwMDkzMDIxMTIxOVoXDTIxMDkzMDE0MDExNVow +PzEkMCIGA1UEChMbRGlnaXRhbCBTaWduYXR1cmUgVHJ1c3QgQ28uMRcwFQYDVQQD +Ew5EU1QgUm9vdCBDQSBYMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB +AN+v6ZdQCINXtMxiZfaQguzH0yxrMMpb7NnDfcdAwRgUi+DoM3ZJKuM/IUmTrE4O +rz5Iy2Xu/NMhD2XSKtkyj4zl93ewEnu1lcCJo6m67XMuegwGMoOifooUMM0RoOEq +OLl5CjH9UL2AZd+3UWODyOKIYepLYYHsUmu5ouJLGiifSKOeDNoJjj4XLh7dIN9b +xiqKqy69cK3FCxolkHRyxXtqqzTWMIn/5WgTe1QLyNau7Fqckh49ZLOMxt+/yUFw +7BZy1SbsOFU5Q9D8/RhcQPGX69Wam40dutolucbY38EVAjqr2m7xPi71XAicPNaD +aeQQmxkqtilX4+U9m5/wAl0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNV +HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFMSnsaR7LHH62+FLkHX/xBVghYkQMA0GCSqG +SIb3DQEBBQUAA4IBAQCjGiybFwBcqR7uKGY3Or+Dxz9LwwmglSBd49lZRNI+DT69 +ikugdB/OEIKcdBodfpga3csTS7MgROSR6cz8faXbauX+5v3gTt23ADq1cEmv8uXr +AvHRAosZy5Q6XkjEGB5YGV8eAlrwDPGxrancWYaLbumR9YbK+rlmM6pZW87ipxZz +R8srzJmwN0jP41ZL9c8PDHIyh8bwRLtTcm1D9SZImlJnt1ir/md2cXjbDaJWFBM5 +JDGFoqgCWjBH4d1QB7wCCZAA62RjYJsWvIjJEubSfZGL+T0yjWW06XyxV3bqxbYo +Ob8VZRzI9neWagqNdwvYkQsEjgfbKbYK7p2CNTUQ +-----END CERTIFICATE----- + +# Issuer: CN=SwissSign Gold CA - G2 O=SwissSign AG +# Subject: CN=SwissSign Gold CA - G2 O=SwissSign AG +# Label: "SwissSign Gold CA - G2" +# Serial: 13492815561806991280 +# MD5 Fingerprint: 24:77:d9:a8:91:d1:3b:fa:88:2d:c2:ff:f8:cd:33:93 +# SHA1 Fingerprint: d8:c5:38:8a:b7:30:1b:1b:6e:d4:7a:e6:45:25:3a:6f:9f:1a:27:61 +# SHA256 Fingerprint: 62:dd:0b:e9:b9:f5:0a:16:3e:a0:f8:e7:5c:05:3b:1e:ca:57:ea:55:c8:68:8f:64:7c:68:81:f2:c8:35:7b:95 +-----BEGIN CERTIFICATE----- +MIIFujCCA6KgAwIBAgIJALtAHEP1Xk+wMA0GCSqGSIb3DQEBBQUAMEUxCzAJBgNV +BAYTAkNIMRUwEwYDVQQKEwxTd2lzc1NpZ24gQUcxHzAdBgNVBAMTFlN3aXNzU2ln +biBHb2xkIENBIC0gRzIwHhcNMDYxMDI1MDgzMDM1WhcNMzYxMDI1MDgzMDM1WjBF +MQswCQYDVQQGEwJDSDEVMBMGA1UEChMMU3dpc3NTaWduIEFHMR8wHQYDVQQDExZT +d2lzc1NpZ24gR29sZCBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIIC +CgKCAgEAr+TufoskDhJuqVAtFkQ7kpJcyrhdhJJCEyq8ZVeCQD5XJM1QiyUqt2/8 +76LQwB8CJEoTlo8jE+YoWACjR8cGp4QjK7u9lit/VcyLwVcfDmJlD909Vopz2q5+ +bbqBHH5CjCA12UNNhPqE21Is8w4ndwtrvxEvcnifLtg+5hg3Wipy+dpikJKVyh+c +6bM8K8vzARO/Ws/BtQpgvd21mWRTuKCWs2/iJneRjOBiEAKfNA+k1ZIzUd6+jbqE +emA8atufK+ze3gE/bk3lUIbLtK/tREDFylqM2tIrfKjuvqblCqoOpd8FUrdVxyJd +MmqXl2MT28nbeTZ7hTpKxVKJ+STnnXepgv9VHKVxaSvRAiTysybUa9oEVeXBCsdt +MDeQKuSeFDNeFhdVxVu1yzSJkvGdJo+hB9TGsnhQ2wwMC3wLjEHXuendjIj3o02y +MszYF9rNt85mndT9Xv+9lz4pded+p2JYryU0pUHHPbwNUMoDAw8IWh+Vc3hiv69y +FGkOpeUDDniOJihC8AcLYiAQZzlG+qkDzAQ4embvIIO1jEpWjpEA/I5cgt6IoMPi +aG59je883WX0XaxR7ySArqpWl2/5rX3aYT+YdzylkbYcjCbaZaIJbcHiVOO5ykxM +gI93e2CaHt+28kgeDrpOVG2Y4OGiGqJ3UM/EY5LsRxmd6+ZrzsECAwEAAaOBrDCB +qTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUWyV7 +lqRlUX64OfPAeGZe6Drn8O4wHwYDVR0jBBgwFoAUWyV7lqRlUX64OfPAeGZe6Drn +8O4wRgYDVR0gBD8wPTA7BglghXQBWQECAQEwLjAsBggrBgEFBQcCARYgaHR0cDov +L3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIBACe6 +45R88a7A3hfm5djV9VSwg/S7zV4Fe0+fdWavPOhWfvxyeDgD2StiGwC5+OlgzczO +UYrHUDFu4Up+GC9pWbY9ZIEr44OE5iKHjn3g7gKZYbge9LgriBIWhMIxkziWMaa5 +O1M/wySTVltpkuzFwbs4AOPsF6m43Md8AYOfMke6UiI0HTJ6CVanfCU2qT1L2sCC +bwq7EsiHSycR+R4tx5M/nttfJmtS2S6K8RTGRI0Vqbe/vd6mGu6uLftIdxf+u+yv +GPUqUfA5hJeVbG4bwyvEdGB5JbAKJ9/fXtI5z0V9QkvfsywexcZdylU6oJxpmo/a +77KwPJ+HbBIrZXAVUjEaJM9vMSNQH4xPjyPDdEFjHFWoFN0+4FFQz/EbMFYOkrCC +hdiDyyJkvC24JdVUorgG6q2SpCSgwYa1ShNqR88uC1aVVMvOmttqtKay20EIhid3 +92qgQmwLOM7XdVAyksLfKzAiSNDVQTglXaTpXZ/GlHXQRf0wl0OPkKsKx4ZzYEpp +Ld6leNcG2mqeSz53OiATIgHQv2ieY2BrNU0LbbqhPcCT4H8js1WtciVORvnSFu+w +ZMEBnunKoGqYDs/YYPIvSbjkQuE4NRb0yG5P94FW6LqjviOvrv1vA+ACOzB2+htt +Qc8Bsem4yWb02ybzOqR08kkkW8mw0FfB+j564ZfJ +-----END CERTIFICATE----- + +# Issuer: CN=SwissSign Silver CA - G2 O=SwissSign AG +# Subject: CN=SwissSign Silver CA - G2 O=SwissSign AG +# Label: "SwissSign Silver CA - G2" +# Serial: 5700383053117599563 +# MD5 Fingerprint: e0:06:a1:c9:7d:cf:c9:fc:0d:c0:56:75:96:d8:62:13 +# SHA1 Fingerprint: 9b:aa:e5:9f:56:ee:21:cb:43:5a:be:25:93:df:a7:f0:40:d1:1d:cb +# SHA256 Fingerprint: be:6c:4d:a2:bb:b9:ba:59:b6:f3:93:97:68:37:42:46:c3:c0:05:99:3f:a9:8f:02:0d:1d:ed:be:d4:8a:81:d5 +-----BEGIN CERTIFICATE----- +MIIFvTCCA6WgAwIBAgIITxvUL1S7L0swDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UE +BhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMYU3dpc3NTaWdu +IFNpbHZlciBDQSAtIEcyMB4XDTA2MTAyNTA4MzI0NloXDTM2MTAyNTA4MzI0Nlow +RzELMAkGA1UEBhMCQ0gxFTATBgNVBAoTDFN3aXNzU2lnbiBBRzEhMB8GA1UEAxMY +U3dpc3NTaWduIFNpbHZlciBDQSAtIEcyMIICIjANBgkqhkiG9w0BAQEFAAOCAg8A +MIICCgKCAgEAxPGHf9N4Mfc4yfjDmUO8x/e8N+dOcbpLj6VzHVxumK4DV644N0Mv +Fz0fyM5oEMF4rhkDKxD6LHmD9ui5aLlV8gREpzn5/ASLHvGiTSf5YXu6t+WiE7br +YT7QbNHm+/pe7R20nqA1W6GSy/BJkv6FCgU+5tkL4k+73JU3/JHpMjUi0R86TieF +nbAVlDLaYQ1HTWBCrpJH6INaUFjpiou5XaHc3ZlKHzZnu0jkg7Y360g6rw9njxcH +6ATK72oxh9TAtvmUcXtnZLi2kUpCe2UuMGoM9ZDulebyzYLs2aFK7PayS+VFheZt +eJMELpyCbTapxDFkH4aDCyr0NQp4yVXPQbBH6TCfmb5hqAaEuSh6XzjZG6k4sIN/ +c8HDO0gqgg8hm7jMqDXDhBuDsz6+pJVpATqJAHgE2cn0mRmrVn5bi4Y5FZGkECwJ +MoBgs5PAKrYYC51+jUnyEEp/+dVGLxmSo5mnJqy7jDzmDrxHB9xzUfFwZC8I+bRH +HTBsROopN4WSaGa8gzj+ezku01DwH/teYLappvonQfGbGHLy9YR0SslnxFSuSGTf +jNFusB3hB48IHpmccelM2KX3RxIfdNFRnobzwqIjQAtz20um53MGjMGg6cFZrEb6 +5i/4z3GcRm25xBWNOHkDRUjvxF3XCO6HOSKGsg0PWEP3calILv3q1h8CAwEAAaOB +rDCBqTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU +F6DNweRBtjpbO8tFnb0cwpj6hlgwHwYDVR0jBBgwFoAUF6DNweRBtjpbO8tFnb0c +wpj6hlgwRgYDVR0gBD8wPTA7BglghXQBWQEDAQEwLjAsBggrBgEFBQcCARYgaHR0 +cDovL3JlcG9zaXRvcnkuc3dpc3NzaWduLmNvbS8wDQYJKoZIhvcNAQEFBQADggIB +AHPGgeAn0i0P4JUw4ppBf1AsX19iYamGamkYDHRJ1l2E6kFSGG9YrVBWIGrGvShp +WJHckRE1qTodvBqlYJ7YH39FkWnZfrt4csEGDyrOj4VwYaygzQu4OSlWhDJOhrs9 +xCrZ1x9y7v5RoSJBsXECYxqCsGKrXlcSH9/L3XWgwF15kIwb4FDm3jH+mHtwX6WQ +2K34ArZv02DdQEsixT2tOnqfGhpHkXkzuoLcMmkDlm4fS/Bx/uNncqCxv1yL5PqZ +IseEuRuNI5c/7SXgz2W79WEE790eslpBIlqhn10s6FvJbakMDHiqYMZWjwFaDGi8 +aRl5xB9+lwW/xekkUV7U1UtT7dkjWjYDZaPBA61BMPNGG4WQr2W11bHkFlt4dR2X +em1ZqSqPe97Dh4kQmUlzeMg9vVE1dCrV8X5pGyq7O70luJpaPXJhkGaH7gzWTdQR +dAtq/gsD/KNVV4n+SsuuWxcFyPKNIzFTONItaj+CuY0IavdeQXRuwxF+B6wpYJE/ +OMpXEA29MC/HpeZBoNquBYeaoKRlbEwJDIm6uNO5wJOKMPqN5ZprFQFOZ6raYlY+ +hAhm0sQ2fac+EPyI4NSA5QC9qvNOBqN6avlicuMJT+ubDgEj8Z+7fNzcbBGXJbLy +tGMU0gYqZ4yD9c7qB9iaah7s5Aq7KkzrCWA5zspi2C5u +-----END CERTIFICATE----- + +# Issuer: CN=GeoTrust Primary Certification Authority O=GeoTrust Inc. +# Subject: CN=GeoTrust Primary Certification Authority O=GeoTrust Inc. +# Label: "GeoTrust Primary Certification Authority" +# Serial: 32798226551256963324313806436981982369 +# MD5 Fingerprint: 02:26:c3:01:5e:08:30:37:43:a9:d0:7d:cf:37:e6:bf +# SHA1 Fingerprint: 32:3c:11:8e:1b:f7:b8:b6:52:54:e2:e2:10:0d:d6:02:90:37:f0:96 +# SHA256 Fingerprint: 37:d5:10:06:c5:12:ea:ab:62:64:21:f1:ec:8c:92:01:3f:c5:f8:2a:e9:8e:e5:33:eb:46:19:b8:de:b4:d0:6c +-----BEGIN CERTIFICATE----- +MIIDfDCCAmSgAwIBAgIQGKy1av1pthU6Y2yv2vrEoTANBgkqhkiG9w0BAQUFADBY +MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjExMC8GA1UEAxMo +R2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEx +MjcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQK +Ew1HZW9UcnVzdCBJbmMuMTEwLwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEAvrgVe//UfH1nrYNke8hCUy3f9oQIIGHWAVlqnEQRr+92/ZV+zmEwu3qDXwK9 +AWbK7hWNb6EwnL2hhZ6UOvNWiAAxz9juapYC2e0DjPt1befquFUWBRaa9OBesYjA +ZIVcFU2Ix7e64HXprQU9nceJSOC7KMgD4TCTZF5SwFlwIjVXiIrxlQqD17wxcwE0 +7e9GceBrAqg1cmuXm2bgyxx5X9gaBGgeRwLmnWDiNpcB3841kt++Z8dtd1k7j53W +kBWUvEI0EME5+bEnPn7WinXFsq+W06Lem+SYvn3h6YGttm/81w7a4DSwDRp35+MI +mO9Y+pyEtzavwt+s0vQQBnBxNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G +A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQULNVQQZcVi/CPNmFbSvtr2ZnJM5IwDQYJ +KoZIhvcNAQEFBQADggEBAFpwfyzdtzRP9YZRqSa+S7iq8XEN3GHHoOo0Hnp3DwQ1 +6CePbJC/kRYkRj5KTs4rFtULUh38H2eiAkUxT87z+gOneZ1TatnaYzr4gNfTmeGl +4b7UVXGYNTq+k+qurUKykG/g/CFNNWMziUnWm07Kx+dOCQD32sfvmWKZd7aVIl6K +oKv0uHiYyjgZmclynnjNS6yvGaBzEi38wkG6gZHaFloxt/m0cYASSJlyc1pZU8Fj +UjPtp8nSOQJw+uCxQmYpqptR7TBUIhRf2asdweSU8Pj1K/fqynhG1riR/aYNKxoU +AT6A8EKglQdebc3MS6RFjasS6LPeWuWgfOgPIh1a6Vk= +-----END CERTIFICATE----- + +# Issuer: CN=thawte Primary Root CA O=thawte, Inc. OU=Certification Services Division/(c) 2006 thawte, Inc. - For authorized use only +# Subject: CN=thawte Primary Root CA O=thawte, Inc. OU=Certification Services Division/(c) 2006 thawte, Inc. - For authorized use only +# Label: "thawte Primary Root CA" +# Serial: 69529181992039203566298953787712940909 +# MD5 Fingerprint: 8c:ca:dc:0b:22:ce:f5:be:72:ac:41:1a:11:a8:d8:12 +# SHA1 Fingerprint: 91:c6:d6:ee:3e:8a:c8:63:84:e5:48:c2:99:29:5c:75:6c:81:7b:81 +# SHA256 Fingerprint: 8d:72:2f:81:a9:c1:13:c0:79:1d:f1:36:a2:96:6d:b2:6c:95:0a:97:1d:b4:6b:41:99:f4:ea:54:b7:8b:fb:9f +-----BEGIN CERTIFICATE----- +MIIEIDCCAwigAwIBAgIQNE7VVyDV7exJ9C/ON9srbTANBgkqhkiG9w0BAQUFADCB +qTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf +Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw +MDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxHzAdBgNV +BAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwHhcNMDYxMTE3MDAwMDAwWhcNMzYw +NzE2MjM1OTU5WjCBqTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5j +LjEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYG +A1UECxMvKGMpIDIwMDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNl +IG9ubHkxHzAdBgNVBAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsoPD7gFnUnMekz52hWXMJEEUMDSxuaPFs +W0hoSVk3/AszGcJ3f8wQLZU0HObrTQmnHNK4yZc2AreJ1CRfBsDMRJSUjQJib+ta +3RGNKJpchJAQeg29dGYvajig4tVUROsdB58Hum/u6f1OCyn1PoSgAfGcq/gcfomk +6KHYcWUNo1F77rzSImANuVud37r8UVsLr5iy6S7pBOhih94ryNdOwUxkHt3Ph1i6 +Sk/KaAcdHJ1KxtUvkcx8cXIcxcBn6zL9yZJclNqFwJu/U30rCfSMnZEfl2pSy94J +NqR32HuHUETVPm4pafs5SSYeCaWAe0At6+gnhcn+Yf1+5nyXHdWdAgMBAAGjQjBA +MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBR7W0XP +r87Lev0xkhpqtvNG61dIUDANBgkqhkiG9w0BAQUFAAOCAQEAeRHAS7ORtvzw6WfU +DW5FvlXok9LOAz/t2iWwHVfLHjp2oEzsUHboZHIMpKnxuIvW1oeEuzLlQRHAd9mz +YJ3rG9XRbkREqaYB7FViHXe4XI5ISXycO1cRrK1zN44veFyQaEfZYGDm/Ac9IiAX +xPcW6cTYcvnIc3zfFi8VqT79aie2oetaupgf1eNNZAqdE8hhuvU5HIe6uL17In/2 +/qxAeeWsEG89jxt5dovEN7MhGITlNgDrYyCZuen+MwS7QcjBAvlEYyCegc5C09Y/ +LHbTY5xZ3Y+m4Q6gLkH3LpVHz7z9M/P2C2F+fpErgUfCJzDupxBdN49cOSvkBPB7 +jVaMaA== +-----END CERTIFICATE----- + +# Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G5 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2006 VeriSign, Inc. - For authorized use only +# Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G5 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2006 VeriSign, Inc. - For authorized use only +# Label: "VeriSign Class 3 Public Primary Certification Authority - G5" +# Serial: 33037644167568058970164719475676101450 +# MD5 Fingerprint: cb:17:e4:31:67:3e:e2:09:fe:45:57:93:f3:0a:fa:1c +# SHA1 Fingerprint: 4e:b6:d5:78:49:9b:1c:cf:5f:58:1e:ad:56:be:3d:9b:67:44:a5:e5 +# SHA256 Fingerprint: 9a:cf:ab:7e:43:c8:d8:80:d0:6b:26:2a:94:de:ee:e4:b4:65:99:89:c3:d0:ca:f1:9b:af:64:05:e4:1a:b7:df +-----BEGIN CERTIFICATE----- +MIIE0zCCA7ugAwIBAgIQGNrRniZ96LtKIVjNzGs7SjANBgkqhkiG9w0BAQUFADCB +yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL +ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp +U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW +ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMzYwNzE2MjM1OTU5WjCByjEL +MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJpU2ln +biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp +U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y +aXR5IC0gRzUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvJAgIKXo1 +nmAMqudLO07cfLw8RRy7K+D+KQL5VwijZIUVJ/XxrcgxiV0i6CqqpkKzj/i5Vbex +t0uz/o9+B1fs70PbZmIVYc9gDaTY3vjgw2IIPVQT60nKWVSFJuUrjxuf6/WhkcIz +SdhDY2pSS9KP6HBRTdGJaXvHcPaz3BJ023tdS1bTlr8Vd6Gw9KIl8q8ckmcY5fQG +BO+QueQA5N06tRn/Arr0PO7gi+s3i+z016zy9vA9r911kTMZHRxAy3QkGSGT2RT+ +rCpSx4/VBEnkjWNHiDxpg8v+R70rfk/Fla4OndTRQ8Bnc+MUCH7lP59zuDMKz10/ +NIeWiu5T6CUVAgMBAAGjgbIwga8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8E +BAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJaW1hZ2UvZ2lmMCEwHzAH +BgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYjaHR0cDovL2xvZ28udmVy +aXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFH/TZafC3ey78DAJ80M5+gKv +MzEzMA0GCSqGSIb3DQEBBQUAA4IBAQCTJEowX2LP2BqYLz3q3JktvXf2pXkiOOzE +p6B4Eq1iDkVwZMXnl2YtmAl+X6/WzChl8gGqCBpH3vn5fJJaCGkgDdk+bW48DW7Y +5gaRQBi5+MHt39tBquCWIMnNZBU4gcmU7qKEKQsTb47bDN0lAtukixlE0kF6BWlK +WE9gyn6CagsCqiUXObXbf+eEZSqVir2G3l6BFoMtEMze/aiCKm0oHw0LxOXnGiYZ +4fQRbxC1lfznQgUy286dUV4otp6F01vvpX1FQHKOtw5rDgb7MzVIcbidJ4vEZV8N +hnacRHr2lVz2XTIIM6RUthg/aFzyQkqFOFSDX9HoLPKsEdao7WNq +-----END CERTIFICATE----- + +# Issuer: CN=SecureTrust CA O=SecureTrust Corporation +# Subject: CN=SecureTrust CA O=SecureTrust Corporation +# Label: "SecureTrust CA" +# Serial: 17199774589125277788362757014266862032 +# MD5 Fingerprint: dc:32:c3:a7:6d:25:57:c7:68:09:9d:ea:2d:a9:a2:d1 +# SHA1 Fingerprint: 87:82:c6:c3:04:35:3b:cf:d2:96:92:d2:59:3e:7d:44:d9:34:ff:11 +# SHA256 Fingerprint: f1:c1:b5:0a:e5:a2:0d:d8:03:0e:c9:f6:bc:24:82:3d:d3:67:b5:25:57:59:b4:e7:1b:61:fc:e9:f7:37:5d:73 +-----BEGIN CERTIFICATE----- +MIIDuDCCAqCgAwIBAgIQDPCOXAgWpa1Cf/DrJxhZ0DANBgkqhkiG9w0BAQUFADBI +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x +FzAVBgNVBAMTDlNlY3VyZVRydXN0IENBMB4XDTA2MTEwNzE5MzExOFoXDTI5MTIz +MTE5NDA1NVowSDELMAkGA1UEBhMCVVMxIDAeBgNVBAoTF1NlY3VyZVRydXN0IENv +cnBvcmF0aW9uMRcwFQYDVQQDEw5TZWN1cmVUcnVzdCBDQTCCASIwDQYJKoZIhvcN +AQEBBQADggEPADCCAQoCggEBAKukgeWVzfX2FI7CT8rU4niVWJxB4Q2ZQCQXOZEz +Zum+4YOvYlyJ0fwkW2Gz4BERQRwdbvC4u/jep4G6pkjGnx29vo6pQT64lO0pGtSO +0gMdA+9tDWccV9cGrcrI9f4Or2YlSASWC12juhbDCE/RRvgUXPLIXgGZbf2IzIao +wW8xQmxSPmjL8xk037uHGFaAJsTQ3MBv396gwpEWoGQRS0S8Hvbn+mPeZqx2pHGj +7DaUaHp3pLHnDi+BeuK1cobvomuL8A/b01k/unK8RCSc43Oz969XL0Imnal0ugBS +8kvNU3xHCzaFDmapCJcWNFfBZveA4+1wVMeT4C4oFVmHursCAwEAAaOBnTCBmjAT +BgkrBgEEAYI3FAIEBh4EAEMAQTALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB +/zAdBgNVHQ4EFgQUQjK2FvoE/f5dS3rD/fdMQB1aQ68wNAYDVR0fBC0wKzApoCeg +JYYjaHR0cDovL2NybC5zZWN1cmV0cnVzdC5jb20vU1RDQS5jcmwwEAYJKwYBBAGC +NxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBADDtT0rhWDpSclu1pqNlGKa7UTt3 +6Z3q059c4EVlew3KW+JwULKUBRSuSceNQQcSc5R+DCMh/bwQf2AQWnL1mA6s7Ll/ +3XpvXdMc9P+IBWlCqQVxyLesJugutIxq/3HcuLHfmbx8IVQr5Fiiu1cprp6poxkm +D5kuCLDv/WnPmRoJjeOnnyvJNjR7JLN4TJUXpAYmHrZkUjZfYGfZnMUFdAvnZyPS +CPyI6a6Lf+Ew9Dd+/cYy2i2eRDAwbO4H3tI0/NL/QPZL9GZGBlSm8jIKYyYwa5vR +3ItHuuG51WLQoqD0ZwV4KWMabwTW+MZMo5qxN7SN5ShLHZ4swrhovO0C7jE= +-----END CERTIFICATE----- + +# Issuer: CN=Secure Global CA O=SecureTrust Corporation +# Subject: CN=Secure Global CA O=SecureTrust Corporation +# Label: "Secure Global CA" +# Serial: 9751836167731051554232119481456978597 +# MD5 Fingerprint: cf:f4:27:0d:d4:ed:dc:65:16:49:6d:3d:da:bf:6e:de +# SHA1 Fingerprint: 3a:44:73:5a:e5:81:90:1f:24:86:61:46:1e:3b:9c:c4:5f:f5:3a:1b +# SHA256 Fingerprint: 42:00:f5:04:3a:c8:59:0e:bb:52:7d:20:9e:d1:50:30:29:fb:cb:d4:1c:a1:b5:06:ec:27:f1:5a:de:7d:ac:69 +-----BEGIN CERTIFICATE----- +MIIDvDCCAqSgAwIBAgIQB1YipOjUiolN9BPI8PjqpTANBgkqhkiG9w0BAQUFADBK +MQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3QgQ29ycG9yYXRpb24x +GTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwHhcNMDYxMTA3MTk0MjI4WhcNMjkx +MjMxMTk1MjA2WjBKMQswCQYDVQQGEwJVUzEgMB4GA1UEChMXU2VjdXJlVHJ1c3Qg +Q29ycG9yYXRpb24xGTAXBgNVBAMTEFNlY3VyZSBHbG9iYWwgQ0EwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvNS7YrGxVaQZx5RNoJLNP2MwhR/jxYDiJ +iQPpvepeRlMJ3Fz1Wuj3RSoC6zFh1ykzTM7HfAo3fg+6MpjhHZevj8fcyTiW89sa +/FHtaMbQbqR8JNGuQsiWUGMu4P51/pinX0kuleM5M2SOHqRfkNJnPLLZ/kG5VacJ +jnIFHovdRIWCQtBJwB1g8NEXLJXr9qXBkqPFwqcIYA1gBBCWeZ4WNOaptvolRTnI +HmX5k/Wq8VLcmZg9pYYaDDUz+kulBAYVHDGA76oYa8J719rO+TMg1fW9ajMtgQT7 +sFzUnKPiXB3jqUJ1XnvUd+85VLrJChgbEplJL4hL/VBi0XPnj3pDAgMBAAGjgZ0w +gZowEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0PBAQDAgGGMA8GA1UdEwEB/wQF +MAMBAf8wHQYDVR0OBBYEFK9EBMJBfkiD2045AuzshHrmzsmkMDQGA1UdHwQtMCsw +KaAnoCWGI2h0dHA6Ly9jcmwuc2VjdXJldHJ1c3QuY29tL1NHQ0EuY3JsMBAGCSsG +AQQBgjcVAQQDAgEAMA0GCSqGSIb3DQEBBQUAA4IBAQBjGghAfaReUw132HquHw0L +URYD7xh8yOOvaliTFGCRsoTciE6+OYo68+aCiV0BN7OrJKQVDpI1WkpEXk5X+nXO +H0jOZvQ8QCaSmGwb7iRGDBezUqXbpZGRzzfTb+cnCDpOGR86p1hcF895P4vkp9Mm +I50mD1hp/Ed+stCNi5O/KU9DaXR2Z0vPB4zmAve14bRDtUstFJ/53CYNv6ZHdAbY +iNE6KTCEztI5gGIbqMdXSbxqVVFnFUq+NQfk1XWYN3kwFNspnWzFacxHVaIw98xc +f8LDmBxrThaA63p4ZUWiABqvDA1VZDRIuJK58bRQKfJPIx/abKwfROHdI3hRW8cW +-----END CERTIFICATE----- + +# Issuer: CN=COMODO Certification Authority O=COMODO CA Limited +# Subject: CN=COMODO Certification Authority O=COMODO CA Limited +# Label: "COMODO Certification Authority" +# Serial: 104350513648249232941998508985834464573 +# MD5 Fingerprint: 5c:48:dc:f7:42:72:ec:56:94:6d:1c:cc:71:35:80:75 +# SHA1 Fingerprint: 66:31:bf:9e:f7:4f:9e:b6:c9:d5:a6:0c:ba:6a:be:d1:f7:bd:ef:7b +# SHA256 Fingerprint: 0c:2c:d6:3d:f7:80:6f:a3:99:ed:e8:09:11:6b:57:5b:f8:79:89:f0:65:18:f9:80:8c:86:05:03:17:8b:af:66 +-----BEGIN CERTIFICATE----- +MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB +gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV +BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw +MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl +YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P +RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0 +aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3 +UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI +2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8 +Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp ++2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+ +DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O +nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW +/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g +PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u +QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY +SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv +IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/ +RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4 +zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd +BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB +ZQ== +-----END CERTIFICATE----- + +# Issuer: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C. +# Subject: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C. +# Label: "Network Solutions Certificate Authority" +# Serial: 116697915152937497490437556386812487904 +# MD5 Fingerprint: d3:f3:a6:16:c0:fa:6b:1d:59:b1:2d:96:4d:0e:11:2e +# SHA1 Fingerprint: 74:f8:a3:c3:ef:e7:b3:90:06:4b:83:90:3c:21:64:60:20:e5:df:ce +# SHA256 Fingerprint: 15:f0:ba:00:a3:ac:7a:f3:ac:88:4c:07:2b:10:11:a0:77:bd:77:c0:97:f4:01:64:b2:f8:59:8a:bd:83:86:0c +-----BEGIN CERTIFICATE----- +MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi +MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu +MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp +dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV +UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO +ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG +SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz +c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP +OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl +mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF +BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4 +qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw +gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB +BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu +bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp +dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8 +6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/ +h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH +/nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv +wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN +pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey +-----END CERTIFICATE----- + +# Issuer: CN=COMODO ECC Certification Authority O=COMODO CA Limited +# Subject: CN=COMODO ECC Certification Authority O=COMODO CA Limited +# Label: "COMODO ECC Certification Authority" +# Serial: 41578283867086692638256921589707938090 +# MD5 Fingerprint: 7c:62:ff:74:9d:31:53:5e:68:4a:d5:78:aa:1e:bf:23 +# SHA1 Fingerprint: 9f:74:4e:9f:2b:4d:ba:ec:0f:31:2c:50:b6:56:3b:8e:2d:93:c3:11 +# SHA256 Fingerprint: 17:93:92:7a:06:14:54:97:89:ad:ce:2f:8f:34:f7:f0:b6:6d:0f:3a:e3:a3:b8:4d:21:ec:15:db:ba:4f:ad:c7 +-----BEGIN CERTIFICATE----- +MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL +MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE +BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT +IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw +MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy +ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N +T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv +biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR +FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J +cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW +BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ +BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm +fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv +GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY= +-----END CERTIFICATE----- + +# Issuer: CN=OISTE WISeKey Global Root GA CA O=WISeKey OU=Copyright (c) 2005/OISTE Foundation Endorsed +# Subject: CN=OISTE WISeKey Global Root GA CA O=WISeKey OU=Copyright (c) 2005/OISTE Foundation Endorsed +# Label: "OISTE WISeKey Global Root GA CA" +# Serial: 86718877871133159090080555911823548314 +# MD5 Fingerprint: bc:6c:51:33:a7:e9:d3:66:63:54:15:72:1b:21:92:93 +# SHA1 Fingerprint: 59:22:a1:e1:5a:ea:16:35:21:f8:98:39:6a:46:46:b0:44:1b:0f:a9 +# SHA256 Fingerprint: 41:c9:23:86:6a:b4:ca:d6:b7:ad:57:80:81:58:2e:02:07:97:a6:cb:df:4f:ff:78:ce:83:96:b3:89:37:d7:f5 +-----BEGIN CERTIFICATE----- +MIID8TCCAtmgAwIBAgIQQT1yx/RrH4FDffHSKFTfmjANBgkqhkiG9w0BAQUFADCB +ijELMAkGA1UEBhMCQ0gxEDAOBgNVBAoTB1dJU2VLZXkxGzAZBgNVBAsTEkNvcHly +aWdodCAoYykgMjAwNTEiMCAGA1UECxMZT0lTVEUgRm91bmRhdGlvbiBFbmRvcnNl +ZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwgUm9vdCBHQSBDQTAeFw0w +NTEyMTExNjAzNDRaFw0zNzEyMTExNjA5NTFaMIGKMQswCQYDVQQGEwJDSDEQMA4G +A1UEChMHV0lTZUtleTEbMBkGA1UECxMSQ29weXJpZ2h0IChjKSAyMDA1MSIwIAYD +VQQLExlPSVNURSBGb3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBX +SVNlS2V5IEdsb2JhbCBSb290IEdBIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAy0+zAJs9Nt350UlqaxBJH+zYK7LG+DKBKUOVTJoZIyEVRd7jyBxR +VVuuk+g3/ytr6dTqvirdqFEr12bDYVxgAsj1znJ7O7jyTmUIms2kahnBAbtzptf2 +w93NvKSLtZlhuAGio9RN1AU9ka34tAhxZK9w8RxrfvbDd50kc3vkDIzh2TbhmYsF +mQvtRTEJysIA2/dyoJaqlYfQjse2YXMNdmaM3Bu0Y6Kff5MTMPGhJ9vZ/yxViJGg +4E8HsChWjBgbl0SOid3gF27nKu+POQoxhILYQBRJLnpB5Kf+42TMwVlxSywhp1t9 +4B3RLoGbw9ho972WG6xwsRYUC9tguSYBBQIDAQABo1EwTzALBgNVHQ8EBAMCAYYw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUswN+rja8sHnR3JQmthG+IbJphpQw +EAYJKwYBBAGCNxUBBAMCAQAwDQYJKoZIhvcNAQEFBQADggEBAEuh/wuHbrP5wUOx +SPMowB0uyQlB+pQAHKSkq0lPjz0e701vvbyk9vImMMkQyh2I+3QZH4VFvbBsUfk2 +ftv1TDI6QU9bR8/oCy22xBmddMVHxjtqD6wU2zz0c5ypBd8A3HR4+vg1YFkCExh8 +vPtNsCBtQ7tgMHpnM1zFmdH4LTlSc/uMqpclXHLZCB6rTjzjgTGfA6b7wP4piFXa +hNVQA7bihKOmNqoROgHhGEvWRGizPflTdISzRpFGlgC3gCy24eMQ4tui5yiPAZZi +Fj4A4xylNoEYokxSdsARo27mHbrjWr42U8U+dY+GaSlYU7Wcu2+fXMUY7N0v4ZjJ +/L7fCg0= +-----END CERTIFICATE----- + +# Issuer: CN=Certigna O=Dhimyotis +# Subject: CN=Certigna O=Dhimyotis +# Label: "Certigna" +# Serial: 18364802974209362175 +# MD5 Fingerprint: ab:57:a6:5b:7d:42:82:19:b5:d8:58:26:28:5e:fd:ff +# SHA1 Fingerprint: b1:2e:13:63:45:86:a4:6f:1a:b2:60:68:37:58:2d:c4:ac:fd:94:97 +# SHA256 Fingerprint: e3:b6:a2:db:2e:d7:ce:48:84:2f:7a:c5:32:41:c7:b7:1d:54:14:4b:fb:40:c1:1f:3f:1d:0b:42:f5:ee:a1:2d +-----BEGIN CERTIFICATE----- +MIIDqDCCApCgAwIBAgIJAP7c4wEPyUj/MA0GCSqGSIb3DQEBBQUAMDQxCzAJBgNV +BAYTAkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hMB4X +DTA3MDYyOTE1MTMwNVoXDTI3MDYyOTE1MTMwNVowNDELMAkGA1UEBhMCRlIxEjAQ +BgNVBAoMCURoaW15b3RpczERMA8GA1UEAwwIQ2VydGlnbmEwggEiMA0GCSqGSIb3 +DQEBAQUAA4IBDwAwggEKAoIBAQDIaPHJ1tazNHUmgh7stL7qXOEm7RFHYeGifBZ4 +QCHkYJ5ayGPhxLGWkv8YbWkj4Sti993iNi+RB7lIzw7sebYs5zRLcAglozyHGxny +gQcPOJAZ0xH+hrTy0V4eHpbNgGzOOzGTtvKg0KmVEn2lmsxryIRWijOp5yIVUxbw +zBfsV1/pogqYCd7jX5xv3EjjhQsVWqa6n6xI4wmy9/Qy3l40vhx4XUJbzg4ij02Q +130yGLMLLGq/jj8UEYkgDncUtT2UCIf3JR7VsmAA7G8qKCVuKj4YYxclPz5EIBb2 +JsglrgVKtOdjLPOMFlN+XPsRGgjBRmKfIrjxwo1p3Po6WAbfAgMBAAGjgbwwgbkw +DwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUGu3+QTmQtCRZvgHyUtVF9lo53BEw +ZAYDVR0jBF0wW4AUGu3+QTmQtCRZvgHyUtVF9lo53BGhOKQ2MDQxCzAJBgNVBAYT +AkZSMRIwEAYDVQQKDAlEaGlteW90aXMxETAPBgNVBAMMCENlcnRpZ25hggkA/tzj +AQ/JSP8wDgYDVR0PAQH/BAQDAgEGMBEGCWCGSAGG+EIBAQQEAwIABzANBgkqhkiG +9w0BAQUFAAOCAQEAhQMeknH2Qq/ho2Ge6/PAD/Kl1NqV5ta+aDY9fm4fTIrv0Q8h +bV6lUmPOEvjvKtpv6zf+EwLHyzs+ImvaYS5/1HI93TDhHkxAGYwP15zRgzB7mFnc +fca5DClMoTOi62c6ZYTTluLtdkVwj7Ur3vkj1kluPBS1xp81HlDQwY9qcEQCYsuu +HWhBp6pX6FOqB9IG9tUUBguRA3UsbHK1YZWaDYu5Def131TN3ubY1gkIl2PlwS6w +t0QmwCbAr1UwnjvVNioZBPRcHv/PLLf/0P2HQBHVESO7SMAhqaQoLf0V+LBOK/Qw +WyH8EZE0vkHve52Xdf+XlcCWWC/qu0bXu+TZLg== +-----END CERTIFICATE----- + +# Issuer: CN=Deutsche Telekom Root CA 2 O=Deutsche Telekom AG OU=T-TeleSec Trust Center +# Subject: CN=Deutsche Telekom Root CA 2 O=Deutsche Telekom AG OU=T-TeleSec Trust Center +# Label: "Deutsche Telekom Root CA 2" +# Serial: 38 +# MD5 Fingerprint: 74:01:4a:91:b1:08:c4:58:ce:47:cd:f0:dd:11:53:08 +# SHA1 Fingerprint: 85:a4:08:c0:9c:19:3e:5d:51:58:7d:cd:d6:13:30:fd:8c:de:37:bf +# SHA256 Fingerprint: b6:19:1a:50:d0:c3:97:7f:7d:a9:9b:cd:aa:c8:6a:22:7d:ae:b9:67:9e:c7:0b:a3:b0:c9:d9:22:71:c1:70:d3 +-----BEGIN CERTIFICATE----- +MIIDnzCCAoegAwIBAgIBJjANBgkqhkiG9w0BAQUFADBxMQswCQYDVQQGEwJERTEc +MBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxlU2Vj +IFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290IENB +IDIwHhcNOTkwNzA5MTIxMTAwWhcNMTkwNzA5MjM1OTAwWjBxMQswCQYDVQQGEwJE +RTEcMBoGA1UEChMTRGV1dHNjaGUgVGVsZWtvbSBBRzEfMB0GA1UECxMWVC1UZWxl +U2VjIFRydXN0IENlbnRlcjEjMCEGA1UEAxMaRGV1dHNjaGUgVGVsZWtvbSBSb290 +IENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCrC6M14IspFLEU +ha88EOQ5bzVdSq7d6mGNlUn0b2SjGmBmpKlAIoTZ1KXleJMOaAGtuU1cOs7TuKhC +QN/Po7qCWWqSG6wcmtoIKyUn+WkjR/Hg6yx6m/UTAtB+NHzCnjwAWav12gz1Mjwr +rFDa1sPeg5TKqAyZMg4ISFZbavva4VhYAUlfckE8FQYBjl2tqriTtM2e66foai1S +NNs671x1Udrb8zH57nGYMsRUFUQM+ZtV7a3fGAigo4aKSe5TBY8ZTNXeWHmb0moc +QqvF1afPaA+W5OFhmHZhyJF81j4A4pFQh+GdCuatl9Idxjp9y7zaAzTVjlsB9WoH +txa2bkp/AgMBAAGjQjBAMB0GA1UdDgQWBBQxw3kbuvVT1xfgiXotF2wKsyudMzAP +BgNVHRMECDAGAQH/AgEFMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQUFAAOC +AQEAlGRZrTlk5ynrE/5aw4sTV8gEJPB0d8Bg42f76Ymmg7+Wgnxu1MM9756Abrsp +tJh6sTtU6zkXR34ajgv8HzFZMQSyzhfzLMdiNlXiItiJVbSYSKpk+tYcNthEeFpa +IzpXl/V6ME+un2pMSyuOoAPjPuCp1NJ70rOo4nI8rZ7/gFnkm0W09juwzTkZmDLl +6iFhkOQxIY40sfcvNUqFENrnijchvllj4PKFiDFT1FQUhXB59C4Gdyd1Lx+4ivn+ +xbrYNuSD7Odlt79jWvNGr4GUN9RBjNYj1h7P9WgbRGOiWrqnNVmh5XAFmw4jV5mU +Cm26OWMohpLzGITY+9HPBVZkVw== +-----END CERTIFICATE----- + +# Issuer: CN=Cybertrust Global Root O=Cybertrust, Inc +# Subject: CN=Cybertrust Global Root O=Cybertrust, Inc +# Label: "Cybertrust Global Root" +# Serial: 4835703278459682877484360 +# MD5 Fingerprint: 72:e4:4a:87:e3:69:40:80:77:ea:bc:e3:f4:ff:f0:e1 +# SHA1 Fingerprint: 5f:43:e5:b1:bf:f8:78:8c:ac:1c:c7:ca:4a:9a:c6:22:2b:cc:34:c6 +# SHA256 Fingerprint: 96:0a:df:00:63:e9:63:56:75:0c:29:65:dd:0a:08:67:da:0b:9c:bd:6e:77:71:4a:ea:fb:23:49:ab:39:3d:a3 +-----BEGIN CERTIFICATE----- +MIIDoTCCAomgAwIBAgILBAAAAAABD4WqLUgwDQYJKoZIhvcNAQEFBQAwOzEYMBYG +A1UEChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2Jh +bCBSb290MB4XDTA2MTIxNTA4MDAwMFoXDTIxMTIxNTA4MDAwMFowOzEYMBYGA1UE +ChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2JhbCBS +b290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+Mi8vRRQZhP/8NN5 +7CPytxrHjoXxEnOmGaoQ25yiZXRadz5RfVb23CO21O1fWLE3TdVJDm71aofW0ozS +J8bi/zafmGWgE07GKmSb1ZASzxQG9Dvj1Ci+6A74q05IlG2OlTEQXO2iLb3VOm2y +HLtgwEZLAfVJrn5GitB0jaEMAs7u/OePuGtm839EAL9mJRQr3RAwHQeWP032a7iP +t3sMpTjr3kfb1V05/Iin89cqdPHoWqI7n1C6poxFNcJQZZXcY4Lv3b93TZxiyWNz +FtApD0mpSPCzqrdsxacwOUBdrsTiXSZT8M4cIwhhqJQZugRiQOwfOHB3EgZxpzAY +XSUnpQIDAQABo4GlMIGiMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/ +MB0GA1UdDgQWBBS2CHsNesysIEyGVjJez6tuhS1wVzA/BgNVHR8EODA2MDSgMqAw +hi5odHRwOi8vd3d3Mi5wdWJsaWMtdHJ1c3QuY29tL2NybC9jdC9jdHJvb3QuY3Js +MB8GA1UdIwQYMBaAFLYIew16zKwgTIZWMl7Pq26FLXBXMA0GCSqGSIb3DQEBBQUA +A4IBAQBW7wojoFROlZfJ+InaRcHUowAl9B8Tq7ejhVhpwjCt2BWKLePJzYFa+HMj +Wqd8BfP9IjsO0QbE2zZMcwSO5bAi5MXzLqXZI+O4Tkogp24CJJ8iYGd7ix1yCcUx +XOl5n4BHPa2hCwcUPUf/A2kaDAtE52Mlp3+yybh2hO0j9n0Hq0V+09+zv+mKts2o +omcrUtW3ZfA5TGOgkXmTUg9U3YO7n9GPp1Nzw8v/MOx8BLjYRB+TX3EJIrduPuoc +A06dGiBh+4E37F78CkWr1+cXVdCg6mCbpvbjjFspwgZgFJ0tl0ypkxWdYcQBX0jW +WL1WMRJOEcgh4LMRkWXbtKaIOM5V +-----END CERTIFICATE----- + +# Issuer: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority +# Subject: O=Chunghwa Telecom Co., Ltd. OU=ePKI Root Certification Authority +# Label: "ePKI Root Certification Authority" +# Serial: 28956088682735189655030529057352760477 +# MD5 Fingerprint: 1b:2e:00:ca:26:06:90:3d:ad:fe:6f:15:68:d3:6b:b3 +# SHA1 Fingerprint: 67:65:0d:f1:7e:8e:7e:5b:82:40:a4:f4:56:4b:cf:e2:3d:69:c6:f0 +# SHA256 Fingerprint: c0:a6:f4:dc:63:a2:4b:fd:cf:54:ef:2a:6a:08:2a:0a:72:de:35:80:3e:2f:f5:ff:52:7a:e5:d8:72:06:df:d5 +-----BEGIN CERTIFICATE----- +MIIFsDCCA5igAwIBAgIQFci9ZUdcr7iXAF7kBtK8nTANBgkqhkiG9w0BAQUFADBe +MQswCQYDVQQGEwJUVzEjMCEGA1UECgwaQ2h1bmdod2EgVGVsZWNvbSBDby4sIEx0 +ZC4xKjAoBgNVBAsMIWVQS0kgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe +Fw0wNDEyMjAwMjMxMjdaFw0zNDEyMjAwMjMxMjdaMF4xCzAJBgNVBAYTAlRXMSMw +IQYDVQQKDBpDaHVuZ2h3YSBUZWxlY29tIENvLiwgTHRkLjEqMCgGA1UECwwhZVBL +SSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIICIjANBgkqhkiG9w0BAQEF +AAOCAg8AMIICCgKCAgEA4SUP7o3biDN1Z82tH306Tm2d0y8U82N0ywEhajfqhFAH +SyZbCUNsIZ5qyNUD9WBpj8zwIuQf5/dqIjG3LBXy4P4AakP/h2XGtRrBp0xtInAh +ijHyl3SJCRImHJ7K2RKilTza6We/CKBk49ZCt0Xvl/T29de1ShUCWH2YWEtgvM3X +DZoTM1PRYfl61dd4s5oz9wCGzh1NlDivqOx4UXCKXBCDUSH3ET00hl7lSM2XgYI1 +TBnsZfZrxQWh7kcT1rMhJ5QQCtkkO7q+RBNGMD+XPNjX12ruOzjjK9SXDrkb5wdJ +fzcq+Xd4z1TtW0ado4AOkUPB1ltfFLqfpo0kR0BZv3I4sjZsN/+Z0V0OWQqraffA +sgRFelQArr5T9rXn4fg8ozHSqf4hUmTFpmfwdQcGlBSBVcYn5AGPF8Fqcde+S/uU +WH1+ETOxQvdibBjWzwloPn9s9h6PYq2lY9sJpx8iQkEeb5mKPtf5P0B6ebClAZLS +nT0IFaUQAS2zMnaolQ2zepr7BxB4EW/hj8e6DyUadCrlHJhBmd8hh+iVBmoKs2pH +dmX2Os+PYhcZewoozRrSgx4hxyy/vv9haLdnG7t4TY3OZ+XkwY63I2binZB1NJip +NiuKmpS5nezMirH4JYlcWrYvjB9teSSnUmjDhDXiZo1jDiVN1Rmy5nk3pyKdVDEC +AwEAAaNqMGgwHQYDVR0OBBYEFB4M97Zn8uGSJglFwFU5Lnc/QkqiMAwGA1UdEwQF +MAMBAf8wOQYEZyoHAAQxMC8wLQIBADAJBgUrDgMCGgUAMAcGBWcqAwAABBRFsMLH +ClZ87lt4DJX5GFPBphzYEDANBgkqhkiG9w0BAQUFAAOCAgEACbODU1kBPpVJufGB +uvl2ICO1J2B01GqZNF5sAFPZn/KmsSQHRGoqxqWOeBLoR9lYGxMqXnmbnwoqZ6Yl +PwZpVnPDimZI+ymBV3QGypzqKOg4ZyYr8dW1P2WT+DZdjo2NQCCHGervJ8A9tDkP +JXtoUHRVnAxZfVo9QZQlUgjgRywVMRnVvwdVxrsStZf0X4OFunHB2WyBEXYKCrC/ +gpf36j36+uwtqSiUO1bd0lEursC9CBWMd1I0ltabrNMdjmEPNXubrjlpC2JgQCA2 +j6/7Nu4tCEoduL+bXPjqpRugc6bY+G7gMwRfaKonh+3ZwZCc7b3jajWvY9+rGNm6 +5ulK6lCKD2GTHuItGeIwlDWSXQ62B68ZgI9HkFFLLk3dheLSClIKF5r8GrBQAuUB +o2M3IUxExJtRmREOc5wGj1QupyheRDmHVi03vYVElOEMSyycw5KFNGHLD7ibSkNS +/jQ6fbjpKdx2qcgw+BRxgMYeNkh0IkFch4LoGHGLQYlE535YW6i4jRPpp2zDR+2z +Gp1iro2C6pSe3VkQw63d4k3jMdXH7OjysP6SHhYKGvzZ8/gntsm+HbRsZJB/9OTE +W9c3rkIO3aQab3yIVMUWbuF6aC74Or8NpDyJO3inTmODBCEIZ43ygknQW/2xzQ+D +hNQ+IIX3Sj0rnP0qCglN6oH4EZw= +-----END CERTIFICATE----- + +# Issuer: O=certSIGN OU=certSIGN ROOT CA +# Subject: O=certSIGN OU=certSIGN ROOT CA +# Label: "certSIGN ROOT CA" +# Serial: 35210227249154 +# MD5 Fingerprint: 18:98:c0:d6:e9:3a:fc:f9:b0:f5:0c:f7:4b:01:44:17 +# SHA1 Fingerprint: fa:b7:ee:36:97:26:62:fb:2d:b0:2a:f6:bf:03:fd:e8:7c:4b:2f:9b +# SHA256 Fingerprint: ea:a9:62:c4:fa:4a:6b:af:eb:e4:15:19:6d:35:1c:cd:88:8d:4f:53:f3:fa:8a:e6:d7:c4:66:a9:4e:60:42:bb +-----BEGIN CERTIFICATE----- +MIIDODCCAiCgAwIBAgIGIAYFFnACMA0GCSqGSIb3DQEBBQUAMDsxCzAJBgNVBAYT +AlJPMREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBD +QTAeFw0wNjA3MDQxNzIwMDRaFw0zMTA3MDQxNzIwMDRaMDsxCzAJBgNVBAYTAlJP +MREwDwYDVQQKEwhjZXJ0U0lHTjEZMBcGA1UECxMQY2VydFNJR04gUk9PVCBDQTCC +ASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALczuX7IJUqOtdu0KBuqV5Do +0SLTZLrTk+jUrIZhQGpgV2hUhE28alQCBf/fm5oqrl0Hj0rDKH/v+yv6efHHrfAQ +UySQi2bJqIirr1qjAOm+ukbuW3N7LBeCgV5iLKECZbO9xSsAfsT8AzNXDe3i+s5d +RdY4zTW2ssHQnIFKquSyAVwdj1+ZxLGt24gh65AIgoDzMKND5pCCrlUoSe1b16kQ +OA7+j0xbm0bqQfWwCHTD0IgztnzXdN/chNFDDnU5oSVAKOp4yw4sLjmdjItuFhwv +JoIQ4uNllAoEwF73XVv4EOLQunpL+943AAAaWyjj0pxzPjKHmKHJUS/X3qwzs08C +AwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAcYwHQYDVR0O +BBYEFOCMm9slSbPxfIbWskKHC9BroNnkMA0GCSqGSIb3DQEBBQUAA4IBAQA+0hyJ +LjX8+HXd5n9liPRyTMks1zJO890ZeUe9jjtbkw9QSSQTaxQGcu8J06Gh40CEyecY +MnQ8SG4Pn0vU9x7Tk4ZkVJdjclDVVc/6IJMCopvDI5NOFlV2oHB5bc0hH88vLbwZ +44gx+FkagQnIl6Z0x2DEW8xXjrJ1/RsCCdtZb3KTafcxQdaIOL+Hsr0Wefmq5L6I +Jd1hJyMctTEHBDa0GpC9oHRxUIltvBTjD4au8as+x6AJzKNI0eDbZOeStc+vckNw +i/nDhDwTqn6Sm1dTk/pwwpEOMfmbZ13pljheX7NzTogVZ96edhBiIL5VaZVDADlN +9u6wWk5JRFRYX0KD +-----END CERTIFICATE----- + +# Issuer: CN=GeoTrust Primary Certification Authority - G3 O=GeoTrust Inc. OU=(c) 2008 GeoTrust Inc. - For authorized use only +# Subject: CN=GeoTrust Primary Certification Authority - G3 O=GeoTrust Inc. OU=(c) 2008 GeoTrust Inc. - For authorized use only +# Label: "GeoTrust Primary Certification Authority - G3" +# Serial: 28809105769928564313984085209975885599 +# MD5 Fingerprint: b5:e8:34:36:c9:10:44:58:48:70:6d:2e:83:d4:b8:05 +# SHA1 Fingerprint: 03:9e:ed:b8:0b:e7:a0:3c:69:53:89:3b:20:d2:d9:32:3a:4c:2a:fd +# SHA256 Fingerprint: b4:78:b8:12:25:0d:f8:78:63:5c:2a:a7:ec:7d:15:5e:aa:62:5e:e8:29:16:e2:cd:29:43:61:88:6c:d1:fb:d4 +-----BEGIN CERTIFICATE----- +MIID/jCCAuagAwIBAgIQFaxulBmyeUtB9iepwxgPHzANBgkqhkiG9w0BAQsFADCB +mDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsT +MChjKSAyMDA4IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s +eTE2MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhv +cml0eSAtIEczMB4XDTA4MDQwMjAwMDAwMFoXDTM3MTIwMTIzNTk1OVowgZgxCzAJ +BgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykg +MjAwOCBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0 +BgNVBAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg +LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANziXmJYHTNXOTIz ++uvLh4yn1ErdBojqZI4xmKU4kB6Yzy5jK/BGvESyiaHAKAxJcCGVn2TAppMSAmUm +hsalifD614SgcK9PGpc/BkTVyetyEH3kMSj7HGHmKAdEc5IiaacDiGydY8hS2pgn +5whMcD60yRLBxWeDXTPzAxHsatBT4tG6NmCUgLthY2xbF37fQJQeqw3CIShwiP/W +JmxsYAQlTlV+fe+/lEjetx3dcI0FX4ilm/LC7urRQEFtYjgdVgbFA0dRIBn8exAL +DmKudlW/X3e+PkkBUz2YJQN2JFodtNuJ6nnltrM7P7pMKEF/BqxqjsHQ9gUdfeZC +huOl1UcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw +HQYDVR0OBBYEFMR5yo6hTgMdHNxr2zFblD4/MH8tMA0GCSqGSIb3DQEBCwUAA4IB +AQAtxRPPVoB7eni9n64smefv2t+UXglpp+duaIy9cr5HqQ6XErhK8WTTOd8lNNTB +zU6B8A8ExCSzNJbGpqow32hhc9f5joWJ7w5elShKKiePEI4ufIbEAp7aDHdlDkQN +kv39sxY2+hENHYwOB4lqKVb3cvTdFZx3NWZXqxNT2I7BQMXXExZacse3aQHEerGD +AWh9jUGhlBjBJVz88P6DAod8DQ3PLghcSkANPuyBYeYk28rgDi0Hsj5W3I31QYUH +SJsMC8tJP33st/3LjWeJGqvtux6jAAgIFyqCXDFdRootD4abdNlF+9RAsXqqaC2G +spki4cErx5z481+oghLrGREt +-----END CERTIFICATE----- + +# Issuer: CN=thawte Primary Root CA - G2 O=thawte, Inc. OU=(c) 2007 thawte, Inc. - For authorized use only +# Subject: CN=thawte Primary Root CA - G2 O=thawte, Inc. OU=(c) 2007 thawte, Inc. - For authorized use only +# Label: "thawte Primary Root CA - G2" +# Serial: 71758320672825410020661621085256472406 +# MD5 Fingerprint: 74:9d:ea:60:24:c4:fd:22:53:3e:cc:3a:72:d9:29:4f +# SHA1 Fingerprint: aa:db:bc:22:23:8f:c4:01:a1:27:bb:38:dd:f4:1d:db:08:9e:f0:12 +# SHA256 Fingerprint: a4:31:0d:50:af:18:a6:44:71:90:37:2a:86:af:af:8b:95:1f:fb:43:1d:83:7f:1e:56:88:b4:59:71:ed:15:57 +-----BEGIN CERTIFICATE----- +MIICiDCCAg2gAwIBAgIQNfwmXNmET8k9Jj1Xm67XVjAKBggqhkjOPQQDAzCBhDEL +MAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjE4MDYGA1UECxMvKGMp +IDIwMDcgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAi +BgNVBAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMjAeFw0wNzExMDUwMDAw +MDBaFw0zODAxMTgyMzU5NTlaMIGEMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhh +d3RlLCBJbmMuMTgwNgYDVQQLEy8oYykgMjAwNyB0aGF3dGUsIEluYy4gLSBGb3Ig +YXV0aG9yaXplZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9v +dCBDQSAtIEcyMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEotWcgnuVnfFSeIf+iha/ +BebfowJPDQfGAFG6DAJSLSKkQjnE/o/qycG+1E3/n3qe4rF8mq2nhglzh9HnmuN6 +papu+7qzcMBniKI11KOasf2twu8x+qi58/sIxpHR+ymVo0IwQDAPBgNVHRMBAf8E +BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUmtgAMADna3+FGO6Lts6K +DPgR4bswCgYIKoZIzj0EAwMDaQAwZgIxAN344FdHW6fmCsO99YCKlzUNG4k8VIZ3 +KMqh9HneteY4sPBlcIx/AlTCv//YoT7ZzwIxAMSNlPzcU9LcnXgWHxUzI1NS41ox +XZ3Krr0TKUQNJ1uo52icEvdYPy5yAlejj6EULg== +-----END CERTIFICATE----- + +# Issuer: CN=thawte Primary Root CA - G3 O=thawte, Inc. OU=Certification Services Division/(c) 2008 thawte, Inc. - For authorized use only +# Subject: CN=thawte Primary Root CA - G3 O=thawte, Inc. OU=Certification Services Division/(c) 2008 thawte, Inc. - For authorized use only +# Label: "thawte Primary Root CA - G3" +# Serial: 127614157056681299805556476275995414779 +# MD5 Fingerprint: fb:1b:5d:43:8a:94:cd:44:c6:76:f2:43:4b:47:e7:31 +# SHA1 Fingerprint: f1:8b:53:8d:1b:e9:03:b6:a6:f0:56:43:5b:17:15:89:ca:f3:6b:f2 +# SHA256 Fingerprint: 4b:03:f4:58:07:ad:70:f2:1b:fc:2c:ae:71:c9:fd:e4:60:4c:06:4c:f5:ff:b6:86:ba:e5:db:aa:d7:fd:d3:4c +-----BEGIN CERTIFICATE----- +MIIEKjCCAxKgAwIBAgIQYAGXt0an6rS0mtZLL/eQ+zANBgkqhkiG9w0BAQsFADCB +rjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf +Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw +MDggdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAiBgNV +BAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMzAeFw0wODA0MDIwMDAwMDBa +Fw0zNzEyMDEyMzU5NTlaMIGuMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3Rl +LCBJbmMuMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9u +MTgwNgYDVQQLEy8oYykgMjAwOCB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXpl +ZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9vdCBDQSAtIEcz +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsr8nLPvb2FvdeHsbnndm +gcs+vHyu86YnmjSjaDFxODNi5PNxZnmxqWWjpYvVj2AtP0LMqmsywCPLLEHd5N/8 +YZzic7IilRFDGF/Eth9XbAoFWCLINkw6fKXRz4aviKdEAhN0cXMKQlkC+BsUa0Lf +b1+6a4KinVvnSr0eAXLbS3ToO39/fR8EtCab4LRarEc9VbjXsCZSKAExQGbY2SS9 +9irY7CFJXJv2eul/VTV+lmuNk5Mny5K76qxAwJ/C+IDPXfRa3M50hqY+bAtTyr2S +zhkGcuYMXDhpxwTWvGzOW/b3aJzcJRVIiKHpqfiYnODz1TEoYRFsZ5aNOZnLwkUk +OQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNV +HQ4EFgQUrWyqlGCc7eT/+j4KdCtjA/e2Wb8wDQYJKoZIhvcNAQELBQADggEBABpA +2JVlrAmSicY59BDlqQ5mU1143vokkbvnRFHfxhY0Cu9qRFHqKweKA3rD6z8KLFIW +oCtDuSWQP3CpMyVtRRooOyfPqsMpQhvfO0zAMzRbQYi/aytlryjvsvXDqmbOe1bu +t8jLZ8HJnBoYuMTDSQPxYA5QzUbF83d597YV4Djbxy8ooAw/dyZ02SUS2jHaGh7c +KUGRIjxpp7sC8rZcJwOJ9Abqm+RyguOhCcHpABnTPtRwa7pxpqpYrvS76Wy274fM +m7v/OeZWYdMKp8RcTGB7BXcmer/YB1IsYvdwY9k5vG8cwnncdimvzsUsZAReiDZu +MdRAGmI0Nj81Aa6sY6A= +-----END CERTIFICATE----- + +# Issuer: CN=GeoTrust Primary Certification Authority - G2 O=GeoTrust Inc. OU=(c) 2007 GeoTrust Inc. - For authorized use only +# Subject: CN=GeoTrust Primary Certification Authority - G2 O=GeoTrust Inc. OU=(c) 2007 GeoTrust Inc. - For authorized use only +# Label: "GeoTrust Primary Certification Authority - G2" +# Serial: 80682863203381065782177908751794619243 +# MD5 Fingerprint: 01:5e:d8:6b:bd:6f:3d:8e:a1:31:f8:12:e0:98:73:6a +# SHA1 Fingerprint: 8d:17:84:d5:37:f3:03:7d:ec:70:fe:57:8b:51:9a:99:e6:10:d7:b0 +# SHA256 Fingerprint: 5e:db:7a:c4:3b:82:a0:6a:87:61:e8:d7:be:49:79:eb:f2:61:1f:7d:d7:9b:f9:1c:1c:6b:56:6a:21:9e:d7:66 +-----BEGIN CERTIFICATE----- +MIICrjCCAjWgAwIBAgIQPLL0SAoA4v7rJDteYD7DazAKBggqhkjOPQQDAzCBmDEL +MAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsTMChj +KSAyMDA3IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTE2 +MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0 +eSAtIEcyMB4XDTA3MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVowgZgxCzAJBgNV +BAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykgMjAw +NyBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNV +BAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH +MjB2MBAGByqGSM49AgEGBSuBBAAiA2IABBWx6P0DFUPlrOuHNxFi79KDNlJ9RVcL +So17VDs6bl8VAsBQps8lL33KSLjHUGMcKiEIfJo22Av+0SbFWDEwKCXzXV2juLal +tJLtbCyf691DiaI8S0iRHVDsJt/WYC69IaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBVfNVdRVfslsq0DafwBo/q+EVXVMAoG +CCqGSM49BAMDA2cAMGQCMGSWWaboCd6LuvpaiIjwH5HTRqjySkwCY/tsXzjbLkGT +qQ7mndwxHLKgpxgceeHHNgIwOlavmnRs9vuD4DPTCF+hnMJbn0bWtsuRBmOiBucz +rD6ogRLQy7rQkgu2npaqBA+K +-----END CERTIFICATE----- + +# Issuer: CN=VeriSign Universal Root Certification Authority O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2008 VeriSign, Inc. - For authorized use only +# Subject: CN=VeriSign Universal Root Certification Authority O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2008 VeriSign, Inc. - For authorized use only +# Label: "VeriSign Universal Root Certification Authority" +# Serial: 85209574734084581917763752644031726877 +# MD5 Fingerprint: 8e:ad:b5:01:aa:4d:81:e4:8c:1d:d1:e1:14:00:95:19 +# SHA1 Fingerprint: 36:79:ca:35:66:87:72:30:4d:30:a5:fb:87:3b:0f:a7:7b:b7:0d:54 +# SHA256 Fingerprint: 23:99:56:11:27:a5:71:25:de:8c:ef:ea:61:0d:df:2f:a0:78:b5:c8:06:7f:4e:82:82:90:bf:b8:60:e8:4b:3c +-----BEGIN CERTIFICATE----- +MIIEuTCCA6GgAwIBAgIQQBrEZCGzEyEDDrvkEhrFHTANBgkqhkiG9w0BAQsFADCB +vTELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL +ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwOCBWZXJp +U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MTgwNgYDVQQDEy9W +ZXJpU2lnbiBVbml2ZXJzYWwgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe +Fw0wODA0MDIwMDAwMDBaFw0zNzEyMDEyMzU5NTlaMIG9MQswCQYDVQQGEwJVUzEX +MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0 +IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWduLCBJbmMuIC0gRm9y +IGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVuaXZlcnNh +bCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEF +AAOCAQ8AMIIBCgKCAQEAx2E3XrEBNNti1xWb/1hajCMj1mCOkdeQmIN65lgZOIzF +9uVkhbSicfvtvbnazU0AtMgtc6XHaXGVHzk8skQHnOgO+k1KxCHfKWGPMiJhgsWH +H26MfF8WIFFE0XBPV+rjHOPMee5Y2A7Cs0WTwCznmhcrewA3ekEzeOEz4vMQGn+H +LL729fdC4uW/h2KJXwBL38Xd5HVEMkE6HnFuacsLdUYI0crSK5XQz/u5QGtkjFdN +/BMReYTtXlT2NJ8IAfMQJQYXStrxHXpma5hgZqTZ79IugvHw7wnqRMkVauIDbjPT +rJ9VAMf2CGqUuV/c4DPxhGD5WycRtPwW8rtWaoAljQIDAQABo4GyMIGvMA8GA1Ud +EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMG0GCCsGAQUFBwEMBGEwX6FdoFsw +WTBXMFUWCWltYWdlL2dpZjAhMB8wBwYFKw4DAhoEFI/l0xqGrI2Oa8PPgGrUSBgs +exkuMCUWI2h0dHA6Ly9sb2dvLnZlcmlzaWduLmNvbS92c2xvZ28uZ2lmMB0GA1Ud +DgQWBBS2d/ppSEefUxLVwuoHMnYH0ZcHGTANBgkqhkiG9w0BAQsFAAOCAQEASvj4 +sAPmLGd75JR3Y8xuTPl9Dg3cyLk1uXBPY/ok+myDjEedO2Pzmvl2MpWRsXe8rJq+ +seQxIcaBlVZaDrHC1LGmWazxY8u4TB1ZkErvkBYoH1quEPuBUDgMbMzxPcP1Y+Oz +4yHJJDnp/RVmRvQbEdBNc6N9Rvk97ahfYtTxP/jgdFcrGJ2BtMQo2pSXpXDrrB2+ +BxHw1dvd5Yzw1TKwg+ZX4o+/vqGqvz0dtdQ46tewXDpPaj+PwGZsY6rp2aQW9IHR +lRQOfc2VNNnSj3BzgXucfr2YYdhFh5iQxeuGMMY1v/D/w1WIg0vvBZIGcfK4mJO3 +7M2CYfE45k+XmCpajQ== +-----END CERTIFICATE----- + +# Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G4 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2007 VeriSign, Inc. - For authorized use only +# Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G4 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2007 VeriSign, Inc. - For authorized use only +# Label: "VeriSign Class 3 Public Primary Certification Authority - G4" +# Serial: 63143484348153506665311985501458640051 +# MD5 Fingerprint: 3a:52:e1:e7:fd:6f:3a:e3:6f:f3:6f:99:1b:f9:22:41 +# SHA1 Fingerprint: 22:d5:d8:df:8f:02:31:d1:8d:f7:9d:b7:cf:8a:2d:64:c9:3f:6c:3a +# SHA256 Fingerprint: 69:dd:d7:ea:90:bb:57:c9:3e:13:5d:c8:5e:a6:fc:d5:48:0b:60:32:39:bd:c4:54:fc:75:8b:2a:26:cf:7f:79 +-----BEGIN CERTIFICATE----- +MIIDhDCCAwqgAwIBAgIQL4D+I4wOIg9IZxIokYesszAKBggqhkjOPQQDAzCByjEL +MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW +ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2ln +biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp +U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y +aXR5IC0gRzQwHhcNMDcxMTA1MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCByjELMAkG +A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZWZXJp +U2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2lnbiwg +SW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2ln +biBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5 +IC0gRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASnVnp8Utpkmw4tXNherJI9/gHm +GUo9FANL+mAnINmDiWn6VMaaGF5VKmTeBvaNSjutEDxlPZCIBIngMGGzrl0Bp3ve +fLK+ymVhAIau2o970ImtTR1ZmkGxvEeA3J5iw/mjgbIwga8wDwYDVR0TAQH/BAUw +AwEB/zAOBgNVHQ8BAf8EBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJ +aW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYj +aHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFLMW +kf3upm7ktS5Jj4d4gYDs5bG1MAoGCCqGSM49BAMDA2gAMGUCMGYhDBgmYFo4e1ZC +4Kf8NoRRkSAsdk1DPcQdhCPQrNZ8NQbOzWm9kA3bbEhCHQ6qQgIxAJw9SDkjOVga +FRJZap7v1VmyHVIsmXHNxynfGyphe3HR3vPA5Q06Sqotp9iGKt0uEA== +-----END CERTIFICATE----- + +# Issuer: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services) +# Subject: CN=NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny O=NetLock Kft. OU=Tan\xfas\xedtv\xe1nykiad\xf3k (Certification Services) +# Label: "NetLock Arany (Class Gold) F\u0151tan\xfas\xedtv\xe1ny" +# Serial: 80544274841616 +# MD5 Fingerprint: c5:a1:b7:ff:73:dd:d6:d7:34:32:18:df:fc:3c:ad:88 +# SHA1 Fingerprint: 06:08:3f:59:3f:15:a1:04:a0:69:a4:6b:a9:03:d0:06:b7:97:09:91 +# SHA256 Fingerprint: 6c:61:da:c3:a2:de:f0:31:50:6b:e0:36:d2:a6:fe:40:19:94:fb:d1:3d:f9:c8:d4:66:59:92:74:c4:46:ec:98 +-----BEGIN CERTIFICATE----- +MIIEFTCCAv2gAwIBAgIGSUEs5AAQMA0GCSqGSIb3DQEBCwUAMIGnMQswCQYDVQQG +EwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFTATBgNVBAoMDE5ldExvY2sgS2Z0LjE3 +MDUGA1UECwwuVGFuw7pzw610dsOhbnlraWFkw7NrIChDZXJ0aWZpY2F0aW9uIFNl +cnZpY2VzKTE1MDMGA1UEAwwsTmV0TG9jayBBcmFueSAoQ2xhc3MgR29sZCkgRsWR +dGFuw7pzw610dsOhbnkwHhcNMDgxMjExMTUwODIxWhcNMjgxMjA2MTUwODIxWjCB +pzELMAkGA1UEBhMCSFUxETAPBgNVBAcMCEJ1ZGFwZXN0MRUwEwYDVQQKDAxOZXRM +b2NrIEtmdC4xNzA1BgNVBAsMLlRhbsO6c8OtdHbDoW55a2lhZMOzayAoQ2VydGlm +aWNhdGlvbiBTZXJ2aWNlcykxNTAzBgNVBAMMLE5ldExvY2sgQXJhbnkgKENsYXNz +IEdvbGQpIEbFkXRhbsO6c8OtdHbDoW55MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A +MIIBCgKCAQEAxCRec75LbRTDofTjl5Bu0jBFHjzuZ9lk4BqKf8owyoPjIMHj9DrT +lF8afFttvzBPhCf2nx9JvMaZCpDyD/V/Q4Q3Y1GLeqVw/HpYzY6b7cNGbIRwXdrz +AZAj/E4wqX7hJ2Pn7WQ8oLjJM2P+FpD/sLj916jAwJRDC7bVWaaeVtAkH3B5r9s5 +VA1lddkVQZQBr17s9o3x/61k/iCa11zr/qYfCGSji3ZVrR47KGAuhyXoqq8fxmRG +ILdwfzzeSNuWU7c5d+Qa4scWhHaXWy+7GRWF+GmF9ZmnqfI0p6m2pgP8b4Y9VHx2 +BJtr+UBdADTHLpl1neWIA6pN+APSQnbAGwIDAKiLo0UwQzASBgNVHRMBAf8ECDAG +AQH/AgEEMA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUzPpnk/C2uNClwB7zU/2M +U9+D15YwDQYJKoZIhvcNAQELBQADggEBAKt/7hwWqZw8UQCgwBEIBaeZ5m8BiFRh +bvG5GK1Krf6BQCOUL/t1fC8oS2IkgYIL9WHxHG64YTjrgfpioTtaYtOUZcTh5m2C ++C8lcLIhJsFyUR+MLMOEkMNaj7rP9KdlpeuY0fsFskZ1FSNqb4VjMIDw1Z4fKRzC +bLBQWV2QWzuoDTDPv31/zvGdg73JRm4gpvlhUbohL3u+pRVjodSVh/GeufOJ8z2F +uLjbvrW5KfnaNwUASZQDhETnv0Mxz3WLJdH0pmT1kvarBes96aULNmLazAZfNou2 +XjG4Kvte9nHfRCaexOYNkbQudZWAUWpLMKawYqGT8ZvYzsRjdT9ZR7E= +-----END CERTIFICATE----- + +# Issuer: CN=Staat der Nederlanden Root CA - G2 O=Staat der Nederlanden +# Subject: CN=Staat der Nederlanden Root CA - G2 O=Staat der Nederlanden +# Label: "Staat der Nederlanden Root CA - G2" +# Serial: 10000012 +# MD5 Fingerprint: 7c:a5:0f:f8:5b:9a:7d:6d:30:ae:54:5a:e3:42:a2:8a +# SHA1 Fingerprint: 59:af:82:79:91:86:c7:b4:75:07:cb:cf:03:57:46:eb:04:dd:b7:16 +# SHA256 Fingerprint: 66:8c:83:94:7d:a6:3b:72:4b:ec:e1:74:3c:31:a0:e6:ae:d0:db:8e:c5:b3:1b:e3:77:bb:78:4f:91:b6:71:6f +-----BEGIN CERTIFICATE----- +MIIFyjCCA7KgAwIBAgIEAJiWjDANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEcyMB4XDTA4MDMyNjExMTgxN1oX +DTIwMDMyNTExMDMxMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl +ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv +b3QgQ0EgLSBHMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMVZ5291 +qj5LnLW4rJ4L5PnZyqtdj7U5EILXr1HgO+EASGrP2uEGQxGZqhQlEq0i6ABtQ8Sp +uOUfiUtnvWFI7/3S4GCI5bkYYCjDdyutsDeqN95kWSpGV+RLufg3fNU254DBtvPU +Z5uW6M7XxgpT0GtJlvOjCwV3SPcl5XCsMBQgJeN/dVrlSPhOewMHBPqCYYdu8DvE +pMfQ9XQ+pV0aCPKbJdL2rAQmPlU6Yiile7Iwr/g3wtG61jj99O9JMDeZJiFIhQGp +5Rbn3JBV3w/oOM2ZNyFPXfUib2rFEhZgF1XyZWampzCROME4HYYEhLoaJXhena/M +UGDWE4dS7WMfbWV9whUYdMrhfmQpjHLYFhN9C0lK8SgbIHRrxT3dsKpICT0ugpTN +GmXZK4iambwYfp/ufWZ8Pr2UuIHOzZgweMFvZ9C+X+Bo7d7iscksWXiSqt8rYGPy +5V6548r6f1CGPqI0GAwJaCgRHOThuVw+R7oyPxjMW4T182t0xHJ04eOLoEq9jWYv +6q012iDTiIJh8BIitrzQ1aTsr1SIJSQ8p22xcik/Plemf1WvbibG/ufMQFxRRIEK +eN5KzlW/HdXZt1bv8Hb/C3m1r737qWmRRpdogBQ2HbN/uymYNqUg+oJgYjOk7Na6 +B6duxc8UpufWkjTYgfX8HV2qXB72o007uPc5AgMBAAGjgZcwgZQwDwYDVR0TAQH/ +BAUwAwEB/zBSBgNVHSAESzBJMEcGBFUdIAAwPzA9BggrBgEFBQcCARYxaHR0cDov +L3d3dy5wa2lvdmVyaGVpZC5ubC9wb2xpY2llcy9yb290LXBvbGljeS1HMjAOBgNV +HQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJFoMocVHYnitfGsNig0jQt8YojrMA0GCSqG +SIb3DQEBCwUAA4ICAQCoQUpnKpKBglBu4dfYszk78wIVCVBR7y29JHuIhjv5tLyS +CZa59sCrI2AGeYwRTlHSeYAz+51IvuxBQ4EffkdAHOV6CMqqi3WtFMTC6GY8ggen +5ieCWxjmD27ZUD6KQhgpxrRW/FYQoAUXvQwjf/ST7ZwaUb7dRUG/kSS0H4zpX897 +IZmflZ85OkYcbPnNe5yQzSipx6lVu6xiNGI1E0sUOlWDuYaNkqbG9AclVMwWVxJK +gnjIFNkXgiYtXSAfea7+1HAWFpWD2DU5/1JddRwWxRNVz0fMdWVSSt7wsKfkCpYL ++63C4iWEst3kvX5ZbJvw8NjnyvLplzh+ib7M+zkXYT9y2zqR2GUBGR2tUKRXCnxL +vJxxcypFURmFzI79R6d0lR2o0a9OF7FpJsKqeFdbxU2n5Z4FF5TKsl+gSRiNNOkm +bEgeqmiSBeGCc1qb3AdbCG19ndeNIdn8FCCqwkXfP+cAslHkwvgFuXkajDTznlvk +N1trSt8sV4pAWja63XVECDdCcAz+3F4hoKOKwJCcaNpQ5kUQR3i2TtJlycM33+FC +Y7BXN0Ute4qcvwXqZVUz9zkQxSgqIXobisQk+T8VyJoVIPVVYpbtbZNQvOSqeK3Z +ywplh6ZmwcSBo3c6WB4L7oOLnR7SUqTMHW+wmG2UMbX4cQrcufx9MmDm66+KAQ== +-----END CERTIFICATE----- + +# Issuer: CN=Hongkong Post Root CA 1 O=Hongkong Post +# Subject: CN=Hongkong Post Root CA 1 O=Hongkong Post +# Label: "Hongkong Post Root CA 1" +# Serial: 1000 +# MD5 Fingerprint: a8:0d:6f:39:78:b9:43:6d:77:42:6d:98:5a:cc:23:ca +# SHA1 Fingerprint: d6:da:a8:20:8d:09:d2:15:4d:24:b5:2f:cb:34:6e:b2:58:b2:8a:58 +# SHA256 Fingerprint: f9:e6:7d:33:6c:51:00:2a:c0:54:c6:32:02:2d:66:dd:a2:e7:e3:ff:f1:0a:d0:61:ed:31:d8:bb:b4:10:cf:b2 +-----BEGIN CERTIFICATE----- +MIIDMDCCAhigAwIBAgICA+gwDQYJKoZIhvcNAQEFBQAwRzELMAkGA1UEBhMCSEsx +FjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdrb25nIFBvc3Qg +Um9vdCBDQSAxMB4XDTAzMDUxNTA1MTMxNFoXDTIzMDUxNTA0NTIyOVowRzELMAkG +A1UEBhMCSEsxFjAUBgNVBAoTDUhvbmdrb25nIFBvc3QxIDAeBgNVBAMTF0hvbmdr +b25nIFBvc3QgUm9vdCBDQSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEArP84tulmAknjorThkPlAj3n54r15/gK97iSSHSL22oVyaf7XPwnU3ZG1ApzQ +jVrhVcNQhrkpJsLj2aDxaQMoIIBFIi1WpztUlVYiWR8o3x8gPW2iNr4joLFutbEn +PzlTCeqrauh0ssJlXI6/fMN4hM2eFvz1Lk8gKgifd/PFHsSaUmYeSF7jEAaPIpjh +ZY4bXSNmO7ilMlHIhqqhqZ5/dpTCpmy3QfDVyAY45tQM4vM7TG1QjMSDJ8EThFk9 +nnV0ttgCXjqQesBCNnLsak3c78QA3xMYV18meMjWCnl3v/evt3a5pQuEF10Q6m/h +q5URX208o1xNg1vysxmKgIsLhwIDAQABoyYwJDASBgNVHRMBAf8ECDAGAQH/AgED +MA4GA1UdDwEB/wQEAwIBxjANBgkqhkiG9w0BAQUFAAOCAQEADkbVPK7ih9legYsC +mEEIjEy82tvuJxuC52pF7BaLT4Wg87JwvVqWuspube5Gi27nKi6Wsxkz67SfqLI3 +7piol7Yutmcn1KZJ/RyTZXaeQi/cImyaT/JaFTmxcdcrUehtHJjA2Sr0oYJ71clB +oiMBdDhViw+5LmeiIAQ32pwL0xch4I+XeTRvhEgCIDMb5jREn5Fw9IBehEPCKdJs +EhTkYY2sEJCehFC78JZvRZ+K88psT/oROhUVRsPNH4NbLUES7VBnQRM9IauUiqpO +fMGx+6fWtScvl6tu4B3i0RwsH0Ti/L6RoZz71ilTc4afU9hDDl3WY4JxHYB0yvbi +AmvZWg== +-----END CERTIFICATE----- + +# Issuer: CN=SecureSign RootCA11 O=Japan Certification Services, Inc. +# Subject: CN=SecureSign RootCA11 O=Japan Certification Services, Inc. +# Label: "SecureSign RootCA11" +# Serial: 1 +# MD5 Fingerprint: b7:52:74:e2:92:b4:80:93:f2:75:e4:cc:d7:f2:ea:26 +# SHA1 Fingerprint: 3b:c4:9f:48:f8:f3:73:a0:9c:1e:bd:f8:5b:b1:c3:65:c7:d8:11:b3 +# SHA256 Fingerprint: bf:0f:ee:fb:9e:3a:58:1a:d5:f9:e9:db:75:89:98:57:43:d2:61:08:5c:4d:31:4f:6f:5d:72:59:aa:42:16:12 +-----BEGIN CERTIFICATE----- +MIIDbTCCAlWgAwIBAgIBATANBgkqhkiG9w0BAQUFADBYMQswCQYDVQQGEwJKUDEr +MCkGA1UEChMiSmFwYW4gQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcywgSW5jLjEcMBoG +A1UEAxMTU2VjdXJlU2lnbiBSb290Q0ExMTAeFw0wOTA0MDgwNDU2NDdaFw0yOTA0 +MDgwNDU2NDdaMFgxCzAJBgNVBAYTAkpQMSswKQYDVQQKEyJKYXBhbiBDZXJ0aWZp +Y2F0aW9uIFNlcnZpY2VzLCBJbmMuMRwwGgYDVQQDExNTZWN1cmVTaWduIFJvb3RD +QTExMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA/XeqpRyQBTvLTJsz +i1oURaTnkBbR31fSIRCkF/3frNYfp+TbfPfs37gD2pRY/V1yfIw/XwFndBWW4wI8 +h9uuywGOwvNmxoVF9ALGOrVisq/6nL+k5tSAMJjzDbaTj6nU2DbysPyKyiyhFTOV +MdrAG/LuYpmGYz+/3ZMqg6h2uRMft85OQoWPIucuGvKVCbIFtUROd6EgvanyTgp9 +UK31BQ1FT0Zx/Sg+U/sE2C3XZR1KG/rPO7AxmjVuyIsG0wCR8pQIZUyxNAYAeoni +8McDWc/V1uinMrPmmECGxc0nEovMe863ETxiYAcjPitAbpSACW22s293bzUIUPsC +h8U+iQIDAQABo0IwQDAdBgNVHQ4EFgQUW/hNT7KlhtQ60vFjmqC+CfZXt94wDgYD +VR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEFBQADggEB +AKChOBZmLqdWHyGcBvod7bkixTgm2E5P7KN/ed5GIaGHd48HCJqypMWvDzKYC3xm +KbabfSVSSUOrTC4rbnpwrxYO4wJs+0LmGJ1F2FXI6Dvd5+H0LgscNFxsWEr7jIhQ +X5Ucv+2rIrVls4W6ng+4reV6G4pQOh29Dbx7VFALuUKvVaAYga1lme++5Jy/xIWr +QbJUb9wlze144o4MjQlJ3WN7WmmWAiGovVJZ6X01y8hSyn+B/tlr0/cR7SXf+Of5 +pPpyl4RTDaXQMhhRdlkUbA/r7F+AjHVDg8OFmP9Mni0N5HeDk061lgeLKBObjBmN +QSdJQO7e5iNEOdyhIta6A/I= +-----END CERTIFICATE----- + +# Issuer: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd. +# Subject: CN=Microsec e-Szigno Root CA 2009 O=Microsec Ltd. +# Label: "Microsec e-Szigno Root CA 2009" +# Serial: 14014712776195784473 +# MD5 Fingerprint: f8:49:f4:03:bc:44:2d:83:be:48:69:7d:29:64:fc:b1 +# SHA1 Fingerprint: 89:df:74:fe:5c:f4:0f:4a:80:f9:e3:37:7d:54:da:91:e1:01:31:8e +# SHA256 Fingerprint: 3c:5f:81:fe:a5:fa:b8:2c:64:bf:a2:ea:ec:af:cd:e8:e0:77:fc:86:20:a7:ca:e5:37:16:3d:f3:6e:db:f3:78 +-----BEGIN CERTIFICATE----- +MIIECjCCAvKgAwIBAgIJAMJ+QwRORz8ZMA0GCSqGSIb3DQEBCwUAMIGCMQswCQYD +VQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3QxFjAUBgNVBAoMDU1pY3Jvc2VjIEx0 +ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3ppZ25vIFJvb3QgQ0EgMjAwOTEfMB0G +CSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5odTAeFw0wOTA2MTYxMTMwMThaFw0y +OTEyMzAxMTMwMThaMIGCMQswCQYDVQQGEwJIVTERMA8GA1UEBwwIQnVkYXBlc3Qx +FjAUBgNVBAoMDU1pY3Jvc2VjIEx0ZC4xJzAlBgNVBAMMHk1pY3Jvc2VjIGUtU3pp +Z25vIFJvb3QgQ0EgMjAwOTEfMB0GCSqGSIb3DQEJARYQaW5mb0BlLXN6aWduby5o +dTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAOn4j/NjrdqG2KfgQvvP +kd6mJviZpWNwrZuuyjNAfW2WbqEORO7hE52UQlKavXWFdCyoDh2Tthi3jCyoz/tc +cbna7P7ofo/kLx2yqHWH2Leh5TvPmUpG0IMZfcChEhyVbUr02MelTTMuhTlAdX4U +fIASmFDHQWe4oIBhVKZsTh/gnQ4H6cm6M+f+wFUoLAKApxn1ntxVUwOXewdI/5n7 +N4okxFnMUBBjjqqpGrCEGob5X7uxUG6k0QrM1XF+H6cbfPVTbiJfyyvm1HxdrtbC +xkzlBQHZ7Vf8wSN5/PrIJIOV87VqUQHQd9bpEqH5GoP7ghu5sJf0dgYzQ0mg/wu1 ++rUCAwEAAaOBgDB+MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0G +A1UdDgQWBBTLD8bfQkPMPcu1SCOhGnqmKrs0aDAfBgNVHSMEGDAWgBTLD8bfQkPM +Pcu1SCOhGnqmKrs0aDAbBgNVHREEFDASgRBpbmZvQGUtc3ppZ25vLmh1MA0GCSqG +SIb3DQEBCwUAA4IBAQDJ0Q5eLtXMs3w+y/w9/w0olZMEyL/azXm4Q5DwpL7v8u8h +mLzU1F0G9u5C7DBsoKqpyvGvivo/C3NqPuouQH4frlRheesuCDfXI/OMn74dseGk +ddug4lQUsbocKaQY9hK6ohQU4zE1yED/t+AFdlfBHFny+L/k7SViXITwfn4fs775 +tyERzAMBVnCnEJIeGzSBHq2cGsMEPO0CYdYeBvNfOofyK/FFh+U9rNHHV4S9a67c +2Pm2G2JwCz02yULyMtd6YebS2z3PyKnJm9zbWETXbzivf3jTo60adbocwTZ8jx5t +HMN1Rq41Bab2XD0h7lbwyYIiLXpUq3DDfSJlgnCW +-----END CERTIFICATE----- + +# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3 +# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3 +# Label: "GlobalSign Root CA - R3" +# Serial: 4835703278459759426209954 +# MD5 Fingerprint: c5:df:b8:49:ca:05:13:55:ee:2d:ba:1a:c3:3e:b0:28 +# SHA1 Fingerprint: d6:9b:56:11:48:f0:1c:77:c5:45:78:c1:09:26:df:5b:85:69:76:ad +# SHA256 Fingerprint: cb:b5:22:d7:b7:f1:27:ad:6a:01:13:86:5b:df:1c:d4:10:2e:7d:07:59:af:63:5a:7c:f4:72:0d:c9:63:c5:3b +-----BEGIN CERTIFICATE----- +MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G +A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp +Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4 +MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG +A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8 +RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT +gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm +KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd +QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ +XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw +DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o +LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU +RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp +jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK +6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX +mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs +Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH +WD9f +-----END CERTIFICATE----- + +# Issuer: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068 +# Subject: CN=Autoridad de Certificacion Firmaprofesional CIF A62634068 +# Label: "Autoridad de Certificacion Firmaprofesional CIF A62634068" +# Serial: 6047274297262753887 +# MD5 Fingerprint: 73:3a:74:7a:ec:bb:a3:96:a6:c2:e4:e2:c8:9b:c0:c3 +# SHA1 Fingerprint: ae:c5:fb:3f:c8:e1:bf:c4:e5:4f:03:07:5a:9a:e8:00:b7:f7:b6:fa +# SHA256 Fingerprint: 04:04:80:28:bf:1f:28:64:d4:8f:9a:d4:d8:32:94:36:6a:82:88:56:55:3f:3b:14:30:3f:90:14:7f:5d:40:ef +-----BEGIN CERTIFICATE----- +MIIGFDCCA/ygAwIBAgIIU+w77vuySF8wDQYJKoZIhvcNAQEFBQAwUTELMAkGA1UE +BhMCRVMxQjBABgNVBAMMOUF1dG9yaWRhZCBkZSBDZXJ0aWZpY2FjaW9uIEZpcm1h +cHJvZmVzaW9uYWwgQ0lGIEE2MjYzNDA2ODAeFw0wOTA1MjAwODM4MTVaFw0zMDEy +MzEwODM4MTVaMFExCzAJBgNVBAYTAkVTMUIwQAYDVQQDDDlBdXRvcmlkYWQgZGUg +Q2VydGlmaWNhY2lvbiBGaXJtYXByb2Zlc2lvbmFsIENJRiBBNjI2MzQwNjgwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDKlmuO6vj78aI14H9M2uDDUtd9 +thDIAl6zQyrET2qyyhxdKJp4ERppWVevtSBC5IsP5t9bpgOSL/UR5GLXMnE42QQM +cas9UX4PB99jBVzpv5RvwSmCwLTaUbDBPLutN0pcyvFLNg4kq7/DhHf9qFD0sefG +L9ItWY16Ck6WaVICqjaY7Pz6FIMMNx/Jkjd/14Et5cS54D40/mf0PmbR0/RAz15i +NA9wBj4gGFrO93IbJWyTdBSTo3OxDqqHECNZXyAFGUftaI6SEspd/NYrspI8IM/h +X68gvqB2f3bl7BqGYTM+53u0P6APjqK5am+5hyZvQWyIplD9amML9ZMWGxmPsu2b +m8mQ9QEM3xk9Dz44I8kvjwzRAv4bVdZO0I08r0+k8/6vKtMFnXkIoctXMbScyJCy +Z/QYFpM6/EfY0XiWMR+6KwxfXZmtY4laJCB22N/9q06mIqqdXuYnin1oKaPnirja +EbsXLZmdEyRG98Xi2J+Of8ePdG1asuhy9azuJBCtLxTa/y2aRnFHvkLfuwHb9H/T +KI8xWVvTyQKmtFLKbpf7Q8UIJm+K9Lv9nyiqDdVF8xM6HdjAeI9BZzwelGSuewvF +6NkBiDkal4ZkQdU7hwxu+g/GvUgUvzlN1J5Bto+WHWOWk9mVBngxaJ43BjuAiUVh +OSPHG0SjFeUc+JIwuwIDAQABo4HvMIHsMBIGA1UdEwEB/wQIMAYBAf8CAQEwDgYD +VR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRlzeurNR4APn7VdMActHNHDhpkLzCBpgYD +VR0gBIGeMIGbMIGYBgRVHSAAMIGPMC8GCCsGAQUFBwIBFiNodHRwOi8vd3d3LmZp +cm1hcHJvZmVzaW9uYWwuY29tL2NwczBcBggrBgEFBQcCAjBQHk4AUABhAHMAZQBv +ACAAZABlACAAbABhACAAQgBvAG4AYQBuAG8AdgBhACAANAA3ACAAQgBhAHIAYwBl +AGwAbwBuAGEAIAAwADgAMAAxADcwDQYJKoZIhvcNAQEFBQADggIBABd9oPm03cXF +661LJLWhAqvdpYhKsg9VSytXjDvlMd3+xDLx51tkljYyGOylMnfX40S2wBEqgLk9 +am58m9Ot/MPWo+ZkKXzR4Tgegiv/J2Wv+xYVxC5xhOW1//qkR71kMrv2JYSiJ0L1 +ILDCExARzRAVukKQKtJE4ZYm6zFIEv0q2skGz3QeqUvVhyj5eTSSPi5E6PaPT481 +PyWzOdxjKpBrIF/EUhJOlywqrJ2X3kjyo2bbwtKDlaZmp54lD+kLM5FlClrD2VQS +3a/DTg4fJl4N3LON7NWBcN7STyQF82xO9UxJZo3R/9ILJUFI/lGExkKvgATP0H5k +SeTy36LssUzAKh3ntLFlosS88Zj0qnAHY7S42jtM+kAiMFsRpvAFDsYCA0irhpuF +3dvd6qJ2gHN99ZwExEWN57kci57q13XRcrHedUTnQn3iV2t93Jm8PYMo6oCTjcVM +ZcFwgbg4/EMxsvYDNEeyrPsiBsse3RdHHF9mudMaotoRsaS8I8nkvof/uZS2+F0g +StRf571oe2XyFR7SOqkt6dhrJKyXWERHrVkY8SFlcN7ONGCoQPHzPKTDKCOM/icz +Q0CgFzzr6juwcqajuUpLXhZI9LK8yIySxZ2frHI2vDSANGupi5LAuBft7HZT9SQB +jLMi6Et8Vcad+qMUu2WFbm5PEn4KPJ2V +-----END CERTIFICATE----- + +# Issuer: CN=Izenpe.com O=IZENPE S.A. +# Subject: CN=Izenpe.com O=IZENPE S.A. +# Label: "Izenpe.com" +# Serial: 917563065490389241595536686991402621 +# MD5 Fingerprint: a6:b0:cd:85:80:da:5c:50:34:a3:39:90:2f:55:67:73 +# SHA1 Fingerprint: 2f:78:3d:25:52:18:a7:4a:65:39:71:b5:2c:a2:9c:45:15:6f:e9:19 +# SHA256 Fingerprint: 25:30:cc:8e:98:32:15:02:ba:d9:6f:9b:1f:ba:1b:09:9e:2d:29:9e:0f:45:48:bb:91:4f:36:3b:c0:d4:53:1f +-----BEGIN CERTIFICATE----- +MIIF8TCCA9mgAwIBAgIQALC3WhZIX7/hy/WL1xnmfTANBgkqhkiG9w0BAQsFADA4 +MQswCQYDVQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6 +ZW5wZS5jb20wHhcNMDcxMjEzMTMwODI4WhcNMzcxMjEzMDgyNzI1WjA4MQswCQYD +VQQGEwJFUzEUMBIGA1UECgwLSVpFTlBFIFMuQS4xEzARBgNVBAMMCkl6ZW5wZS5j +b20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDJ03rKDx6sp4boFmVq +scIbRTJxldn+EFvMr+eleQGPicPK8lVx93e+d5TzcqQsRNiekpsUOqHnJJAKClaO +xdgmlOHZSOEtPtoKct2jmRXagaKH9HtuJneJWK3W6wyyQXpzbm3benhB6QiIEn6H +LmYRY2xU+zydcsC8Lv/Ct90NduM61/e0aL6i9eOBbsFGb12N4E3GVFWJGjMxCrFX +uaOKmMPsOzTFlUFpfnXCPCDFYbpRR6AgkJOhkEvzTnyFRVSa0QUmQbC1TR0zvsQD +yCV8wXDbO/QJLVQnSKwv4cSsPsjLkkxTOTcj7NMB+eAJRE1NZMDhDVqHIrytG6P+ +JrUV86f8hBnp7KGItERphIPzidF0BqnMC9bC3ieFUCbKF7jJeodWLBoBHmy+E60Q +rLUk9TiRodZL2vG70t5HtfG8gfZZa88ZU+mNFctKy6lvROUbQc/hhqfK0GqfvEyN +BjNaooXlkDWgYlwWTvDjovoDGrQscbNYLN57C9saD+veIR8GdwYDsMnvmfzAuU8L +hij+0rnq49qlw0dpEuDb8PYZi+17cNcC1u2HGCgsBCRMd+RIihrGO5rUD8r6ddIB +QFqNeb+Lz0vPqhbBleStTIo+F5HUsWLlguWABKQDfo2/2n+iD5dPDNMN+9fR5XJ+ +HMh3/1uaD7euBUbl8agW7EekFwIDAQABo4H2MIHzMIGwBgNVHREEgagwgaWBD2lu +Zm9AaXplbnBlLmNvbaSBkTCBjjFHMEUGA1UECgw+SVpFTlBFIFMuQS4gLSBDSUYg +QTAxMzM3MjYwLVJNZXJjLlZpdG9yaWEtR2FzdGVpeiBUMTA1NSBGNjIgUzgxQzBB +BgNVBAkMOkF2ZGEgZGVsIE1lZGl0ZXJyYW5lbyBFdG9yYmlkZWEgMTQgLSAwMTAx +MCBWaXRvcmlhLUdhc3RlaXowDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC +AQYwHQYDVR0OBBYEFB0cZQ6o8iV7tJHP5LGx5r1VdGwFMA0GCSqGSIb3DQEBCwUA +A4ICAQB4pgwWSp9MiDrAyw6lFn2fuUhfGI8NYjb2zRlrrKvV9pF9rnHzP7MOeIWb +laQnIUdCSnxIOvVFfLMMjlF4rJUT3sb9fbgakEyrkgPH7UIBzg/YsfqikuFgba56 +awmqxinuaElnMIAkejEWOVt+8Rwu3WwJrfIxwYJOubv5vr8qhT/AQKM6WfxZSzwo +JNu0FXWuDYi6LnPAvViH5ULy617uHjAimcs30cQhbIHsvm0m5hzkQiCeR7Csg1lw +LDXWrzY0tM07+DKo7+N4ifuNRSzanLh+QBxh5z6ikixL8s36mLYp//Pye6kfLqCT +VyvehQP5aTfLnnhqBbTFMXiJ7HqnheG5ezzevh55hM6fcA5ZwjUukCox2eRFekGk +LhObNA5me0mrZJfQRsN5nXJQY6aYWwa9SG3YOYNw6DXwBdGqvOPbyALqfP2C2sJb +UjWumDqtujWTI6cfSN01RpiyEGjkpTHCClguGYEQyVB1/OpaFs4R1+7vUIgtYf8/ +QnMFlEPVjjxOAToZpR9GTnfQXeWBIiGH/pR9hNiTrdZoQ0iy2+tzJOeRf1SktoA+ +naM8THLCV8Sg1Mw4J87VBp6iSNnpn86CcDaTmjvfliHjWbcM2pE38P1ZWrOZyGls +QyYBNWNgVYkDOnXYukrZVP/u3oDYLdE41V4tC5h9Pmzb/CaIxw== +-----END CERTIFICATE----- + +# Issuer: CN=Chambers of Commerce Root - 2008 O=AC Camerfirma S.A. +# Subject: CN=Chambers of Commerce Root - 2008 O=AC Camerfirma S.A. +# Label: "Chambers of Commerce Root - 2008" +# Serial: 11806822484801597146 +# MD5 Fingerprint: 5e:80:9e:84:5a:0e:65:0b:17:02:f3:55:18:2a:3e:d7 +# SHA1 Fingerprint: 78:6a:74:ac:76:ab:14:7f:9c:6a:30:50:ba:9e:a8:7e:fe:9a:ce:3c +# SHA256 Fingerprint: 06:3e:4a:fa:c4:91:df:d3:32:f3:08:9b:85:42:e9:46:17:d8:93:d7:fe:94:4e:10:a7:93:7e:e2:9d:96:93:c0 +-----BEGIN CERTIFICATE----- +MIIHTzCCBTegAwIBAgIJAKPaQn6ksa7aMA0GCSqGSIb3DQEBBQUAMIGuMQswCQYD +VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 +IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 +MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xKTAnBgNVBAMTIENoYW1iZXJz +IG9mIENvbW1lcmNlIFJvb3QgLSAyMDA4MB4XDTA4MDgwMTEyMjk1MFoXDTM4MDcz +MTEyMjk1MFowga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpNYWRyaWQgKHNlZSBj +dXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29tL2FkZHJlc3MpMRIw +EAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVyZmlybWEgUy5BLjEp +MCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAtIDIwMDgwggIiMA0G +CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCvAMtwNyuAWko6bHiUfaN/Gh/2NdW9 +28sNRHI+JrKQUrpjOyhYb6WzbZSm891kDFX29ufyIiKAXuFixrYp4YFs8r/lfTJq +VKAyGVn+H4vXPWCGhSRv4xGzdz4gljUha7MI2XAuZPeEklPWDrCQiorjh40G072Q +DuKZoRuGDtqaCrsLYVAGUvGef3bsyw/QHg3PmTA9HMRFEFis1tPo1+XqxQEHd9ZR +5gN/ikilTWh1uem8nk4ZcfUyS5xtYBkL+8ydddy/Js2Pk3g5eXNeJQ7KXOt3EgfL +ZEFHcpOrUMPrCXZkNNI5t3YRCQ12RcSprj1qr7V9ZS+UWBDsXHyvfuK2GNnQm05a +Sd+pZgvMPMZ4fKecHePOjlO+Bd5gD2vlGts/4+EhySnB8esHnFIbAURRPHsl18Tl +UlRdJQfKFiC4reRB7noI/plvg6aRArBsNlVq5331lubKgdaX8ZSD6e2wsWsSaR6s ++12pxZjptFtYer49okQ6Y1nUCyXeG0+95QGezdIp1Z8XGQpvvwyQ0wlf2eOKNcx5 +Wk0ZN5K3xMGtr/R5JJqyAQuxr1yW84Ay+1w9mPGgP0revq+ULtlVmhduYJ1jbLhj +ya6BXBg14JC7vjxPNyK5fuvPnnchpj04gftI2jE9K+OJ9dC1vX7gUMQSibMjmhAx +hduub+84Mxh2EQIDAQABo4IBbDCCAWgwEgYDVR0TAQH/BAgwBgEB/wIBDDAdBgNV +HQ4EFgQU+SSsD7K1+HnA+mCIG8TZTQKeFxkwgeMGA1UdIwSB2zCB2IAU+SSsD7K1 ++HnA+mCIG8TZTQKeFxmhgbSkgbEwga4xCzAJBgNVBAYTAkVVMUMwQQYDVQQHEzpN +YWRyaWQgKHNlZSBjdXJyZW50IGFkZHJlc3MgYXQgd3d3LmNhbWVyZmlybWEuY29t +L2FkZHJlc3MpMRIwEAYDVQQFEwlBODI3NDMyODcxGzAZBgNVBAoTEkFDIENhbWVy +ZmlybWEgUy5BLjEpMCcGA1UEAxMgQ2hhbWJlcnMgb2YgQ29tbWVyY2UgUm9vdCAt +IDIwMDiCCQCj2kJ+pLGu2jAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRV +HSAAMCowKAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20w +DQYJKoZIhvcNAQEFBQADggIBAJASryI1wqM58C7e6bXpeHxIvj99RZJe6dqxGfwW +PJ+0W2aeaufDuV2I6A+tzyMP3iU6XsxPpcG1Lawk0lgH3qLPaYRgM+gQDROpI9CF +5Y57pp49chNyM/WqfcZjHwj0/gF/JM8rLFQJ3uIrbZLGOU8W6jx+ekbURWpGqOt1 +glanq6B8aBMz9p0w8G8nOSQjKpD9kCk18pPfNKXG9/jvjA9iSnyu0/VU+I22mlaH +FoI6M6taIgj3grrqLuBHmrS1RaMFO9ncLkVAO+rcf+g769HsJtg1pDDFOqxXnrN2 +pSB7+R5KBWIBpih1YJeSDW4+TTdDDZIVnBgizVGZoCkaPF+KMjNbMMeJL0eYD6MD +xvbxrN8y8NmBGuScvfaAFPDRLLmF9dijscilIeUcE5fuDr3fKanvNFNb0+RqE4QG +tjICxFKuItLcsiFCGtpA8CnJ7AoMXOLQusxI0zcKzBIKinmwPQN/aUv0NCB9szTq +jktk9T79syNnFQ0EuPAtwQlRPLJsFfClI9eDdOTlLsn+mCdCxqvGnrDQWzilm1De +fhiYtUU79nm06PcaewaD+9CL2rvHvRirCG88gGtAPxkZumWK5r7VXNM21+9AUiRg +OGcEMeyP84LG3rlV8zsxkVrctQgVrXYlCg17LofiDKYGvCYQbTed7N14jHyAxfDZ +d0jQ +-----END CERTIFICATE----- + +# Issuer: CN=Global Chambersign Root - 2008 O=AC Camerfirma S.A. +# Subject: CN=Global Chambersign Root - 2008 O=AC Camerfirma S.A. +# Label: "Global Chambersign Root - 2008" +# Serial: 14541511773111788494 +# MD5 Fingerprint: 9e:80:ff:78:01:0c:2e:c1:36:bd:fe:96:90:6e:08:f3 +# SHA1 Fingerprint: 4a:bd:ee:ec:95:0d:35:9c:89:ae:c7:52:a1:2c:5b:29:f6:d6:aa:0c +# SHA256 Fingerprint: 13:63:35:43:93:34:a7:69:80:16:a0:d3:24:de:72:28:4e:07:9d:7b:52:20:bb:8f:bd:74:78:16:ee:be:ba:ca +-----BEGIN CERTIFICATE----- +MIIHSTCCBTGgAwIBAgIJAMnN0+nVfSPOMA0GCSqGSIb3DQEBBQUAMIGsMQswCQYD +VQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3VycmVudCBhZGRyZXNzIGF0 +IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAGA1UEBRMJQTgyNzQzMjg3 +MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAlBgNVBAMTHkdsb2JhbCBD +aGFtYmVyc2lnbiBSb290IC0gMjAwODAeFw0wODA4MDExMjMxNDBaFw0zODA3MzEx +MjMxNDBaMIGsMQswCQYDVQQGEwJFVTFDMEEGA1UEBxM6TWFkcmlkIChzZWUgY3Vy +cmVudCBhZGRyZXNzIGF0IHd3dy5jYW1lcmZpcm1hLmNvbS9hZGRyZXNzKTESMBAG +A1UEBRMJQTgyNzQzMjg3MRswGQYDVQQKExJBQyBDYW1lcmZpcm1hIFMuQS4xJzAl +BgNVBAMTHkdsb2JhbCBDaGFtYmVyc2lnbiBSb290IC0gMjAwODCCAiIwDQYJKoZI +hvcNAQEBBQADggIPADCCAgoCggIBAMDfVtPkOpt2RbQT2//BthmLN0EYlVJH6xed +KYiONWwGMi5HYvNJBL99RDaxccy9Wglz1dmFRP+RVyXfXjaOcNFccUMd2drvXNL7 +G706tcuto8xEpw2uIRU/uXpbknXYpBI4iRmKt4DS4jJvVpyR1ogQC7N0ZJJ0YPP2 +zxhPYLIj0Mc7zmFLmY/CDNBAspjcDahOo7kKrmCgrUVSY7pmvWjg+b4aqIG7HkF4 +ddPB/gBVsIdU6CeQNR1MM62X/JcumIS/LMmjv9GYERTtY/jKmIhYF5ntRQOXfjyG +HoiMvvKRhI9lNNgATH23MRdaKXoKGCQwoze1eqkBfSbW+Q6OWfH9GzO1KTsXO0G2 +Id3UwD2ln58fQ1DJu7xsepeY7s2MH/ucUa6LcL0nn3HAa6x9kGbo1106DbDVwo3V +yJ2dwW3Q0L9R5OP4wzg2rtandeavhENdk5IMagfeOx2YItaswTXbo6Al/3K1dh3e +beksZixShNBFks4c5eUzHdwHU1SjqoI7mjcv3N2gZOnm3b2u/GSFHTynyQbehP9r +6GsaPMWis0L7iwk+XwhSx2LE1AVxv8Rk5Pihg+g+EpuoHtQ2TS9x9o0o9oOpE9Jh +wZG7SMA0j0GMS0zbaRL/UJScIINZc+18ofLx/d33SdNDWKBWY8o9PeU1VlnpDsog +zCtLkykPAgMBAAGjggFqMIIBZjASBgNVHRMBAf8ECDAGAQH/AgEMMB0GA1UdDgQW +BBS5CcqcHtvTbDprru1U8VuTBjUuXjCB4QYDVR0jBIHZMIHWgBS5CcqcHtvTbDpr +ru1U8VuTBjUuXqGBsqSBrzCBrDELMAkGA1UEBhMCRVUxQzBBBgNVBAcTOk1hZHJp +ZCAoc2VlIGN1cnJlbnQgYWRkcmVzcyBhdCB3d3cuY2FtZXJmaXJtYS5jb20vYWRk +cmVzcykxEjAQBgNVBAUTCUE4Mjc0MzI4NzEbMBkGA1UEChMSQUMgQ2FtZXJmaXJt +YSBTLkEuMScwJQYDVQQDEx5HbG9iYWwgQ2hhbWJlcnNpZ24gUm9vdCAtIDIwMDiC +CQDJzdPp1X0jzjAOBgNVHQ8BAf8EBAMCAQYwPQYDVR0gBDYwNDAyBgRVHSAAMCow +KAYIKwYBBQUHAgEWHGh0dHA6Ly9wb2xpY3kuY2FtZXJmaXJtYS5jb20wDQYJKoZI +hvcNAQEFBQADggIBAICIf3DekijZBZRG/5BXqfEv3xoNa/p8DhxJJHkn2EaqbylZ +UohwEurdPfWbU1Rv4WCiqAm57OtZfMY18dwY6fFn5a+6ReAJ3spED8IXDneRRXoz +X1+WLGiLwUePmJs9wOzL9dWCkoQ10b42OFZyMVtHLaoXpGNR6woBrX/sdZ7LoR/x +fxKxueRkf2fWIyr0uDldmOghp+G9PUIadJpwr2hsUF1Jz//7Dl3mLEfXgTpZALVz +a2Mg9jFFCDkO9HB+QHBaP9BrQql0PSgvAm11cpUJjUhjxsYjV5KTXjXBjfkK9yyd +Yhz2rXzdpjEetrHHfoUm+qRqtdpjMNHvkzeyZi99Bffnt0uYlDXA2TopwZ2yUDMd +SqlapskD7+3056huirRXhOukP9DuqqqHW2Pok+JrqNS4cnhrG+055F3Lm6qH1U9O +AP7Zap88MQ8oAgF9mOinsKJknnn4SPIVqczmyETrP3iZ8ntxPjzxmKfFGBI/5rso +M0LpRQp8bfKGeS/Fghl9CYl8slR2iK7ewfPM4W7bMdaTrpmg7yVqc5iJWzouE4ge +v8CSlDQb4ye3ix5vQv/n6TebUB0tovkC7stYWDpxvGjjqsGvHCgfotwjZT+B6q6Z +09gwzxMNTxXJhLynSC34MCN32EZLeW32jO06f2ARePTpm67VVMB0gNELQp/B +-----END CERTIFICATE----- + +# Issuer: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc. +# Subject: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc. +# Label: "Go Daddy Root Certificate Authority - G2" +# Serial: 0 +# MD5 Fingerprint: 80:3a:bc:22:c1:e6:fb:8d:9b:3b:27:4a:32:1b:9a:01 +# SHA1 Fingerprint: 47:be:ab:c9:22:ea:e8:0e:78:78:34:62:a7:9f:45:c2:54:fd:e6:8b +# SHA256 Fingerprint: 45:14:0b:32:47:eb:9c:c8:c5:b4:f0:d7:b5:30:91:f7:32:92:08:9e:6e:5a:63:e2:74:9d:d3:ac:a9:19:8e:da +-----BEGIN CERTIFICATE----- +MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT +EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp +ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz +NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH +EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE +AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw +DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD +E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH +/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy +DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh +GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR +tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA +AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE +FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX +WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu +9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr +gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo +2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO +LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI +4uJEvlz36hz1 +-----END CERTIFICATE----- + +# Issuer: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc. +# Subject: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc. +# Label: "Starfield Root Certificate Authority - G2" +# Serial: 0 +# MD5 Fingerprint: d6:39:81:c6:52:7e:96:69:fc:fc:ca:66:ed:05:f2:96 +# SHA1 Fingerprint: b5:1c:06:7c:ee:2b:0c:3d:f8:55:ab:2d:92:f4:fe:39:d4:e7:0f:0e +# SHA256 Fingerprint: 2c:e1:cb:0b:f9:d2:f9:e1:02:99:3f:be:21:51:52:c3:b2:dd:0c:ab:de:1c:68:e5:31:9b:83:91:54:db:b7:f5 +-----BEGIN CERTIFICATE----- +MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT +HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs +ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw +MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6 +b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj +aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp +Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC +ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg +nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1 +HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N +Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN +dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0 +HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO +BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G +CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU +sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3 +4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg +8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K +pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1 +mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0 +-----END CERTIFICATE----- + +# Issuer: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc. +# Subject: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc. +# Label: "Starfield Services Root Certificate Authority - G2" +# Serial: 0 +# MD5 Fingerprint: 17:35:74:af:7b:61:1c:eb:f4:f9:3c:e2:ee:40:f9:a2 +# SHA1 Fingerprint: 92:5a:8f:8d:2c:6d:04:e0:66:5f:59:6a:ff:22:d8:63:e8:25:6f:3f +# SHA256 Fingerprint: 56:8d:69:05:a2:c8:87:08:a4:b3:02:51:90:ed:cf:ed:b1:97:4a:60:6a:13:c6:e5:29:0f:cb:2a:e6:3e:da:b5 +-----BEGIN CERTIFICATE----- +MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx +EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT +HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs +ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5 +MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD +VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy +ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy +dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p +OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2 +8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K +Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe +hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk +6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw +DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q +AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI +bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB +ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z +qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd +iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn +0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN +sSi6 +-----END CERTIFICATE----- + +# Issuer: CN=AffirmTrust Commercial O=AffirmTrust +# Subject: CN=AffirmTrust Commercial O=AffirmTrust +# Label: "AffirmTrust Commercial" +# Serial: 8608355977964138876 +# MD5 Fingerprint: 82:92:ba:5b:ef:cd:8a:6f:a6:3d:55:f9:84:f6:d6:b7 +# SHA1 Fingerprint: f9:b5:b6:32:45:5f:9c:be:ec:57:5f:80:dc:e9:6e:2c:c7:b2:78:b7 +# SHA256 Fingerprint: 03:76:ab:1d:54:c5:f9:80:3c:e4:b2:e2:01:a0:ee:7e:ef:7b:57:b6:36:e8:a9:3c:9b:8d:48:60:c9:6f:5f:a7 +-----BEGIN CERTIFICATE----- +MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE +BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz +dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL +MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp +cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP +Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr +ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL +MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1 +yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr +VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/ +nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ +KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG +XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj +vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt +Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g +N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC +nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8= +-----END CERTIFICATE----- + +# Issuer: CN=AffirmTrust Networking O=AffirmTrust +# Subject: CN=AffirmTrust Networking O=AffirmTrust +# Label: "AffirmTrust Networking" +# Serial: 8957382827206547757 +# MD5 Fingerprint: 42:65:ca:be:01:9a:9a:4c:a9:8c:41:49:cd:c0:d5:7f +# SHA1 Fingerprint: 29:36:21:02:8b:20:ed:02:f5:66:c5:32:d1:d6:ed:90:9f:45:00:2f +# SHA256 Fingerprint: 0a:81:ec:5a:92:97:77:f1:45:90:4a:f3:8d:5d:50:9f:66:b5:e2:c5:8f:cd:b5:31:05:8b:0e:17:f3:f0:b4:1b +-----BEGIN CERTIFICATE----- +MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE +BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz +dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL +MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp +cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC +AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y +YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua +kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL +QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp +6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG +yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i +QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ +KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO +tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu +QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ +Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u +olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48 +x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s= +-----END CERTIFICATE----- + +# Issuer: CN=AffirmTrust Premium O=AffirmTrust +# Subject: CN=AffirmTrust Premium O=AffirmTrust +# Label: "AffirmTrust Premium" +# Serial: 7893706540734352110 +# MD5 Fingerprint: c4:5d:0e:48:b6:ac:28:30:4e:0a:bc:f9:38:16:87:57 +# SHA1 Fingerprint: d8:a6:33:2c:e0:03:6f:b1:85:f6:63:4f:7d:6a:06:65:26:32:28:27 +# SHA256 Fingerprint: 70:a7:3f:7f:37:6b:60:07:42:48:90:45:34:b1:14:82:d5:bf:0e:69:8e:cc:49:8d:f5:25:77:eb:f2:e9:3b:9a +-----BEGIN CERTIFICATE----- +MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE +BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz +dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG +A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U +cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf +qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ +JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ ++jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS +s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5 +HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7 +70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG +V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S +qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S +5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia +C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX +OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE +FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/ +BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2 +KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg +Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B +8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ +MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc +0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ +u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF +u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH +YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8 +GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO +RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e +KeC2uAloGRwYQw== +-----END CERTIFICATE----- + +# Issuer: CN=AffirmTrust Premium ECC O=AffirmTrust +# Subject: CN=AffirmTrust Premium ECC O=AffirmTrust +# Label: "AffirmTrust Premium ECC" +# Serial: 8401224907861490260 +# MD5 Fingerprint: 64:b0:09:55:cf:b1:d5:99:e2:be:13:ab:a6:5d:ea:4d +# SHA1 Fingerprint: b8:23:6b:00:2f:1d:16:86:53:01:55:6c:11:a4:37:ca:eb:ff:c3:bb +# SHA256 Fingerprint: bd:71:fd:f6:da:97:e4:cf:62:d1:64:7a:dd:25:81:b0:7d:79:ad:f8:39:7e:b4:ec:ba:9c:5e:84:88:82:14:23 +-----BEGIN CERTIFICATE----- +MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC +VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ +cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ +BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt +VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D +0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9 +ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G +A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G +A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs +aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I +flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ== +-----END CERTIFICATE----- + +# Issuer: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority +# Subject: CN=Certum Trusted Network CA O=Unizeto Technologies S.A. OU=Certum Certification Authority +# Label: "Certum Trusted Network CA" +# Serial: 279744 +# MD5 Fingerprint: d5:e9:81:40:c5:18:69:fc:46:2c:89:75:62:0f:aa:78 +# SHA1 Fingerprint: 07:e0:32:e0:20:b7:2c:3f:19:2f:06:28:a2:59:3a:19:a7:0f:06:9e +# SHA256 Fingerprint: 5c:58:46:8d:55:f5:8e:49:7e:74:39:82:d2:b5:00:10:b6:d1:65:37:4a:cf:83:a7:d4:a3:2d:b7:68:c4:40:8e +-----BEGIN CERTIFICATE----- +MIIDuzCCAqOgAwIBAgIDBETAMA0GCSqGSIb3DQEBBQUAMH4xCzAJBgNVBAYTAlBM +MSIwIAYDVQQKExlVbml6ZXRvIFRlY2hub2xvZ2llcyBTLkEuMScwJQYDVQQLEx5D +ZXJ0dW0gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkxIjAgBgNVBAMTGUNlcnR1bSBU +cnVzdGVkIE5ldHdvcmsgQ0EwHhcNMDgxMDIyMTIwNzM3WhcNMjkxMjMxMTIwNzM3 +WjB+MQswCQYDVQQGEwJQTDEiMCAGA1UEChMZVW5pemV0byBUZWNobm9sb2dpZXMg +Uy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MSIw +IAYDVQQDExlDZXJ0dW0gVHJ1c3RlZCBOZXR3b3JrIENBMIIBIjANBgkqhkiG9w0B +AQEFAAOCAQ8AMIIBCgKCAQEA4/t9o3K6wvDJFIf1awFO4W5AB7ptJ11/91sts1rH +UV+rpDKmYYe2bg+G0jACl/jXaVehGDldamR5xgFZrDwxSjh80gTSSyjoIF87B6LM +TXPb865Px1bVWqeWifrzq2jUI4ZZJ88JJ7ysbnKDHDBy3+Ci6dLhdHUZvSqeexVU +BBvXQzmtVSjF4hq79MDkrjhJM8x2hZ85RdKknvISjFH4fOQtf/WsX+sWn7Et0brM +kUJ3TCXJkDhv2/DM+44el1k+1WBO5gUo7Ul5E0u6SNsv+XLTOcr+H9g0cvW0QM8x +AcPs3hEtF10fuFDRXhmnad4HMyjKUJX5p1TLVIZQRan5SQIDAQABo0IwQDAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQIds3LB/8k9sXN7buQvOKEN0Z19zAOBgNV +HQ8BAf8EBAMCAQYwDQYJKoZIhvcNAQEFBQADggEBAKaorSLOAT2mo/9i0Eidi15y +sHhE49wcrwn9I0j6vSrEuVUEtRCjjSfeC4Jj0O7eDDd5QVsisrCaQVymcODU0HfL +I9MA4GxWL+FpDQ3Zqr8hgVDZBqWo/5U30Kr+4rP1mS1FhIrlQgnXdAIv94nYmem8 +J9RHjboNRhx3zxSkHLmkMcScKHQDNP8zGSal6Q10tz6XxnboJ5ajZt3hrvJBW8qY +VoNzcOSGGtIxQbovvi0TWnZvTuhOgQ4/WwMioBK+ZlgRSssDxLQqKi2WF+A5VLxI +03YnnZotBqbJ7DnSq9ufmgsnAjUpsUCV5/nonFWIGUbWtzT1fs45mtk48VH3Tyw= +-----END CERTIFICATE----- + +# Issuer: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA +# Subject: CN=TWCA Root Certification Authority O=TAIWAN-CA OU=Root CA +# Label: "TWCA Root Certification Authority" +# Serial: 1 +# MD5 Fingerprint: aa:08:8f:f6:f9:7b:b7:f2:b1:a7:1e:9b:ea:ea:bd:79 +# SHA1 Fingerprint: cf:9e:87:6d:d3:eb:fc:42:26:97:a3:b5:a3:7a:a0:76:a9:06:23:48 +# SHA256 Fingerprint: bf:d8:8f:e1:10:1c:41:ae:3e:80:1b:f8:be:56:35:0e:e9:ba:d1:a6:b9:bd:51:5e:dc:5c:6d:5b:87:11:ac:44 +-----BEGIN CERTIFICATE----- +MIIDezCCAmOgAwIBAgIBATANBgkqhkiG9w0BAQUFADBfMQswCQYDVQQGEwJUVzES +MBAGA1UECgwJVEFJV0FOLUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFU +V0NBIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwODI4MDcyNDMz +WhcNMzAxMjMxMTU1OTU5WjBfMQswCQYDVQQGEwJUVzESMBAGA1UECgwJVEFJV0FO +LUNBMRAwDgYDVQQLDAdSb290IENBMSowKAYDVQQDDCFUV0NBIFJvb3QgQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB +AQCwfnK4pAOU5qfeCTiRShFAh6d8WWQUe7UREN3+v9XAu1bihSX0NXIP+FPQQeFE +AcK0HMMxQhZHhTMidrIKbw/lJVBPhYa+v5guEGcevhEFhgWQxFnQfHgQsIBct+HH +K3XLfJ+utdGdIzdjp9xCoi2SBBtQwXu4PhvJVgSLL1KbralW6cH/ralYhzC2gfeX +RfwZVzsrb+RH9JlF/h3x+JejiB03HFyP4HYlmlD4oFT/RJB2I9IyxsOrBr/8+7/z +rX2SYgJbKdM1o5OaQ2RgXbL6Mv87BK9NQGr5x+PvI/1ry+UPizgN7gr8/g+YnzAx +3WxSZfmLgb4i4RxYA7qRG4kHAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqOFsmjd6LWvJPelSDGRjjCDWmujANBgkq +hkiG9w0BAQUFAAOCAQEAPNV3PdrfibqHDAhUaiBQkr6wQT25JmSDCi/oQMCXKCeC +MErJk/9q56YAf4lCmtYR5VPOL8zy2gXE/uJQxDqGfczafhAJO5I1KlOy/usrBdls +XebQ79NqZp4VKIV66IIArB6nCWlWQtNoURi+VJq/REG6Sb4gumlc7rh3zc5sH62D +lhh9DrUUOYTxKOkto557HnpyWoOzeW/vtPzQCqVYT0bf+215WfKEIlKuD8z7fDvn +aspHYcN6+NOSBB+4IIThNlQWx0DeO4pz3N/GCUzf7Nr/1FNCocnyYh0igzyXxfkZ +YiesZSLX0zzG5Y6yU8xJzrww/nsOM5D77dIUkR8Hrw== +-----END CERTIFICATE----- + +# Issuer: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2 +# Subject: O=SECOM Trust Systems CO.,LTD. OU=Security Communication RootCA2 +# Label: "Security Communication RootCA2" +# Serial: 0 +# MD5 Fingerprint: 6c:39:7d:a4:0e:55:59:b2:3f:d6:41:b1:12:50:de:43 +# SHA1 Fingerprint: 5f:3b:8c:f2:f8:10:b3:7d:78:b4:ce:ec:19:19:c3:73:34:b9:c7:74 +# SHA256 Fingerprint: 51:3b:2c:ec:b8:10:d4:cd:e5:dd:85:39:1a:df:c6:c2:dd:60:d8:7b:b7:36:d2:b5:21:48:4a:a4:7a:0e:be:f6 +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIBADANBgkqhkiG9w0BAQsFADBdMQswCQYDVQQGEwJKUDEl +MCMGA1UEChMcU0VDT00gVHJ1c3QgU3lzdGVtcyBDTy4sTFRELjEnMCUGA1UECxMe +U2VjdXJpdHkgQ29tbXVuaWNhdGlvbiBSb290Q0EyMB4XDTA5MDUyOTA1MDAzOVoX +DTI5MDUyOTA1MDAzOVowXTELMAkGA1UEBhMCSlAxJTAjBgNVBAoTHFNFQ09NIFRy +dXN0IFN5c3RlbXMgQ08uLExURC4xJzAlBgNVBAsTHlNlY3VyaXR5IENvbW11bmlj +YXRpb24gUm9vdENBMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANAV +OVKxUrO6xVmCxF1SrjpDZYBLx/KWvNs2l9amZIyoXvDjChz335c9S672XewhtUGr +zbl+dp+++T42NKA7wfYxEUV0kz1XgMX5iZnK5atq1LXaQZAQwdbWQonCv/Q4EpVM +VAX3NuRFg3sUZdbcDE3R3n4MqzvEFb46VqZab3ZpUql6ucjrappdUtAtCms1FgkQ +hNBqyjoGADdH5H5XTz+L62e4iKrFvlNVspHEfbmwhRkGeC7bYRr6hfVKkaHnFtWO +ojnflLhwHyg/i/xAXmODPIMqGplrz95Zajv8bxbXH/1KEOtOghY6rCcMU/Gt1SSw +awNQwS08Ft1ENCcadfsCAwEAAaNCMEAwHQYDVR0OBBYEFAqFqXdlBZh8QIH4D5cs +OPEK7DzPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3 +DQEBCwUAA4IBAQBMOqNErLlFsceTfsgLCkLfZOoc7llsCLqJX2rKSpWeeo8HxdpF +coJxDjrSzG+ntKEju/Ykn8sX/oymzsLS28yN/HH8AynBbF0zX2S2ZTuJbxh2ePXc +okgfGT+Ok+vx+hfuzU7jBBJV1uXk3fs+BXziHV7Gp7yXT2g69ekuCkO2r1dcYmh8 +t/2jioSgrGK+KwmHNPBqAbubKVY8/gA3zyNs8U6qtnRGEmyR7jTV7JqR50S+kDFy +1UkC9gLl9B/rfNmWVan/7Ir5mUf/NVoCqgTLiluHcSmRvaS0eg29mvVXIwAHIRc/ +SjnRBUkLp7Y3gaVdjKozXoEofKd9J+sAro03 +-----END CERTIFICATE----- + +# Issuer: CN=Hellenic Academic and Research Institutions RootCA 2011 O=Hellenic Academic and Research Institutions Cert. Authority +# Subject: CN=Hellenic Academic and Research Institutions RootCA 2011 O=Hellenic Academic and Research Institutions Cert. Authority +# Label: "Hellenic Academic and Research Institutions RootCA 2011" +# Serial: 0 +# MD5 Fingerprint: 73:9f:4c:4b:73:5b:79:e9:fa:ba:1c:ef:6e:cb:d5:c9 +# SHA1 Fingerprint: fe:45:65:9b:79:03:5b:98:a1:61:b5:51:2e:ac:da:58:09:48:22:4d +# SHA256 Fingerprint: bc:10:4f:15:a4:8b:e7:09:dc:a5:42:a7:e1:d4:b9:df:6f:05:45:27:e8:02:ea:a9:2d:59:54:44:25:8a:fe:71 +-----BEGIN CERTIFICATE----- +MIIEMTCCAxmgAwIBAgIBADANBgkqhkiG9w0BAQUFADCBlTELMAkGA1UEBhMCR1Ix +RDBCBgNVBAoTO0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1 +dGlvbnMgQ2VydC4gQXV0aG9yaXR5MUAwPgYDVQQDEzdIZWxsZW5pYyBBY2FkZW1p +YyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIFJvb3RDQSAyMDExMB4XDTExMTIw +NjEzNDk1MloXDTMxMTIwMTEzNDk1MlowgZUxCzAJBgNVBAYTAkdSMUQwQgYDVQQK +EztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0dXRpb25zIENl +cnQuIEF1dGhvcml0eTFAMD4GA1UEAxM3SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl +c2VhcmNoIEluc3RpdHV0aW9ucyBSb290Q0EgMjAxMTCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBAKlTAOMupvaO+mDYLZU++CwqVE7NuYRhlFhPjz2L5EPz +dYmNUeTDN9KKiE15HrcS3UN4SoqS5tdI1Q+kOilENbgH9mgdVc04UfCMJDGFr4PJ +fel3r+0ae50X+bOdOFAPplp5kYCvN66m0zH7tSYJnTxa71HFK9+WXesyHgLacEns +bgzImjeN9/E2YEsmLIKe0HjzDQ9jpFEw4fkrJxIH2Oq9GGKYsFk3fb7u8yBRQlqD +75O6aRXxYp2fmTmCobd0LovUxQt7L/DICto9eQqakxylKHJzkUOap9FNhYS5qXSP +FEDH3N6sQWRstBmbAmNtJGSPRLIl6s5ddAxjMlyNh+UCAwEAAaOBiTCBhjAPBgNV +HRMBAf8EBTADAQH/MAsGA1UdDwQEAwIBBjAdBgNVHQ4EFgQUppFC/RNhSiOeCKQp +5dgTBCPuQSUwRwYDVR0eBEAwPqA8MAWCAy5ncjAFggMuZXUwBoIELmVkdTAGggQu +b3JnMAWBAy5ncjAFgQMuZXUwBoEELmVkdTAGgQQub3JnMA0GCSqGSIb3DQEBBQUA +A4IBAQAf73lB4XtuP7KMhjdCSk4cNx6NZrokgclPEg8hwAOXhiVtXdMiKahsog2p +6z0GW5k6x8zDmjR/qw7IThzh+uTczQ2+vyT+bOdrwg3IBp5OjWEopmr95fZi6hg8 +TqBTnbI6nOulnJEWtk2C4AwFSKls9cz4y51JtPACpf1wA+2KIaWuE4ZJwzNzvoc7 +dIsXRSZMFpGD/md9zU1jZ/rzAxKWeAaNsWftjj++n08C9bMJL/NMh98qy5V8Acys +Nnq/onN694/BtZqhFLKPM58N7yLcZnuEvUUXBj08yrl3NI/K6s8/MT7jiOOASSXI +l7WdmplNsDz4SgCbZN2fOUvRJ9e4 +-----END CERTIFICATE----- + +# Issuer: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967 +# Subject: CN=Actalis Authentication Root CA O=Actalis S.p.A./03358520967 +# Label: "Actalis Authentication Root CA" +# Serial: 6271844772424770508 +# MD5 Fingerprint: 69:c1:0d:4f:07:a3:1b:c3:fe:56:3d:04:bc:11:f6:a6 +# SHA1 Fingerprint: f3:73:b3:87:06:5a:28:84:8a:f2:f3:4a:ce:19:2b:dd:c7:8e:9c:ac +# SHA256 Fingerprint: 55:92:60:84:ec:96:3a:64:b9:6e:2a:be:01:ce:0b:a8:6a:64:fb:fe:bc:c7:aa:b5:af:c1:55:b3:7f:d7:60:66 +-----BEGIN CERTIFICATE----- +MIIFuzCCA6OgAwIBAgIIVwoRl0LE48wwDQYJKoZIhvcNAQELBQAwazELMAkGA1UE +BhMCSVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8w +MzM1ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290 +IENBMB4XDTExMDkyMjExMjIwMloXDTMwMDkyMjExMjIwMlowazELMAkGA1UEBhMC +SVQxDjAMBgNVBAcMBU1pbGFuMSMwIQYDVQQKDBpBY3RhbGlzIFMucC5BLi8wMzM1 +ODUyMDk2NzEnMCUGA1UEAwweQWN0YWxpcyBBdXRoZW50aWNhdGlvbiBSb290IENB +MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAp8bEpSmkLO/lGMWwUKNv +UTufClrJwkg4CsIcoBh/kbWHuUA/3R1oHwiD1S0eiKD4j1aPbZkCkpAW1V8IbInX +4ay8IMKx4INRimlNAJZaby/ARH6jDuSRzVju3PvHHkVH3Se5CAGfpiEd9UEtL0z9 +KK3giq0itFZljoZUj5NDKd45RnijMCO6zfB9E1fAXdKDa0hMxKufgFpbOr3JpyI/ +gCczWw63igxdBzcIy2zSekciRDXFzMwujt0q7bd9Zg1fYVEiVRvjRuPjPdA1Yprb +rxTIW6HMiRvhMCb8oJsfgadHHwTrozmSBp+Z07/T6k9QnBn+locePGX2oxgkg4YQ +51Q+qDp2JE+BIcXjDwL4k5RHILv+1A7TaLndxHqEguNTVHnd25zS8gebLra8Pu2F +be8lEfKXGkJh90qX6IuxEAf6ZYGyojnP9zz/GPvG8VqLWeICrHuS0E4UT1lF9gxe +KF+w6D9Fz8+vm2/7hNN3WpVvrJSEnu68wEqPSpP4RCHiMUVhUE4Q2OM1fEwZtN4F +v6MGn8i1zeQf1xcGDXqVdFUNaBr8EBtiZJ1t4JWgw5QHVw0U5r0F+7if5t+L4sbn +fpb2U8WANFAoWPASUHEXMLrmeGO89LKtmyuy/uE5jF66CyCU3nuDuP/jVo23Eek7 +jPKxwV2dpAtMK9myGPW1n0sCAwEAAaNjMGEwHQYDVR0OBBYEFFLYiDrIn3hm7Ynz +ezhwlMkCAjbQMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUUtiIOsifeGbt +ifN7OHCUyQICNtAwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAL +e3KHwGCmSUyIWOYdiPcUZEim2FgKDk8TNd81HdTtBjHIgT5q1d07GjLukD0R0i70 +jsNjLiNmsGe+b7bAEzlgqqI0JZN1Ut6nna0Oh4lScWoWPBkdg/iaKWW+9D+a2fDz +WochcYBNy+A4mz+7+uAwTc+G02UQGRjRlwKxK3JCaKygvU5a2hi/a5iB0P2avl4V +SM0RFbnAKVy06Ij3Pjaut2L9HmLecHgQHEhb2rykOLpn7VU+Xlff1ANATIGk0k9j +pwlCCRT8AKnCgHNPLsBA2RF7SOp6AsDT6ygBJlh0wcBzIm2Tlf05fbsq4/aC4yyX +X04fkZT6/iyj2HYauE2yOE+b+h1IYHkm4vP9qdCa6HCPSXrW5b0KDtst842/6+Ok +fcvHlXHo2qN8xcL4dJIEG4aspCJTQLas/kx2z/uUMsA1n3Y/buWQbqCmJqK4LL7R +K4X9p2jIugErsWx0Hbhzlefut8cl8ABMALJ+tguLHPPAUJ4lueAI3jZm/zel0btU +ZCzJJ7VLkn5l/9Mt4blOvH+kQSGQQXemOR/qnuOf0GZvBeyqdn6/axag67XH/JJU +LysRJyU3eExRarDzzFhdFPFqSBX/wge2sY0PjlxQRrM9vwGYT7JZVEc+NHt4bVaT +LnPqZih4zR0Uv6CPLy64Lo7yFIrM6bV8+2ydDKXhlg== +-----END CERTIFICATE----- + +# Issuer: O=Trustis Limited OU=Trustis FPS Root CA +# Subject: O=Trustis Limited OU=Trustis FPS Root CA +# Label: "Trustis FPS Root CA" +# Serial: 36053640375399034304724988975563710553 +# MD5 Fingerprint: 30:c9:e7:1e:6b:e6:14:eb:65:b2:16:69:20:31:67:4d +# SHA1 Fingerprint: 3b:c0:38:0b:33:c3:f6:a6:0c:86:15:22:93:d9:df:f5:4b:81:c0:04 +# SHA256 Fingerprint: c1:b4:82:99:ab:a5:20:8f:e9:63:0a:ce:55:ca:68:a0:3e:da:5a:51:9c:88:02:a0:d3:a6:73:be:8f:8e:55:7d +-----BEGIN CERTIFICATE----- +MIIDZzCCAk+gAwIBAgIQGx+ttiD5JNM2a/fH8YygWTANBgkqhkiG9w0BAQUFADBF +MQswCQYDVQQGEwJHQjEYMBYGA1UEChMPVHJ1c3RpcyBMaW1pdGVkMRwwGgYDVQQL +ExNUcnVzdGlzIEZQUyBSb290IENBMB4XDTAzMTIyMzEyMTQwNloXDTI0MDEyMTEx +MzY1NFowRTELMAkGA1UEBhMCR0IxGDAWBgNVBAoTD1RydXN0aXMgTGltaXRlZDEc +MBoGA1UECxMTVHJ1c3RpcyBGUFMgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQAD +ggEPADCCAQoCggEBAMVQe547NdDfxIzNjpvto8A2mfRC6qc+gIMPpqdZh8mQRUN+ +AOqGeSoDvT03mYlmt+WKVoaTnGhLaASMk5MCPjDSNzoiYYkchU59j9WvezX2fihH +iTHcDnlkH5nSW7r+f2C/revnPDgpai/lkQtV/+xvWNUtyd5MZnGPDNcE2gfmHhjj +vSkCqPoc4Vu5g6hBSLwacY3nYuUtsuvffM/bq1rKMfFMIvMFE/eC+XN5DL7XSxzA +0RU8k0Fk0ea+IxciAIleH2ulrG6nS4zto3Lmr2NNL4XSFDWaLk6M6jKYKIahkQlB +OrTh4/L68MkKokHdqeMDx4gVOxzUGpTXn2RZEm0CAwEAAaNTMFEwDwYDVR0TAQH/ +BAUwAwEB/zAfBgNVHSMEGDAWgBS6+nEleYtXQSUhhgtx67JkDoshZzAdBgNVHQ4E +FgQUuvpxJXmLV0ElIYYLceuyZA6LIWcwDQYJKoZIhvcNAQEFBQADggEBAH5Y//01 +GX2cGE+esCu8jowU/yyg2kdbw++BLa8F6nRIW/M+TgfHbcWzk88iNVy2P3UnXwmW +zaD+vkAMXBJV+JOCyinpXj9WV4s4NvdFGkwozZ5BuO1WTISkQMi4sKUraXAEasP4 +1BIy+Q7DsdwyhEQsb8tGD+pmQQ9P8Vilpg0ND2HepZ5dfWWhPBfnqFVO76DH7cZE +f1T1o+CP8HxVIo8ptoGj4W1OLBuAZ+ytIJ8MYmHVl/9D7S3B2l0pKoU/rGXuhg8F +jZBf3+6f9L/uHfuY5H+QK4R4EA5sSVPvFVtlRkpdr7r7OnIdzfYliB6XzCGcKQEN +ZetX2fNXlrtIzYE= +-----END CERTIFICATE----- + +# Issuer: CN=Buypass Class 2 Root CA O=Buypass AS-983163327 +# Subject: CN=Buypass Class 2 Root CA O=Buypass AS-983163327 +# Label: "Buypass Class 2 Root CA" +# Serial: 2 +# MD5 Fingerprint: 46:a7:d2:fe:45:fb:64:5a:a8:59:90:9b:78:44:9b:29 +# SHA1 Fingerprint: 49:0a:75:74:de:87:0a:47:fe:58:ee:f6:c7:6b:eb:c6:0b:12:40:99 +# SHA256 Fingerprint: 9a:11:40:25:19:7c:5b:b9:5d:94:e6:3d:55:cd:43:79:08:47:b6:46:b2:3c:df:11:ad:a4:a0:0e:ff:15:fb:48 +-----BEGIN CERTIFICATE----- +MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg +Q2xhc3MgMiBSb290IENBMB4XDTEwMTAyNjA4MzgwM1oXDTQwMTAyNjA4MzgwM1ow +TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw +HgYDVQQDDBdCdXlwYXNzIENsYXNzIDIgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB +BQADggIPADCCAgoCggIBANfHXvfBB9R3+0Mh9PT1aeTuMgHbo4Yf5FkNuud1g1Lr +6hxhFUi7HQfKjK6w3Jad6sNgkoaCKHOcVgb/S2TwDCo3SbXlzwx87vFKu3MwZfPV +L4O2fuPn9Z6rYPnT8Z2SdIrkHJasW4DptfQxh6NR/Md+oW+OU3fUl8FVM5I+GC91 +1K2GScuVr1QGbNgGE41b/+EmGVnAJLqBcXmQRFBoJJRfuLMR8SlBYaNByyM21cHx +MlAQTn/0hpPshNOOvEu/XAFOBz3cFIqUCqTqc/sLUegTBxj6DvEr0VQVfTzh97QZ +QmdiXnfgolXsttlpF9U6r0TtSsWe5HonfOV116rLJeffawrbD02TTqigzXsu8lkB +arcNuAeBfos4GzjmCleZPe4h6KP1DBbdi+w0jpwqHAAVF41og9JwnxgIzRFo1clr +Us3ERo/ctfPYV3Me6ZQ5BL/T3jjetFPsaRyifsSP5BtwrfKi+fv3FmRmaZ9JUaLi +FRhnBkp/1Wy1TbMz4GHrXb7pmA8y1x1LPC5aAVKRCfLf6o3YBkBjqhHk/sM3nhRS +P/TizPJhk9H9Z2vXUq6/aKtAQ6BXNVN48FP4YUIHZMbXb5tMOA1jrGKvNouicwoN +9SG9dKpN6nIDSdvHXx1iY8f93ZHsM+71bbRuMGjeyNYmsHVee7QHIJihdjK4TWxP +AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMmAd+BikoL1Rpzz +uvdMw964o605MA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAU18h +9bqwOlI5LJKwbADJ784g7wbylp7ppHR/ehb8t/W2+xUbP6umwHJdELFx7rxP462s +A20ucS6vxOOto70MEae0/0qyexAQH6dXQbLArvQsWdZHEIjzIVEpMMpghq9Gqx3t +OluwlN5E40EIosHsHdb9T7bWR9AUC8rmyrV7d35BH16Dx7aMOZawP5aBQW9gkOLo ++fsicdl9sz1Gv7SEr5AcD48Saq/v7h56rgJKihcrdv6sVIkkLE8/trKnToyokZf7 +KcZ7XC25y2a2t6hbElGFtQl+Ynhw/qlqYLYdDnkM/crqJIByw5c/8nerQyIKx+u2 +DISCLIBrQYoIwOula9+ZEsuK1V6ADJHgJgg2SMX6OBE1/yWDLfJ6v9r9jv6ly0Us +H8SIU653DtmadsWOLB2jutXsMq7Aqqz30XpN69QH4kj3Io6wpJ9qzo6ysmD0oyLQ +I+uUWnpp3Q+/QFesa1lQ2aOZ4W7+jQF5JyMV3pKdewlNWudLSDBaGOYKbeaP4NK7 +5t98biGCwWg5TbSYWGZizEqQXsP6JwSxeRV0mcy+rSDeJmAc61ZRpqPq5KM/p/9h +3PFaTWwyI0PurKju7koSCTxdccK+efrCh2gdC/1cacwG0Jp9VJkqyTkaGa9LKkPz +Y11aWOIv4x3kqdbQCtCev9eBCfHJxyYNrJgWVqA= +-----END CERTIFICATE----- + +# Issuer: CN=Buypass Class 3 Root CA O=Buypass AS-983163327 +# Subject: CN=Buypass Class 3 Root CA O=Buypass AS-983163327 +# Label: "Buypass Class 3 Root CA" +# Serial: 2 +# MD5 Fingerprint: 3d:3b:18:9e:2c:64:5a:e8:d5:88:ce:0e:f9:37:c2:ec +# SHA1 Fingerprint: da:fa:f7:fa:66:84:ec:06:8f:14:50:bd:c7:c2:81:a5:bc:a9:64:57 +# SHA256 Fingerprint: ed:f7:eb:bc:a2:7a:2a:38:4d:38:7b:7d:40:10:c6:66:e2:ed:b4:84:3e:4c:29:b4:ae:1d:5b:93:32:e6:b2:4d +-----BEGIN CERTIFICATE----- +MIIFWTCCA0GgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBOMQswCQYDVQQGEwJOTzEd +MBsGA1UECgwUQnV5cGFzcyBBUy05ODMxNjMzMjcxIDAeBgNVBAMMF0J1eXBhc3Mg +Q2xhc3MgMyBSb290IENBMB4XDTEwMTAyNjA4Mjg1OFoXDTQwMTAyNjA4Mjg1OFow +TjELMAkGA1UEBhMCTk8xHTAbBgNVBAoMFEJ1eXBhc3MgQVMtOTgzMTYzMzI3MSAw +HgYDVQQDDBdCdXlwYXNzIENsYXNzIDMgUm9vdCBDQTCCAiIwDQYJKoZIhvcNAQEB +BQADggIPADCCAgoCggIBAKXaCpUWUOOV8l6ddjEGMnqb8RB2uACatVI2zSRHsJ8Y +ZLya9vrVediQYkwiL944PdbgqOkcLNt4EemOaFEVcsfzM4fkoF0LXOBXByow9c3E +N3coTRiR5r/VUv1xLXA+58bEiuPwKAv0dpihi4dVsjoT/Lc+JzeOIuOoTyrvYLs9 +tznDDgFHmV0ST9tD+leh7fmdvhFHJlsTmKtdFoqwNxxXnUX/iJY2v7vKB3tvh2PX +0DJq1l1sDPGzbjniazEuOQAnFN44wOwZZoYS6J1yFhNkUsepNxz9gjDthBgd9K5c +/3ATAOux9TN6S9ZV+AWNS2mw9bMoNlwUxFFzTWsL8TQH2xc519woe2v1n/MuwU8X +KhDzzMro6/1rqy6any2CbgTUUgGTLT2G/H783+9CHaZr77kgxve9oKeV/afmiSTY +zIw0bOIjL9kSGiG5VZFvC5F5GQytQIgLcOJ60g7YaEi7ghM5EFjp2CoHxhLbWNvS +O1UQRwUVZ2J+GGOmRj8JDlQyXr8NYnon74Do29lLBlo3WiXQCBJ31G8JUJc9yB3D +34xFMFbG02SrZvPAXpacw8Tvw3xrizp5f7NJzz3iiZ+gMEuFuZyUJHmPfWupRWgP +K9Dx2hzLabjKSWJtyNBjYt1gD1iqj6G8BaVmos8bdrKEZLFMOVLAMLrwjEsCsLa3 +AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFEe4zf/lb+74suwv +Tg75JbCOPGvDMA4GA1UdDwEB/wQEAwIBBjANBgkqhkiG9w0BAQsFAAOCAgEAACAj +QTUEkMJAYmDv4jVM1z+s4jSQuKFvdvoWFqRINyzpkMLyPPgKn9iB5btb2iUspKdV +cSQy9sgL8rxq+JOssgfCX5/bzMiKqr5qb+FJEMwx14C7u8jYog5kV+qi9cKpMRXS +IGrs/CIBKM+GuIAeqcwRpTzyFrNHnfzSgCHEy9BHcEGhyoMZCCxt8l13nIoUE9Q2 +HJLw5QY33KbmkJs4j1xrG0aGQ0JfPgEHU1RdZX33inOhmlRaHylDFCfChQ+1iHsa +O5S3HWCntZznKWlXWpuTekMwGwPXYshApqr8ZORK15FTAaggiG6cX0S5y2CBNOxv +033aSF/rtJC8LakcC6wc1aJoIIAE1vyxjy+7SjENSoYc6+I2KSb12tjE8nVhz36u +dmNKekBlk4f4HoCMhuWG1o8O/FMsYOgWYRqiPkN7zTlgVGr18okmAWiDSKIz6MkE +kbIRNBE+6tBDGR8Dk5AM/1E9V/RBbuHLoL7ryWPNbczk+DaqaJ3tvV2XcEQNtg41 +3OEMXbugUZTLfhbrES+jkkXITHHZvMmZUldGL1DPvTVp9D0VzgalLA8+9oG6lLvD +u79leNKGef9JOxqDDPDeeOzI8k1MGt6CKfjBWtrt7uYnXuhF0J0cUahoq0Tj0Itq +4/g7u9xN12TyUb7mqqta6THuBrxzvxNiCp/HuZc= +-----END CERTIFICATE----- + +# Issuer: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center +# Subject: CN=T-TeleSec GlobalRoot Class 3 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center +# Label: "T-TeleSec GlobalRoot Class 3" +# Serial: 1 +# MD5 Fingerprint: ca:fb:40:a8:4e:39:92:8a:1d:fe:8e:2f:c4:27:ea:ef +# SHA1 Fingerprint: 55:a6:72:3e:cb:f2:ec:cd:c3:23:74:70:19:9d:2a:be:11:e3:81:d1 +# SHA256 Fingerprint: fd:73:da:d3:1c:64:4f:f1:b4:3b:ef:0c:cd:da:96:71:0b:9c:d9:87:5e:ca:7e:31:70:7a:f3:e9:6d:52:2b:bd +-----BEGIN CERTIFICATE----- +MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx +KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd +BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl +YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1 +OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy +aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50 +ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G +CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN +8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/ +RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4 +hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5 +ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM +EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj +QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1 +A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy +WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ +1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30 +6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT +91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml +e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p +TpPDpFQUWw== +-----END CERTIFICATE----- + +# Issuer: CN=EE Certification Centre Root CA O=AS Sertifitseerimiskeskus +# Subject: CN=EE Certification Centre Root CA O=AS Sertifitseerimiskeskus +# Label: "EE Certification Centre Root CA" +# Serial: 112324828676200291871926431888494945866 +# MD5 Fingerprint: 43:5e:88:d4:7d:1a:4a:7e:fd:84:2e:52:eb:01:d4:6f +# SHA1 Fingerprint: c9:a8:b9:e7:55:80:5e:58:e3:53:77:a7:25:eb:af:c3:7b:27:cc:d7 +# SHA256 Fingerprint: 3e:84:ba:43:42:90:85:16:e7:75:73:c0:99:2f:09:79:ca:08:4e:46:85:68:1f:f1:95:cc:ba:8a:22:9b:8a:76 +-----BEGIN CERTIFICATE----- +MIIEAzCCAuugAwIBAgIQVID5oHPtPwBMyonY43HmSjANBgkqhkiG9w0BAQUFADB1 +MQswCQYDVQQGEwJFRTEiMCAGA1UECgwZQVMgU2VydGlmaXRzZWVyaW1pc2tlc2t1 +czEoMCYGA1UEAwwfRUUgQ2VydGlmaWNhdGlvbiBDZW50cmUgUm9vdCBDQTEYMBYG +CSqGSIb3DQEJARYJcGtpQHNrLmVlMCIYDzIwMTAxMDMwMTAxMDMwWhgPMjAzMDEy +MTcyMzU5NTlaMHUxCzAJBgNVBAYTAkVFMSIwIAYDVQQKDBlBUyBTZXJ0aWZpdHNl +ZXJpbWlza2Vza3VzMSgwJgYDVQQDDB9FRSBDZXJ0aWZpY2F0aW9uIENlbnRyZSBS +b290IENBMRgwFgYJKoZIhvcNAQkBFglwa2lAc2suZWUwggEiMA0GCSqGSIb3DQEB +AQUAA4IBDwAwggEKAoIBAQDIIMDs4MVLqwd4lfNE7vsLDP90jmG7sWLqI9iroWUy +euuOF0+W2Ap7kaJjbMeMTC55v6kF/GlclY1i+blw7cNRfdCT5mzrMEvhvH2/UpvO +bntl8jixwKIy72KyaOBhU8E2lf/slLo2rpwcpzIP5Xy0xm90/XsY6KxX7QYgSzIw +WFv9zajmofxwvI6Sc9uXp3whrj3B9UiHbCe9nyV0gVWw93X2PaRka9ZP585ArQ/d +MtO8ihJTmMmJ+xAdTX7Nfh9WDSFwhfYggx/2uh8Ej+p3iDXE/+pOoYtNP2MbRMNE +1CV2yreN1x5KZmTNXMWcg+HCCIia7E6j8T4cLNlsHaFLAgMBAAGjgYowgYcwDwYD +VR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBLyWj7qVhy/ +zQas8fElyalL1BSZMEUGA1UdJQQ+MDwGCCsGAQUFBwMCBggrBgEFBQcDAQYIKwYB +BQUHAwMGCCsGAQUFBwMEBggrBgEFBQcDCAYIKwYBBQUHAwkwDQYJKoZIhvcNAQEF +BQADggEBAHv25MANqhlHt01Xo/6tu7Fq1Q+e2+RjxY6hUFaTlrg4wCQiZrxTFGGV +v9DHKpY5P30osxBAIWrEr7BSdxjhlthWXePdNl4dp1BUoMUq5KqMlIpPnTX/dqQG +E5Gion0ARD9V04I8GtVbvFZMIi5GQ4okQC3zErg7cBqklrkar4dBGmoYDQZPxz5u +uSlNDUmJEYcyW+ZLBMjkXOZ0c5RdFpgTlf7727FE5TpwrDdr5rMzcijJs1eg9gIW +iAYLtqZLICjU3j2LrTcFU3T+bsy8QxdxXvnFzBqpYe73dgzzcvRyrc9yAjYHR8/v +GVCJYMzpJJUPwssd8m92kMfMdcGWxZ0= +-----END CERTIFICATE----- + +# Issuer: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH +# Subject: CN=D-TRUST Root Class 3 CA 2 2009 O=D-Trust GmbH +# Label: "D-TRUST Root Class 3 CA 2 2009" +# Serial: 623603 +# MD5 Fingerprint: cd:e0:25:69:8d:47:ac:9c:89:35:90:f7:fd:51:3d:2f +# SHA1 Fingerprint: 58:e8:ab:b0:36:15:33:fb:80:f7:9b:1b:6d:29:d3:ff:8d:5f:00:f0 +# SHA256 Fingerprint: 49:e7:a4:42:ac:f0:ea:62:87:05:00:54:b5:25:64:b6:50:e4:f4:9e:42:e3:48:d6:aa:38:e0:39:e9:57:b1:c1 +-----BEGIN CERTIFICATE----- +MIIEMzCCAxugAwIBAgIDCYPzMA0GCSqGSIb3DQEBCwUAME0xCzAJBgNVBAYTAkRF +MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMMHkQtVFJVU1QgUm9vdCBD +bGFzcyAzIENBIDIgMjAwOTAeFw0wOTExMDUwODM1NThaFw0yOTExMDUwODM1NTha +ME0xCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxJzAlBgNVBAMM +HkQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgMjAwOTCCASIwDQYJKoZIhvcNAQEB +BQADggEPADCCAQoCggEBANOySs96R+91myP6Oi/WUEWJNTrGa9v+2wBoqOADER03 +UAifTUpolDWzU9GUY6cgVq/eUXjsKj3zSEhQPgrfRlWLJ23DEE0NkVJD2IfgXU42 +tSHKXzlABF9bfsyjxiupQB7ZNoTWSPOSHjRGICTBpFGOShrvUD9pXRl/RcPHAY9R +ySPocq60vFYJfxLLHLGvKZAKyVXMD9O0Gu1HNVpK7ZxzBCHQqr0ME7UAyiZsxGsM +lFqVlNpQmvH/pStmMaTJOKDfHR+4CS7zp+hnUquVH+BGPtikw8paxTGA6Eian5Rp +/hnd2HN8gcqW3o7tszIFZYQ05ub9VxC1X3a/L7AQDcUCAwEAAaOCARowggEWMA8G +A1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFP3aFMSfMN4hvR5COfyrYyNJ4PGEMA4G +A1UdDwEB/wQEAwIBBjCB0wYDVR0fBIHLMIHIMIGAoH6gfIZ6bGRhcDovL2RpcmVj +dG9yeS5kLXRydXN0Lm5ldC9DTj1ELVRSVVNUJTIwUm9vdCUyMENsYXNzJTIwMyUy +MENBJTIwMiUyMDIwMDksTz1ELVRydXN0JTIwR21iSCxDPURFP2NlcnRpZmljYXRl +cmV2b2NhdGlvbmxpc3QwQ6BBoD+GPWh0dHA6Ly93d3cuZC10cnVzdC5uZXQvY3Js +L2QtdHJ1c3Rfcm9vdF9jbGFzc18zX2NhXzJfMjAwOS5jcmwwDQYJKoZIhvcNAQEL +BQADggEBAH+X2zDI36ScfSF6gHDOFBJpiBSVYEQBrLLpME+bUMJm2H6NMLVwMeni +acfzcNsgFYbQDfC+rAF1hM5+n02/t2A7nPPKHeJeaNijnZflQGDSNiH+0LS4F9p0 +o3/U37CYAqxva2ssJSRyoWXuJVrl5jLn8t+rSfrzkGkj2wTZ51xY/GXUl77M/C4K +zCUqNQT4YJEVdT1B/yMfGchs64JTBKbkTCJNjYy6zltz7GRUUG3RnFX7acM2w4y8 +PIWmawomDeCTmGCufsYkl4phX5GOZpIJhzbNi5stPvZR1FDUWSi9g/LMKHtThm3Y +Johw1+qRzT65ysCQblrGXnRl11z+o+I= +-----END CERTIFICATE----- + +# Issuer: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH +# Subject: CN=D-TRUST Root Class 3 CA 2 EV 2009 O=D-Trust GmbH +# Label: "D-TRUST Root Class 3 CA 2 EV 2009" +# Serial: 623604 +# MD5 Fingerprint: aa:c6:43:2c:5e:2d:cd:c4:34:c0:50:4f:11:02:4f:b6 +# SHA1 Fingerprint: 96:c9:1b:0b:95:b4:10:98:42:fa:d0:d8:22:79:fe:60:fa:b9:16:83 +# SHA256 Fingerprint: ee:c5:49:6b:98:8c:e9:86:25:b9:34:09:2e:ec:29:08:be:d0:b0:f3:16:c2:d4:73:0c:84:ea:f1:f3:d3:48:81 +-----BEGIN CERTIFICATE----- +MIIEQzCCAyugAwIBAgIDCYP0MA0GCSqGSIb3DQEBCwUAMFAxCzAJBgNVBAYTAkRF +MRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNVBAMMIUQtVFJVU1QgUm9vdCBD +bGFzcyAzIENBIDIgRVYgMjAwOTAeFw0wOTExMDUwODUwNDZaFw0yOTExMDUwODUw +NDZaMFAxCzAJBgNVBAYTAkRFMRUwEwYDVQQKDAxELVRydXN0IEdtYkgxKjAoBgNV +BAMMIUQtVFJVU1QgUm9vdCBDbGFzcyAzIENBIDIgRVYgMjAwOTCCASIwDQYJKoZI +hvcNAQEBBQADggEPADCCAQoCggEBAJnxhDRwui+3MKCOvXwEz75ivJn9gpfSegpn +ljgJ9hBOlSJzmY3aFS3nBfwZcyK3jpgAvDw9rKFs+9Z5JUut8Mxk2og+KbgPCdM0 +3TP1YtHhzRnp7hhPTFiu4h7WDFsVWtg6uMQYZB7jM7K1iXdODL/ZlGsTl28So/6Z +qQTMFexgaDbtCHu39b+T7WYxg4zGcTSHThfqr4uRjRxWQa4iN1438h3Z0S0NL2lR +p75mpoo6Kr3HGrHhFPC+Oh25z1uxav60sUYgovseO3Dvk5h9jHOW8sXvhXCtKSb8 +HgQ+HKDYD8tSg2J87otTlZCpV6LqYQXY+U3EJ/pure3511H3a6UCAwEAAaOCASQw +ggEgMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNOUikxiEyoZLsyvcop9Ntea +HNxnMA4GA1UdDwEB/wQEAwIBBjCB3QYDVR0fBIHVMIHSMIGHoIGEoIGBhn9sZGFw +Oi8vZGlyZWN0b3J5LmQtdHJ1c3QubmV0L0NOPUQtVFJVU1QlMjBSb290JTIwQ2xh +c3MlMjAzJTIwQ0ElMjAyJTIwRVYlMjAyMDA5LE89RC1UcnVzdCUyMEdtYkgsQz1E +RT9jZXJ0aWZpY2F0ZXJldm9jYXRpb25saXN0MEagRKBChkBodHRwOi8vd3d3LmQt +dHJ1c3QubmV0L2NybC9kLXRydXN0X3Jvb3RfY2xhc3NfM19jYV8yX2V2XzIwMDku +Y3JsMA0GCSqGSIb3DQEBCwUAA4IBAQA07XtaPKSUiO8aEXUHL7P+PPoeUSbrh/Yp +3uDx1MYkCenBz1UbtDDZzhr+BlGmFaQt77JLvyAoJUnRpjZ3NOhk31KxEcdzes05 +nsKtjHEh8lprr988TlWvsoRlFIm5d8sqMb7Po23Pb0iUMkZv53GMoKaEGTcH8gNF +CSuGdXzfX2lXANtu2KZyIktQ1HWYVt+3GP9DQ1CuekR78HlR10M9p9OB0/DJT7na +xpeG0ILD5EJt/rDiZE4OJudANCa1CInXCGNjOCd1HjPqbqjdn5lPdE2BiYBL3ZqX +KVwvvoFBuYz/6n1gBp7N1z3TLqMVvKjmJuVvw9y4AyHqnxbxLFS1 +-----END CERTIFICATE----- + +# Issuer: CN=CA Disig Root R2 O=Disig a.s. +# Subject: CN=CA Disig Root R2 O=Disig a.s. +# Label: "CA Disig Root R2" +# Serial: 10572350602393338211 +# MD5 Fingerprint: 26:01:fb:d8:27:a7:17:9a:45:54:38:1a:43:01:3b:03 +# SHA1 Fingerprint: b5:61:eb:ea:a4:de:e4:25:4b:69:1a:98:a5:57:47:c2:34:c7:d9:71 +# SHA256 Fingerprint: e2:3d:4a:03:6d:7b:70:e9:f5:95:b1:42:20:79:d2:b9:1e:df:bb:1f:b6:51:a0:63:3e:aa:8a:9d:c5:f8:07:03 +-----BEGIN CERTIFICATE----- +MIIFaTCCA1GgAwIBAgIJAJK4iNuwisFjMA0GCSqGSIb3DQEBCwUAMFIxCzAJBgNV +BAYTAlNLMRMwEQYDVQQHEwpCcmF0aXNsYXZhMRMwEQYDVQQKEwpEaXNpZyBhLnMu +MRkwFwYDVQQDExBDQSBEaXNpZyBSb290IFIyMB4XDTEyMDcxOTA5MTUzMFoXDTQy +MDcxOTA5MTUzMFowUjELMAkGA1UEBhMCU0sxEzARBgNVBAcTCkJyYXRpc2xhdmEx +EzARBgNVBAoTCkRpc2lnIGEucy4xGTAXBgNVBAMTEENBIERpc2lnIFJvb3QgUjIw +ggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCio8QACdaFXS1tFPbCw3Oe +NcJxVX6B+6tGUODBfEl45qt5WDza/3wcn9iXAng+a0EE6UG9vgMsRfYvZNSrXaNH +PWSb6WiaxswbP7q+sos0Ai6YVRn8jG+qX9pMzk0DIaPY0jSTVpbLTAwAFjxfGs3I +x2ymrdMxp7zo5eFm1tL7A7RBZckQrg4FY8aAamkw/dLukO8NJ9+flXP04SXabBbe +QTg06ov80egEFGEtQX6sx3dOy1FU+16SGBsEWmjGycT6txOgmLcRK7fWV8x8nhfR +yyX+hk4kLlYMeE2eARKmK6cBZW58Yh2EhN/qwGu1pSqVg8NTEQxzHQuyRpDRQjrO +QG6Vrf/GlK1ul4SOfW+eioANSW1z4nuSHsPzwfPrLgVv2RvPN3YEyLRa5Beny912 +H9AZdugsBbPWnDTYltxhh5EF5EQIM8HauQhl1K6yNg3ruji6DOWbnuuNZt2Zz9aJ +QfYEkoopKW1rOhzndX0CcQ7zwOe9yxndnWCywmZgtrEE7snmhrmaZkCo5xHtgUUD +i/ZnWejBBhG93c+AAk9lQHhcR1DIm+YfgXvkRKhbhZri3lrVx/k6RGZL5DJUfORs +nLMOPReisjQS1n6yqEm70XooQL6iFh/f5DcfEXP7kAplQ6INfPgGAVUzfbANuPT1 +rqVCV3w2EYx7XsQDnYx5nQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1Ud +DwEB/wQEAwIBBjAdBgNVHQ4EFgQUtZn4r7CU9eMg1gqtzk5WpC5uQu0wDQYJKoZI +hvcNAQELBQADggIBACYGXnDnZTPIgm7ZnBc6G3pmsgH2eDtpXi/q/075KMOYKmFM +tCQSin1tERT3nLXK5ryeJ45MGcipvXrA1zYObYVybqjGom32+nNjf7xueQgcnYqf +GopTpti72TVVsRHFqQOzVju5hJMiXn7B9hJSi+osZ7z+Nkz1uM/Rs0mSO9MpDpkb +lvdhuDvEK7Z4bLQjb/D907JedR+Zlais9trhxTF7+9FGs9K8Z7RiVLoJ92Owk6Ka ++elSLotgEqv89WBW7xBci8QaQtyDW2QOy7W81k/BfDxujRNt+3vrMNDcTa/F1bal +TFtxyegxvug4BkihGuLq0t4SOVga/4AOgnXmt8kHbA7v/zjxmHHEt38OFdAlab0i +nSvtBfZGR6ztwPDUO+Ls7pZbkBNOHlY667DvlruWIxG68kOGdGSVyCh13x01utI3 +gzhTODY7z2zp+WsO0PsE6E9312UBeIYMej4hYvF/Y3EMyZ9E26gnonW+boE+18Dr +G5gPcFw0sorMwIUY6256s/daoQe/qUKS82Ail+QUoQebTnbAjn39pCXHR+3/H3Os +zMOl6W8KjptlwlCFtaOgUxLMVYdh84GuEEZhvUQhuMI9dM9+JDX6HAcOmz0iyu8x +L4ysEr3vQCj8KWefshNPZiTEUxnpHikV7+ZtsH8tZ/3zbBt1RqPlShfppNcL +-----END CERTIFICATE----- + +# Issuer: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV +# Subject: CN=ACCVRAIZ1 O=ACCV OU=PKIACCV +# Label: "ACCVRAIZ1" +# Serial: 6828503384748696800 +# MD5 Fingerprint: d0:a0:5a:ee:05:b6:09:94:21:a1:7d:f1:b2:29:82:02 +# SHA1 Fingerprint: 93:05:7a:88:15:c6:4f:ce:88:2f:fa:91:16:52:28:78:bc:53:64:17 +# SHA256 Fingerprint: 9a:6e:c0:12:e1:a7:da:9d:be:34:19:4d:47:8a:d7:c0:db:18:22:fb:07:1d:f1:29:81:49:6e:d1:04:38:41:13 +-----BEGIN CERTIFICATE----- +MIIH0zCCBbugAwIBAgIIXsO3pkN/pOAwDQYJKoZIhvcNAQEFBQAwQjESMBAGA1UE +AwwJQUNDVlJBSVoxMRAwDgYDVQQLDAdQS0lBQ0NWMQ0wCwYDVQQKDARBQ0NWMQsw +CQYDVQQGEwJFUzAeFw0xMTA1MDUwOTM3MzdaFw0zMDEyMzEwOTM3MzdaMEIxEjAQ +BgNVBAMMCUFDQ1ZSQUlaMTEQMA4GA1UECwwHUEtJQUNDVjENMAsGA1UECgwEQUND +VjELMAkGA1UEBhMCRVMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCb +qau/YUqXry+XZpp0X9DZlv3P4uRm7x8fRzPCRKPfmt4ftVTdFXxpNRFvu8gMjmoY +HtiP2Ra8EEg2XPBjs5BaXCQ316PWywlxufEBcoSwfdtNgM3802/J+Nq2DoLSRYWo +G2ioPej0RGy9ocLLA76MPhMAhN9KSMDjIgro6TenGEyxCQ0jVn8ETdkXhBilyNpA +lHPrzg5XPAOBOp0KoVdDaaxXbXmQeOW1tDvYvEyNKKGno6e6Ak4l0Squ7a4DIrhr +IA8wKFSVf+DuzgpmndFALW4ir50awQUZ0m/A8p/4e7MCQvtQqR0tkw8jq8bBD5L/ +0KIV9VMJcRz/RROE5iZe+OCIHAr8Fraocwa48GOEAqDGWuzndN9wrqODJerWx5eH +k6fGioozl2A3ED6XPm4pFdahD9GILBKfb6qkxkLrQaLjlUPTAYVtjrs78yM2x/47 +4KElB0iryYl0/wiPgL/AlmXz7uxLaL2diMMxs0Dx6M/2OLuc5NF/1OVYm3z61PMO +m3WR5LpSLhl+0fXNWhn8ugb2+1KoS5kE3fj5tItQo05iifCHJPqDQsGH+tUtKSpa +cXpkatcnYGMN285J9Y0fkIkyF/hzQ7jSWpOGYdbhdQrqeWZ2iE9x6wQl1gpaepPl +uUsXQA+xtrn13k/c4LOsOxFwYIRKQ26ZIMApcQrAZQIDAQABo4ICyzCCAscwfQYI +KwYBBQUHAQEEcTBvMEwGCCsGAQUFBzAChkBodHRwOi8vd3d3LmFjY3YuZXMvZmls +ZWFkbWluL0FyY2hpdm9zL2NlcnRpZmljYWRvcy9yYWl6YWNjdjEuY3J0MB8GCCsG +AQUFBzABhhNodHRwOi8vb2NzcC5hY2N2LmVzMB0GA1UdDgQWBBTSh7Tj3zcnk1X2 +VuqB5TbMjB4/vTAPBgNVHRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFNKHtOPfNyeT +VfZW6oHlNsyMHj+9MIIBcwYDVR0gBIIBajCCAWYwggFiBgRVHSAAMIIBWDCCASIG +CCsGAQUFBwICMIIBFB6CARAAQQB1AHQAbwByAGkAZABhAGQAIABkAGUAIABDAGUA +cgB0AGkAZgBpAGMAYQBjAGkA8wBuACAAUgBhAO0AegAgAGQAZQAgAGwAYQAgAEEA +QwBDAFYAIAAoAEEAZwBlAG4AYwBpAGEAIABkAGUAIABUAGUAYwBuAG8AbABvAGcA +7QBhACAAeQAgAEMAZQByAHQAaQBmAGkAYwBhAGMAaQDzAG4AIABFAGwAZQBjAHQA +cgDzAG4AaQBjAGEALAAgAEMASQBGACAAUQA0ADYAMAAxADEANQA2AEUAKQAuACAA +QwBQAFMAIABlAG4AIABoAHQAdABwADoALwAvAHcAdwB3AC4AYQBjAGMAdgAuAGUA +czAwBggrBgEFBQcCARYkaHR0cDovL3d3dy5hY2N2LmVzL2xlZ2lzbGFjaW9uX2Mu +aHRtMFUGA1UdHwROMEwwSqBIoEaGRGh0dHA6Ly93d3cuYWNjdi5lcy9maWxlYWRt +aW4vQXJjaGl2b3MvY2VydGlmaWNhZG9zL3JhaXphY2N2MV9kZXIuY3JsMA4GA1Ud +DwEB/wQEAwIBBjAXBgNVHREEEDAOgQxhY2N2QGFjY3YuZXMwDQYJKoZIhvcNAQEF +BQADggIBAJcxAp/n/UNnSEQU5CmH7UwoZtCPNdpNYbdKl02125DgBS4OxnnQ8pdp +D70ER9m+27Up2pvZrqmZ1dM8MJP1jaGo/AaNRPTKFpV8M9xii6g3+CfYCS0b78gU +JyCpZET/LtZ1qmxNYEAZSUNUY9rizLpm5U9EelvZaoErQNV/+QEnWCzI7UiRfD+m +AM/EKXMRNt6GGT6d7hmKG9Ww7Y49nCrADdg9ZuM8Db3VlFzi4qc1GwQA9j9ajepD +vV+JHanBsMyZ4k0ACtrJJ1vnE5Bc5PUzolVt3OAJTS+xJlsndQAJxGJ3KQhfnlms +tn6tn1QwIgPBHnFk/vk4CpYY3QIUrCPLBhwepH2NDd4nQeit2hW3sCPdK6jT2iWH +7ehVRE2I9DZ+hJp4rPcOVkkO1jMl1oRQQmwgEh0q1b688nCBpHBgvgW1m54ERL5h +I6zppSSMEYCUWqKiuUnSwdzRp+0xESyeGabu4VXhwOrPDYTkF7eifKXeVSUG7szA +h1xA2syVP1XgNce4hL60Xc16gwFy7ofmXx2utYXGJt/mwZrpHgJHnyqobalbz+xF +d3+YJ5oyXSrjhO7FmGYvliAd3djDJ9ew+f7Zfc3Qn48LFFhRny+Lwzgt3uiP1o2H +pPVWQxaZLPSkVrQ0uGE3ycJYgBugl6H8WY3pEfbRD0tVNEYqi4Y7 +-----END CERTIFICATE----- + +# Issuer: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA +# Subject: CN=TWCA Global Root CA O=TAIWAN-CA OU=Root CA +# Label: "TWCA Global Root CA" +# Serial: 3262 +# MD5 Fingerprint: f9:03:7e:cf:e6:9e:3c:73:7a:2a:90:07:69:ff:2b:96 +# SHA1 Fingerprint: 9c:bb:48:53:f6:a4:f6:d3:52:a4:e8:32:52:55:60:13:f5:ad:af:65 +# SHA256 Fingerprint: 59:76:90:07:f7:68:5d:0f:cd:50:87:2f:9f:95:d5:75:5a:5b:2b:45:7d:81:f3:69:2b:61:0a:98:67:2f:0e:1b +-----BEGIN CERTIFICATE----- +MIIFQTCCAymgAwIBAgICDL4wDQYJKoZIhvcNAQELBQAwUTELMAkGA1UEBhMCVFcx +EjAQBgNVBAoTCVRBSVdBTi1DQTEQMA4GA1UECxMHUm9vdCBDQTEcMBoGA1UEAxMT +VFdDQSBHbG9iYWwgUm9vdCBDQTAeFw0xMjA2MjcwNjI4MzNaFw0zMDEyMzExNTU5 +NTlaMFExCzAJBgNVBAYTAlRXMRIwEAYDVQQKEwlUQUlXQU4tQ0ExEDAOBgNVBAsT +B1Jvb3QgQ0ExHDAaBgNVBAMTE1RXQ0EgR2xvYmFsIFJvb3QgQ0EwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCwBdvI64zEbooh745NnHEKH1Jw7W2CnJfF +10xORUnLQEK1EjRsGcJ0pDFfhQKX7EMzClPSnIyOt7h52yvVavKOZsTuKwEHktSz +0ALfUPZVr2YOy+BHYC8rMjk1Ujoog/h7FsYYuGLWRyWRzvAZEk2tY/XTP3VfKfCh +MBwqoJimFb3u/Rk28OKRQ4/6ytYQJ0lM793B8YVwm8rqqFpD/G2Gb3PpN0Wp8DbH +zIh1HrtsBv+baz4X7GGqcXzGHaL3SekVtTzWoWH1EfcFbx39Eb7QMAfCKbAJTibc +46KokWofwpFFiFzlmLhxpRUZyXx1EcxwdE8tmx2RRP1WKKD+u4ZqyPpcC1jcxkt2 +yKsi2XMPpfRaAok/T54igu6idFMqPVMnaR1sjjIsZAAmY2E2TqNGtz99sy2sbZCi +laLOz9qC5wc0GZbpuCGqKX6mOL6OKUohZnkfs8O1CWfe1tQHRvMq2uYiN2DLgbYP +oA/pyJV/v1WRBXrPPRXAb94JlAGD1zQbzECl8LibZ9WYkTunhHiVJqRaCPgrdLQA +BDzfuBSO6N+pjWxnkjMdwLfS7JLIvgm/LCkFbwJrnu+8vyq8W8BQj0FwcYeyTbcE +qYSjMq+u7msXi7Kx/mzhkIyIqJdIzshNy/MGz19qCkKxHh53L46g5pIOBvwFItIm +4TFRfTLcDwIDAQABoyMwITAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB +/zANBgkqhkiG9w0BAQsFAAOCAgEAXzSBdu+WHdXltdkCY4QWwa6gcFGn90xHNcgL +1yg9iXHZqjNB6hQbbCEAwGxCGX6faVsgQt+i0trEfJdLjbDorMjupWkEmQqSpqsn +LhpNgb+E1HAerUf+/UqdM+DyucRFCCEK2mlpc3INvjT+lIutwx4116KD7+U4x6WF +H6vPNOw/KP4M8VeGTslV9xzU2KV9Bnpv1d8Q34FOIWWxtuEXeZVFBs5fzNxGiWNo +RI2T9GRwoD2dKAXDOXC4Ynsg/eTb6QihuJ49CcdP+yz4k3ZB3lLg4VfSnQO8d57+ +nile98FRYB/e2guyLXW3Q0iT5/Z5xoRdgFlglPx4mI88k1HtQJAH32RjJMtOcQWh +15QaiDLxInQirqWm2BJpTGCjAu4r7NRjkgtevi92a6O2JryPA9gK8kxkRr05YuWW +6zRjESjMlfGt7+/cgFhI6Uu46mWs6fyAtbXIRfmswZ/ZuepiiI7E8UuDEq3mi4TW +nsLrgxifarsbJGAzcMzs9zLzXNl5fe+epP7JI8Mk7hWSsT2RTyaGvWZzJBPqpK5j +wa19hAM8EHiGG3njxPPyBJUgriOCxLM6AGK/5jYk4Ve6xx6QddVfP5VhK8E7zeWz +aGHQRiapIVJpLesux+t3zqY6tQMzT3bR51xUAV3LePTJDL/PEo4XLSNolOer/qmy +KwbQBM0= +-----END CERTIFICATE----- + +# Issuer: CN=TeliaSonera Root CA v1 O=TeliaSonera +# Subject: CN=TeliaSonera Root CA v1 O=TeliaSonera +# Label: "TeliaSonera Root CA v1" +# Serial: 199041966741090107964904287217786801558 +# MD5 Fingerprint: 37:41:49:1b:18:56:9a:26:f5:ad:c2:66:fb:40:a5:4c +# SHA1 Fingerprint: 43:13:bb:96:f1:d5:86:9b:c1:4e:6a:92:f6:cf:f6:34:69:87:82:37 +# SHA256 Fingerprint: dd:69:36:fe:21:f8:f0:77:c1:23:a1:a5:21:c1:22:24:f7:22:55:b7:3e:03:a7:26:06:93:e8:a2:4b:0f:a3:89 +-----BEGIN CERTIFICATE----- +MIIFODCCAyCgAwIBAgIRAJW+FqD3LkbxezmCcvqLzZYwDQYJKoZIhvcNAQEFBQAw +NzEUMBIGA1UECgwLVGVsaWFTb25lcmExHzAdBgNVBAMMFlRlbGlhU29uZXJhIFJv +b3QgQ0EgdjEwHhcNMDcxMDE4MTIwMDUwWhcNMzIxMDE4MTIwMDUwWjA3MRQwEgYD +VQQKDAtUZWxpYVNvbmVyYTEfMB0GA1UEAwwWVGVsaWFTb25lcmEgUm9vdCBDQSB2 +MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAMK+6yfwIaPzaSZVfp3F +VRaRXP3vIb9TgHot0pGMYzHw7CTww6XScnwQbfQ3t+XmfHnqjLWCi65ItqwA3GV1 +7CpNX8GH9SBlK4GoRz6JI5UwFpB/6FcHSOcZrr9FZ7E3GwYq/t75rH2D+1665I+X +Z75Ljo1kB1c4VWk0Nj0TSO9P4tNmHqTPGrdeNjPUtAa9GAH9d4RQAEX1jF3oI7x+ +/jXh7VB7qTCNGdMJjmhnXb88lxhTuylixcpecsHHltTbLaC0H2kD7OriUPEMPPCs +81Mt8Bz17Ww5OXOAFshSsCPN4D7c3TxHoLs1iuKYaIu+5b9y7tL6pe0S7fyYGKkm +dtwoSxAgHNN/Fnct7W+A90m7UwW7XWjH1Mh1Fj+JWov3F0fUTPHSiXk+TT2YqGHe +Oh7S+F4D4MHJHIzTjU3TlTazN19jY5szFPAtJmtTfImMMsJu7D0hADnJoWjiUIMu +sDor8zagrC/kb2HCUQk5PotTubtn2txTuXZZNp1D5SDgPTJghSJRt8czu90VL6R4 +pgd7gUY2BIbdeTXHlSw7sKMXNeVzH7RcWe/a6hBle3rQf5+ztCo3O3CLm1u5K7fs +slESl1MpWtTwEhDcTwK7EpIvYtQ/aUN8Ddb8WHUBiJ1YFkveupD/RwGJBmr2X7KQ +arMCpgKIv7NHfirZ1fpoeDVNAgMBAAGjPzA9MA8GA1UdEwEB/wQFMAMBAf8wCwYD +VR0PBAQDAgEGMB0GA1UdDgQWBBTwj1k4ALP1j5qWDNXr+nuqF+gTEjANBgkqhkiG +9w0BAQUFAAOCAgEAvuRcYk4k9AwI//DTDGjkk0kiP0Qnb7tt3oNmzqjMDfz1mgbl +dxSR651Be5kqhOX//CHBXfDkH1e3damhXwIm/9fH907eT/j3HEbAek9ALCI18Bmx +0GtnLLCo4MBANzX2hFxc469CeP6nyQ1Q6g2EdvZR74NTxnr/DlZJLo961gzmJ1Tj +TQpgcmLNkQfWpb/ImWvtxBnmq0wROMVvMeJuScg/doAmAyYp4Db29iBT4xdwNBed +Y2gea+zDTYa4EzAvXUYNR0PVG6pZDrlcjQZIrXSHX8f8MVRBE+LHIQ6e4B4N4cB7 +Q4WQxYpYxmUKeFfyxiMPAdkgS94P+5KFdSpcc41teyWRyu5FrgZLAMzTsVlQ2jqI +OylDRl6XK1TOU2+NSueW+r9xDkKLfP0ooNBIytrEgUy7onOTJsjrDNYmiLbAJM+7 +vVvrdX3pCI6GMyx5dwlppYn8s3CQh3aP0yK7Qs69cwsgJirQmz1wHiRszYd2qReW +t88NkvuOGKmYSdGe/mBEciG5Ge3C9THxOUiIkCR1VBatzvT4aRRkOfujuLpwQMcn +HL/EVlP6Y2XQ8xwOFvVrhlhNGNTkDY6lnVuR3HYkUD/GKvvZt5y11ubQ2egZixVx +SK236thZiNSQvxaz2emsWWFUyBy6ysHK4bkgTI86k4mloMy/0/Z1pHWWbVY= +-----END CERTIFICATE----- + +# Issuer: CN=E-Tugra Certification Authority O=E-Tu\u011fra EBG Bili\u015fim Teknolojileri ve Hizmetleri A.\u015e. OU=E-Tugra Sertifikasyon Merkezi +# Subject: CN=E-Tugra Certification Authority O=E-Tu\u011fra EBG Bili\u015fim Teknolojileri ve Hizmetleri A.\u015e. OU=E-Tugra Sertifikasyon Merkezi +# Label: "E-Tugra Certification Authority" +# Serial: 7667447206703254355 +# MD5 Fingerprint: b8:a1:03:63:b0:bd:21:71:70:8a:6f:13:3a:bb:79:49 +# SHA1 Fingerprint: 51:c6:e7:08:49:06:6e:f3:92:d4:5c:a0:0d:6d:a3:62:8f:c3:52:39 +# SHA256 Fingerprint: b0:bf:d5:2b:b0:d7:d9:bd:92:bf:5d:4d:c1:3d:a2:55:c0:2c:54:2f:37:83:65:ea:89:39:11:f5:5e:55:f2:3c +-----BEGIN CERTIFICATE----- +MIIGSzCCBDOgAwIBAgIIamg+nFGby1MwDQYJKoZIhvcNAQELBQAwgbIxCzAJBgNV +BAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+BgNVBAoMN0UtVHXEn3JhIEVCRyBC +aWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhpem1ldGxlcmkgQS7Fni4xJjAkBgNV +BAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBNZXJrZXppMSgwJgYDVQQDDB9FLVR1 +Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTEzMDMwNTEyMDk0OFoXDTIz +MDMwMzEyMDk0OFowgbIxCzAJBgNVBAYTAlRSMQ8wDQYDVQQHDAZBbmthcmExQDA+ +BgNVBAoMN0UtVHXEn3JhIEVCRyBCaWxpxZ9pbSBUZWtub2xvamlsZXJpIHZlIEhp +em1ldGxlcmkgQS7Fni4xJjAkBgNVBAsMHUUtVHVncmEgU2VydGlmaWthc3lvbiBN +ZXJrZXppMSgwJgYDVQQDDB9FLVR1Z3JhIENlcnRpZmljYXRpb24gQXV0aG9yaXR5 +MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA4vU/kwVRHoViVF56C/UY +B4Oufq9899SKa6VjQzm5S/fDxmSJPZQuVIBSOTkHS0vdhQd2h8y/L5VMzH2nPbxH +D5hw+IyFHnSOkm0bQNGZDbt1bsipa5rAhDGvykPL6ys06I+XawGb1Q5KCKpbknSF +Q9OArqGIW66z6l7LFpp3RMih9lRozt6Plyu6W0ACDGQXwLWTzeHxE2bODHnv0ZEo +q1+gElIwcxmOj+GMB6LDu0rw6h8VqO4lzKRG+Bsi77MOQ7osJLjFLFzUHPhdZL3D +k14opz8n8Y4e0ypQBaNV2cvnOVPAmJ6MVGKLJrD3fY185MaeZkJVgkfnsliNZvcH +fC425lAcP9tDJMW/hkd5s3kc91r0E+xs+D/iWR+V7kI+ua2oMoVJl0b+SzGPWsut +dEcf6ZG33ygEIqDUD13ieU/qbIWGvaimzuT6w+Gzrt48Ue7LE3wBf4QOXVGUnhMM +ti6lTPk5cDZvlsouDERVxcr6XQKj39ZkjFqzAQqptQpHF//vkUAqjqFGOjGY5RH8 +zLtJVor8udBhmm9lbObDyz51Sf6Pp+KJxWfXnUYTTjF2OySznhFlhqt/7x3U+Lzn +rFpct1pHXFXOVbQicVtbC/DP3KBhZOqp12gKY6fgDT+gr9Oq0n7vUaDmUStVkhUX +U8u3Zg5mTPj5dUyQ5xJwx0UCAwEAAaNjMGEwHQYDVR0OBBYEFC7j27JJ0JxUeVz6 +Jyr+zE7S6E5UMA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAULuPbsknQnFR5 +XPonKv7MTtLoTlQwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3DQEBCwUAA4ICAQAF +Nzr0TbdF4kV1JI+2d1LoHNgQk2Xz8lkGpD4eKexd0dCrfOAKkEh47U6YA5n+KGCR +HTAduGN8qOY1tfrTYXbm1gdLymmasoR6d5NFFxWfJNCYExL/u6Au/U5Mh/jOXKqY +GwXgAEZKgoClM4so3O0409/lPun++1ndYYRP0lSWE2ETPo+Aab6TR7U1Q9Jauz1c +77NCR807VRMGsAnb/WP2OogKmW9+4c4bU2pEZiNRCHu8W1Ki/QY3OEBhj0qWuJA3 ++GbHeJAAFS6LrVE1Uweoa2iu+U48BybNCAVwzDk/dr2l02cmAYamU9JgO3xDf1WK +vJUawSg5TB9D0pH0clmKuVb8P7Sd2nCcdlqMQ1DujjByTd//SffGqWfZbawCEeI6 +FiWnWAjLb1NBnEg4R2gz0dfHj9R0IdTDBZB6/86WiLEVKV0jq9BgoRJP3vQXzTLl +yb/IQ639Lo7xr+L0mPoSHyDYwKcMhcWQ9DstliaxLL5Mq+ux0orJ23gTDx4JnW2P +AJ8C2sH6H3p6CcRK5ogql5+Ji/03X186zjhZhkuvcQu02PJwT58yE+Owp1fl2tpD +y4Q08ijE6m30Ku/Ba3ba+367hTzSU8JNvnHhRdH9I2cNE3X7z2VnIp2usAnRCf8d +NL/+I5c30jn6PQ0GC7TbO6Orb1wdtn7os4I07QZcJA== +-----END CERTIFICATE----- + +# Issuer: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center +# Subject: CN=T-TeleSec GlobalRoot Class 2 O=T-Systems Enterprise Services GmbH OU=T-Systems Trust Center +# Label: "T-TeleSec GlobalRoot Class 2" +# Serial: 1 +# MD5 Fingerprint: 2b:9b:9e:e4:7b:6c:1f:00:72:1a:cc:c1:77:79:df:6a +# SHA1 Fingerprint: 59:0d:2d:7d:88:4f:40:2e:61:7e:a5:62:32:17:65:cf:17:d8:94:e9 +# SHA256 Fingerprint: 91:e2:f5:78:8d:58:10:eb:a7:ba:58:73:7d:e1:54:8a:8e:ca:cd:01:45:98:bc:0b:14:3e:04:1b:17:05:25:52 +-----BEGIN CERTIFICATE----- +MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx +KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd +BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl +YyBHbG9iYWxSb290IENsYXNzIDIwHhcNMDgxMDAxMTA0MDE0WhcNMzMxMDAxMjM1 +OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy +aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50 +ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDIwggEiMA0G +CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCqX9obX+hzkeXaXPSi5kfl82hVYAUd +AqSzm1nzHoqvNK38DcLZSBnuaY/JIPwhqgcZ7bBcrGXHX+0CfHt8LRvWurmAwhiC +FoT6ZrAIxlQjgeTNuUk/9k9uN0goOA/FvudocP05l03Sx5iRUKrERLMjfTlH6VJi +1hKTXrcxlkIF+3anHqP1wvzpesVsqXFP6st4vGCvx9702cu+fjOlbpSD8DT6Iavq +jnKgP6TeMFvvhk1qlVtDRKgQFRzlAVfFmPHmBiiRqiDFt1MmUUOyCxGVWOHAD3bZ +wI18gfNycJ5v/hqO2V81xrJvNHy+SE/iWjnX2J14np+GPgNeGYtEotXHAgMBAAGj +QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS/ +WSA2AHmgoCJrjNXyYdK4LMuCSjANBgkqhkiG9w0BAQsFAAOCAQEAMQOiYQsfdOhy +NsZt+U2e+iKo4YFWz827n+qrkRk4r6p8FU3ztqONpfSO9kSpp+ghla0+AGIWiPAC +uvxhI+YzmzB6azZie60EI4RYZeLbK4rnJVM3YlNfvNoBYimipidx5joifsFvHZVw +IEoHNN/q/xWA5brXethbdXwFeilHfkCoMRN3zUA7tFFHei4R40cR3p1m0IvVVGb6 +g1XqfMIpiRvpb7PO4gWEyS8+eIVibslfwXhjdFjASBgMmTnrpMwatXlajRWc2BQN +9noHV8cigwUtPJslJj0Ys6lDfMjIq2SPDqO/nBudMNva0Bkuqjzx+zOAduTNrRlP +BSeOE6Fuwg== +-----END CERTIFICATE----- + +# Issuer: CN=Atos TrustedRoot 2011 O=Atos +# Subject: CN=Atos TrustedRoot 2011 O=Atos +# Label: "Atos TrustedRoot 2011" +# Serial: 6643877497813316402 +# MD5 Fingerprint: ae:b9:c4:32:4b:ac:7f:5d:66:cc:77:94:bb:2a:77:56 +# SHA1 Fingerprint: 2b:b1:f5:3e:55:0c:1d:c5:f1:d4:e6:b7:6a:46:4b:55:06:02:ac:21 +# SHA256 Fingerprint: f3:56:be:a2:44:b7:a9:1e:b3:5d:53:ca:9a:d7:86:4a:ce:01:8e:2d:35:d5:f8:f9:6d:df:68:a6:f4:1a:a4:74 +-----BEGIN CERTIFICATE----- +MIIDdzCCAl+gAwIBAgIIXDPLYixfszIwDQYJKoZIhvcNAQELBQAwPDEeMBwGA1UE +AwwVQXRvcyBUcnVzdGVkUm9vdCAyMDExMQ0wCwYDVQQKDARBdG9zMQswCQYDVQQG +EwJERTAeFw0xMTA3MDcxNDU4MzBaFw0zMDEyMzEyMzU5NTlaMDwxHjAcBgNVBAMM +FUF0b3MgVHJ1c3RlZFJvb3QgMjAxMTENMAsGA1UECgwEQXRvczELMAkGA1UEBhMC +REUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCVhTuXbyo7LjvPpvMp +Nb7PGKw+qtn4TaA+Gke5vJrf8v7MPkfoepbCJI419KkM/IL9bcFyYie96mvr54rM +VD6QUM+A1JX76LWC1BTFtqlVJVfbsVD2sGBkWXppzwO3bw2+yj5vdHLqqjAqc2K+ +SZFhyBH+DgMq92og3AIVDV4VavzjgsG1xZ1kCWyjWZgHJ8cblithdHFsQ/H3NYkQ +4J7sVaE3IqKHBAUsR320HLliKWYoyrfhk/WklAOZuXCFteZI6o1Q/NnezG8HDt0L +cp2AMBYHlT8oDv3FdU9T1nSatCQujgKRz3bFmx5VdJx4IbHwLfELn8LVlhgf8FQi +eowHAgMBAAGjfTB7MB0GA1UdDgQWBBSnpQaxLKYJYO7Rl+lwrrw7GWzbITAPBgNV +HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFKelBrEspglg7tGX6XCuvDsZbNshMBgG +A1UdIAQRMA8wDQYLKwYBBAGwLQMEAQEwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3 +DQEBCwUAA4IBAQAmdzTblEiGKkGdLD4GkGDEjKwLVLgfuXvTBznk+j57sj1O7Z8j +vZfza1zv7v1Apt+hk6EKhqzvINB5Ab149xnYJDE0BAGmuhWawyfc2E8PzBhj/5kP +DpFrdRbhIfzYJsdHt6bPWHJxfrrhTZVHO8mvbaG0weyJ9rQPOLXiZNwlz6bb65pc +maHFCN795trV1lpFDMS3wrUU77QR/w4VtfX128a961qn8FYiqTxlVMYVqL2Gns2D +lmh6cYGJ4Qvh6hEbaAjMaZ7snkGeRDImeuKHCnE96+RapNLbxc3G3mB/ufNPRJLv +KrcYPqcZ2Qt9sTdBQrC6YB3y/gkRsPCHe6ed +-----END CERTIFICATE----- + +# Issuer: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited +# Subject: CN=QuoVadis Root CA 1 G3 O=QuoVadis Limited +# Label: "QuoVadis Root CA 1 G3" +# Serial: 687049649626669250736271037606554624078720034195 +# MD5 Fingerprint: a4:bc:5b:3f:fe:37:9a:fa:64:f0:e2:fa:05:3d:0b:ab +# SHA1 Fingerprint: 1b:8e:ea:57:96:29:1a:c9:39:ea:b8:0a:81:1a:73:73:c0:93:79:67 +# SHA256 Fingerprint: 8a:86:6f:d1:b2:76:b5:7e:57:8e:92:1c:65:82:8a:2b:ed:58:e9:f2:f2:88:05:41:34:b7:f1:f4:bf:c9:cc:74 +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIUeFhfLq0sGUvjNwc1NBMotZbUZZMwDQYJKoZIhvcNAQEL +BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMSBHMzAeFw0xMjAxMTIxNzI3NDRaFw00 +MjAxMTIxNzI3NDRaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM +aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDEgRzMwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCgvlAQjunybEC0BJyFuTHK3C3kEakEPBtV +wedYMB0ktMPvhd6MLOHBPd+C5k+tR4ds7FtJwUrVu4/sh6x/gpqG7D0DmVIB0jWe +rNrwU8lmPNSsAgHaJNM7qAJGr6Qc4/hzWHa39g6QDbXwz8z6+cZM5cOGMAqNF341 +68Xfuw6cwI2H44g4hWf6Pser4BOcBRiYz5P1sZK0/CPTz9XEJ0ngnjybCKOLXSoh +4Pw5qlPafX7PGglTvF0FBM+hSo+LdoINofjSxxR3W5A2B4GbPgb6Ul5jxaYA/qXp +UhtStZI5cgMJYr2wYBZupt0lwgNm3fME0UDiTouG9G/lg6AnhF4EwfWQvTA9xO+o +abw4m6SkltFi2mnAAZauy8RRNOoMqv8hjlmPSlzkYZqn0ukqeI1RPToV7qJZjqlc +3sX5kCLliEVx3ZGZbHqfPT2YfF72vhZooF6uCyP8Wg+qInYtyaEQHeTTRCOQiJ/G +KubX9ZqzWB4vMIkIG1SitZgj7Ah3HJVdYdHLiZxfokqRmu8hqkkWCKi9YSgxyXSt +hfbZxbGL0eUQMk1fiyA6PEkfM4VZDdvLCXVDaXP7a3F98N/ETH3Goy7IlXnLc6KO +Tk0k+17kBL5yG6YnLUlamXrXXAkgt3+UuU/xDRxeiEIbEbfnkduebPRq34wGmAOt +zCjvpUfzUwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQUo5fW816iEOGrRZ88F2Q87gFwnMwwDQYJKoZIhvcNAQELBQAD +ggIBABj6W3X8PnrHX3fHyt/PX8MSxEBd1DKquGrX1RUVRpgjpeaQWxiZTOOtQqOC +MTaIzen7xASWSIsBx40Bz1szBpZGZnQdT+3Btrm0DWHMY37XLneMlhwqI2hrhVd2 +cDMT/uFPpiN3GPoajOi9ZcnPP/TJF9zrx7zABC4tRi9pZsMbj/7sPtPKlL92CiUN +qXsCHKnQO18LwIE6PWThv6ctTr1NxNgpxiIY0MWscgKCP6o6ojoilzHdCGPDdRS5 +YCgtW2jgFqlmgiNR9etT2DGbe+m3nUvriBbP+V04ikkwj+3x6xn0dxoxGE1nVGwv +b2X52z3sIexe9PSLymBlVNFxZPT5pqOBMzYzcfCkeF9OrYMh3jRJjehZrJ3ydlo2 +8hP0r+AJx2EqbPfgna67hkooby7utHnNkDPDs3b69fBsnQGQ+p6Q9pxyz0fawx/k +NSBT8lTR32GDpgLiJTjehTItXnOQUl1CxM49S+H5GYQd1aJQzEH7QRTDvdbJWqNj +ZgKAvQU6O0ec7AAmTPWIUb+oI38YB7AL7YsmoWTTYUrrXJ/es69nA7Mf3W1daWhp +q1467HxpvMc7hU6eFbm0FU/DlXpY18ls6Wy58yljXrQs8C097Vpl4KlbQMJImYFt +nh8GKjwStIsPm6Ik8KaN1nrgS7ZklmOVhMJKzRwuJIczYOXD +-----END CERTIFICATE----- + +# Issuer: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited +# Subject: CN=QuoVadis Root CA 2 G3 O=QuoVadis Limited +# Label: "QuoVadis Root CA 2 G3" +# Serial: 390156079458959257446133169266079962026824725800 +# MD5 Fingerprint: af:0c:86:6e:bf:40:2d:7f:0b:3e:12:50:ba:12:3d:06 +# SHA1 Fingerprint: 09:3c:61:f3:8b:8b:dc:7d:55:df:75:38:02:05:00:e1:25:f5:c8:36 +# SHA256 Fingerprint: 8f:e4:fb:0a:f9:3a:4d:0d:67:db:0b:eb:b2:3e:37:c7:1b:f3:25:dc:bc:dd:24:0e:a0:4d:af:58:b4:7e:18:40 +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIURFc0JFuBiZs18s64KztbpybwdSgwDQYJKoZIhvcNAQEL +BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMiBHMzAeFw0xMjAxMTIxODU5MzJaFw00 +MjAxMTIxODU5MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM +aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDIgRzMwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQChriWyARjcV4g/Ruv5r+LrI3HimtFhZiFf +qq8nUeVuGxbULX1QsFN3vXg6YOJkApt8hpvWGo6t/x8Vf9WVHhLL5hSEBMHfNrMW +n4rjyduYNM7YMxcoRvynyfDStNVNCXJJ+fKH46nafaF9a7I6JaltUkSs+L5u+9ym +c5GQYaYDFCDy54ejiK2toIz/pgslUiXnFgHVy7g1gQyjO/Dh4fxaXc6AcW34Sas+ +O7q414AB+6XrW7PFXmAqMaCvN+ggOp+oMiwMzAkd056OXbxMmO7FGmh77FOm6RQ1 +o9/NgJ8MSPsc9PG/Srj61YxxSscfrf5BmrODXfKEVu+lV0POKa2Mq1W/xPtbAd0j +IaFYAI7D0GoT7RPjEiuA3GfmlbLNHiJuKvhB1PLKFAeNilUSxmn1uIZoL1NesNKq +IcGY5jDjZ1XHm26sGahVpkUG0CM62+tlXSoREfA7T8pt9DTEceT/AFr2XK4jYIVz +8eQQsSWu1ZK7E8EM4DnatDlXtas1qnIhO4M15zHfeiFuuDIIfR0ykRVKYnLP43eh +vNURG3YBZwjgQQvD6xVu+KQZ2aKrr+InUlYrAoosFCT5v0ICvybIxo/gbjh9Uy3l +7ZizlWNof/k19N+IxWA1ksB8aRxhlRbQ694Lrz4EEEVlWFA4r0jyWbYW8jwNkALG +cC4BrTwV1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQU7edvdlq/YOxJW8ald7tyFnGbxD0wDQYJKoZIhvcNAQELBQAD +ggIBAJHfgD9DCX5xwvfrs4iP4VGyvD11+ShdyLyZm3tdquXK4Qr36LLTn91nMX66 +AarHakE7kNQIXLJgapDwyM4DYvmL7ftuKtwGTTwpD4kWilhMSA/ohGHqPHKmd+RC +roijQ1h5fq7KpVMNqT1wvSAZYaRsOPxDMuHBR//47PERIjKWnML2W2mWeyAMQ0Ga +W/ZZGYjeVYg3UQt4XAoeo0L9x52ID8DyeAIkVJOviYeIyUqAHerQbj5hLja7NQ4n +lv1mNDthcnPxFlxHBlRJAHpYErAK74X9sbgzdWqTHBLmYF5vHX/JHyPLhGGfHoJE ++V+tYlUkmlKY7VHnoX6XOuYvHxHaU4AshZ6rNRDbIl9qxV6XU/IyAgkwo1jwDQHV +csaxfGl7w/U2Rcxhbl5MlMVerugOXou/983g7aEOGzPuVBj+D77vfoRrQ+NwmNtd +dbINWQeFFSM51vHfqSYP1kjHs6Yi9TM3WpVHn3u6GBVv/9YUZINJ0gpnIdsPNWNg +KCLjsZWDzYWm3S8P52dSbrsvhXz1SnPnxT7AvSESBT/8twNJAlvIJebiVDj1eYeM +HVOyToV7BjjHLPj4sHKNJeV3UvQDHEimUF+IIDBu8oJDqz2XhOdT+yHBTw8imoa4 +WSr2Rz0ZiC3oheGe7IUIarFsNMkd7EgrO3jtZsSOeWmD3n+M +-----END CERTIFICATE----- + +# Issuer: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited +# Subject: CN=QuoVadis Root CA 3 G3 O=QuoVadis Limited +# Label: "QuoVadis Root CA 3 G3" +# Serial: 268090761170461462463995952157327242137089239581 +# MD5 Fingerprint: df:7d:b9:ad:54:6f:68:a1:df:89:57:03:97:43:b0:d7 +# SHA1 Fingerprint: 48:12:bd:92:3c:a8:c4:39:06:e7:30:6d:27:96:e6:a4:cf:22:2e:7d +# SHA256 Fingerprint: 88:ef:81:de:20:2e:b0:18:45:2e:43:f8:64:72:5c:ea:5f:bd:1f:c2:d9:d2:05:73:07:09:c5:d8:b8:69:0f:46 +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIULvWbAiin23r/1aOp7r0DoM8Sah0wDQYJKoZIhvcNAQEL +BQAwSDELMAkGA1UEBhMCQk0xGTAXBgNVBAoTEFF1b1ZhZGlzIExpbWl0ZWQxHjAc +BgNVBAMTFVF1b1ZhZGlzIFJvb3QgQ0EgMyBHMzAeFw0xMjAxMTIyMDI2MzJaFw00 +MjAxMTIyMDI2MzJaMEgxCzAJBgNVBAYTAkJNMRkwFwYDVQQKExBRdW9WYWRpcyBM +aW1pdGVkMR4wHAYDVQQDExVRdW9WYWRpcyBSb290IENBIDMgRzMwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCzyw4QZ47qFJenMioKVjZ/aEzHs286IxSR +/xl/pcqs7rN2nXrpixurazHb+gtTTK/FpRp5PIpM/6zfJd5O2YIyC0TeytuMrKNu +FoM7pmRLMon7FhY4futD4tN0SsJiCnMK3UmzV9KwCoWdcTzeo8vAMvMBOSBDGzXR +U7Ox7sWTaYI+FrUoRqHe6okJ7UO4BUaKhvVZR74bbwEhELn9qdIoyhA5CcoTNs+c +ra1AdHkrAj80//ogaX3T7mH1urPnMNA3I4ZyYUUpSFlob3emLoG+B01vr87ERROR +FHAGjx+f+IdpsQ7vw4kZ6+ocYfx6bIrc1gMLnia6Et3UVDmrJqMz6nWB2i3ND0/k +A9HvFZcba5DFApCTZgIhsUfei5pKgLlVj7WiL8DWM2fafsSntARE60f75li59wzw +eyuxwHApw0BiLTtIadwjPEjrewl5qW3aqDCYz4ByA4imW0aucnl8CAMhZa634Ryl +sSqiMd5mBPfAdOhx3v89WcyWJhKLhZVXGqtrdQtEPREoPHtht+KPZ0/l7DxMYIBp +VzgeAVuNVejH38DMdyM0SXV89pgR6y3e7UEuFAUCf+D+IOs15xGsIs5XPd7JMG0Q +A4XN8f+MFrXBsj6IbGB/kE+V9/YtrQE5BwT6dYB9v0lQ7e/JxHwc64B+27bQ3RP+ +ydOc17KXqQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +BjAdBgNVHQ4EFgQUxhfQvKjqAkPyGwaZXSuQILnXnOQwDQYJKoZIhvcNAQELBQAD +ggIBADRh2Va1EodVTd2jNTFGu6QHcrxfYWLopfsLN7E8trP6KZ1/AvWkyaiTt3px +KGmPc+FSkNrVvjrlt3ZqVoAh313m6Tqe5T72omnHKgqwGEfcIHB9UqM+WXzBusnI +FUBhynLWcKzSt/Ac5IYp8M7vaGPQtSCKFWGafoaYtMnCdvvMujAWzKNhxnQT5Wvv +oxXqA/4Ti2Tk08HS6IT7SdEQTXlm66r99I0xHnAUrdzeZxNMgRVhvLfZkXdxGYFg +u/BYpbWcC/ePIlUnwEsBbTuZDdQdm2NnL9DuDcpmvJRPpq3t/O5jrFc/ZSXPsoaP +0Aj/uHYUbt7lJ+yreLVTubY/6CD50qi+YUbKh4yE8/nxoGibIh6BJpsQBJFxwAYf +3KDTuVan45gtf4Od34wrnDKOMpTwATwiKp9Dwi7DmDkHOHv8XgBCH/MyJnmDhPbl +8MFREsALHgQjDFSlTC9JxUrRtm5gDWv8a4uFJGS3iQ6rJUdbPM9+Sb3H6QrG2vd+ +DhcI00iX0HGS8A85PjRqHH3Y8iKuu2n0M7SmSFXRDw4m6Oy2Cy2nhTXN/VnIn9HN +PlopNLk9hM6xZdRZkZFWdSHBd575euFgndOtBBj0fOtek49TSiIp+EgrPk2GrFt/ +ywaZWWDYWGWVjUTR939+J399roD1B0y2PpxxVJkES/1Y+Zj0 +-----END CERTIFICATE----- + +# Issuer: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com +# Subject: CN=DigiCert Assured ID Root G2 O=DigiCert Inc OU=www.digicert.com +# Label: "DigiCert Assured ID Root G2" +# Serial: 15385348160840213938643033620894905419 +# MD5 Fingerprint: 92:38:b9:f8:63:24:82:65:2c:57:33:e6:fe:81:8f:9d +# SHA1 Fingerprint: a1:4b:48:d9:43:ee:0a:0e:40:90:4f:3c:e0:a4:c0:91:93:51:5d:3f +# SHA256 Fingerprint: 7d:05:eb:b6:82:33:9f:8c:94:51:ee:09:4e:eb:fe:fa:79:53:a1:14:ed:b2:f4:49:49:45:2f:ab:7d:2f:c1:85 +-----BEGIN CERTIFICATE----- +MIIDljCCAn6gAwIBAgIQC5McOtY5Z+pnI7/Dr5r0SzANBgkqhkiG9w0BAQsFADBl +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv +b3QgRzIwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQG +EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl +cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzIwggEi +MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDZ5ygvUj82ckmIkzTz+GoeMVSA +n61UQbVH35ao1K+ALbkKz3X9iaV9JPrjIgwrvJUXCzO/GU1BBpAAvQxNEP4Htecc +biJVMWWXvdMX0h5i89vqbFCMP4QMls+3ywPgym2hFEwbid3tALBSfK+RbLE4E9Hp +EgjAALAcKxHad3A2m67OeYfcgnDmCXRwVWmvo2ifv922ebPynXApVfSr/5Vh88lA +bx3RvpO704gqu52/clpWcTs/1PPRCv4o76Pu2ZmvA9OPYLfykqGxvYmJHzDNw6Yu +YjOuFgJ3RFrngQo8p0Quebg/BLxcoIfhG69Rjs3sLPr4/m3wOnyqi+RnlTGNAgMB +AAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQW +BBTOw0q5mVXyuNtgv6l+vVa1lzan1jANBgkqhkiG9w0BAQsFAAOCAQEAyqVVjOPI +QW5pJ6d1Ee88hjZv0p3GeDgdaZaikmkuOGybfQTUiaWxMTeKySHMq2zNixya1r9I +0jJmwYrA8y8678Dj1JGG0VDjA9tzd29KOVPt3ibHtX2vK0LRdWLjSisCx1BL4Gni +lmwORGYQRI+tBev4eaymG+g3NJ1TyWGqolKvSnAWhsI6yLETcDbYz+70CjTVW0z9 +B5yiutkBclzzTcHdDrEcDcRjvq30FPuJ7KJBDkzMyFdA0G4Dqs0MjomZmWzwPDCv +ON9vvKO+KSAnq3T/EyJ43pdSVR6DtVQgA+6uwE9W3jfMw3+qBCe703e4YtsXfJwo +IhNzbM8m9Yop5w== +-----END CERTIFICATE----- + +# Issuer: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com +# Subject: CN=DigiCert Assured ID Root G3 O=DigiCert Inc OU=www.digicert.com +# Label: "DigiCert Assured ID Root G3" +# Serial: 15459312981008553731928384953135426796 +# MD5 Fingerprint: 7c:7f:65:31:0c:81:df:8d:ba:3e:99:e2:5c:ad:6e:fb +# SHA1 Fingerprint: f5:17:a2:4f:9a:48:c6:c9:f8:a2:00:26:9f:dc:0f:48:2c:ab:30:89 +# SHA256 Fingerprint: 7e:37:cb:8b:4c:47:09:0c:ab:36:55:1b:a6:f4:5d:b8:40:68:0f:ba:16:6a:95:2d:b1:00:71:7f:43:05:3f:c2 +-----BEGIN CERTIFICATE----- +MIICRjCCAc2gAwIBAgIQC6Fa+h3foLVJRK/NJKBs7DAKBggqhkjOPQQDAzBlMQsw +CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu +ZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3Qg +RzMwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBlMQswCQYDVQQGEwJV +UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu +Y29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgRzMwdjAQBgcq +hkjOPQIBBgUrgQQAIgNiAAQZ57ysRGXtzbg/WPuNsVepRC0FFfLvC/8QdJ+1YlJf +Zn4f5dwbRXkLzMZTCp2NXQLZqVneAlr2lSoOjThKiknGvMYDOAdfVdp+CW7if17Q +RSAPWXYQ1qAk8C3eNvJsKTmjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/ +BAQDAgGGMB0GA1UdDgQWBBTL0L2p4ZgFUaFNN6KDec6NHSrkhDAKBggqhkjOPQQD +AwNnADBkAjAlpIFFAmsSS3V0T8gj43DydXLefInwz5FyYZ5eEJJZVrmDxxDnOOlY +JjZ91eQ0hjkCMHw2U/Aw5WJjOpnitqM7mzT6HtoQknFekROn3aRukswy1vUhZscv +6pZjamVFkpUBtA== +-----END CERTIFICATE----- + +# Issuer: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com +# Subject: CN=DigiCert Global Root G2 O=DigiCert Inc OU=www.digicert.com +# Label: "DigiCert Global Root G2" +# Serial: 4293743540046975378534879503202253541 +# MD5 Fingerprint: e4:a6:8a:c8:54:ac:52:42:46:0a:fd:72:48:1b:2a:44 +# SHA1 Fingerprint: df:3c:24:f9:bf:d6:66:76:1b:26:80:73:fe:06:d1:cc:8d:4f:82:a4 +# SHA256 Fingerprint: cb:3c:cb:b7:60:31:e5:e0:13:8f:8d:d3:9a:23:f9:de:47:ff:c3:5e:43:c1:14:4c:ea:27:d4:6a:5a:b1:cb:5f +-----BEGIN CERTIFICATE----- +MIIDjjCCAnagAwIBAgIQAzrx5qcRqaC7KGSxHQn65TANBgkqhkiG9w0BAQsFADBh +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBH +MjAeFw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVT +MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j +b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEcyMIIBIjANBgkqhkiG +9w0BAQEFAAOCAQ8AMIIBCgKCAQEAuzfNNNx7a8myaJCtSnX/RrohCgiN9RlUyfuI +2/Ou8jqJkTx65qsGGmvPrC3oXgkkRLpimn7Wo6h+4FR1IAWsULecYxpsMNzaHxmx +1x7e/dfgy5SDN67sH0NO3Xss0r0upS/kqbitOtSZpLYl6ZtrAGCSYP9PIUkY92eQ +q2EGnI/yuum06ZIya7XzV+hdG82MHauVBJVJ8zUtluNJbd134/tJS7SsVQepj5Wz +tCO7TG1F8PapspUwtP1MVYwnSlcUfIKdzXOS0xZKBgyMUNGPHgm+F6HmIcr9g+UQ +vIOlCsRnKPZzFBQ9RnbDhxSJITRNrw9FDKZJobq7nMWxM4MphQIDAQABo0IwQDAP +BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAdBgNVHQ4EFgQUTiJUIBiV +5uNu5g/6+rkS7QYXjzkwDQYJKoZIhvcNAQELBQADggEBAGBnKJRvDkhj6zHd6mcY +1Yl9PMWLSn/pvtsrF9+wX3N3KjITOYFnQoQj8kVnNeyIv/iPsGEMNKSuIEyExtv4 +NeF22d+mQrvHRAiGfzZ0JFrabA0UWTW98kndth/Jsw1HKj2ZL7tcu7XUIOGZX1NG +Fdtom/DzMNU+MeKNhJ7jitralj41E6Vf8PlwUHBHQRFXGU7Aj64GxJUTFy8bJZ91 +8rGOmaFvE7FBcf6IKshPECBV1/MUReXgRPTqh5Uykw7+U0b6LJ3/iyK5S9kJRaTe +pLiaWN0bfVKfjllDiIGknibVb63dDcY3fe0Dkhvld1927jyNxF1WW6LZZm6zNTfl +MrY= +-----END CERTIFICATE----- + +# Issuer: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com +# Subject: CN=DigiCert Global Root G3 O=DigiCert Inc OU=www.digicert.com +# Label: "DigiCert Global Root G3" +# Serial: 7089244469030293291760083333884364146 +# MD5 Fingerprint: f5:5d:a4:50:a5:fb:28:7e:1e:0f:0d:cc:96:57:56:ca +# SHA1 Fingerprint: 7e:04:de:89:6a:3e:66:6d:00:e6:87:d3:3f:fa:d9:3b:e8:3d:34:9e +# SHA256 Fingerprint: 31:ad:66:48:f8:10:41:38:c7:38:f3:9e:a4:32:01:33:39:3e:3a:18:cc:02:29:6e:f9:7c:2a:c9:ef:67:31:d0 +-----BEGIN CERTIFICATE----- +MIICPzCCAcWgAwIBAgIQBVVWvPJepDU1w6QP1atFcjAKBggqhkjOPQQDAzBhMQsw +CQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cu +ZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBHMzAe +Fw0xMzA4MDExMjAwMDBaFw0zODAxMTUxMjAwMDBaMGExCzAJBgNVBAYTAlVTMRUw +EwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5jb20x +IDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IEczMHYwEAYHKoZIzj0CAQYF +K4EEACIDYgAE3afZu4q4C/sLfyHS8L6+c/MzXRq8NOrexpu80JX28MzQC7phW1FG +fp4tn+6OYwwX7Adw9c+ELkCDnOg/QW07rdOkFFk2eJ0DQ+4QE2xy3q6Ip6FrtUPO +Z9wj/wMco+I+o0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBhjAd +BgNVHQ4EFgQUs9tIpPmhxdiuNkHMEWNpYim8S8YwCgYIKoZIzj0EAwMDaAAwZQIx +AK288mw/EkrRLTnDCgmXc/SINoyIJ7vmiI1Qhadj+Z4y3maTD/HMsQmP3Wyr+mt/ +oAIwOWZbwmSNuJ5Q3KjVSaLtx9zRSX8XAbjIho9OjIgrqJqpisXRAL34VOKa5Vt8 +sycX +-----END CERTIFICATE----- + +# Issuer: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com +# Subject: CN=DigiCert Trusted Root G4 O=DigiCert Inc OU=www.digicert.com +# Label: "DigiCert Trusted Root G4" +# Serial: 7451500558977370777930084869016614236 +# MD5 Fingerprint: 78:f2:fc:aa:60:1f:2f:b4:eb:c9:37:ba:53:2e:75:49 +# SHA1 Fingerprint: dd:fb:16:cd:49:31:c9:73:a2:03:7d:3f:c8:3a:4d:7d:77:5d:05:e4 +# SHA256 Fingerprint: 55:2f:7b:dc:f1:a7:af:9e:6c:e6:72:01:7f:4f:12:ab:f7:72:40:c7:8e:76:1a:c2:03:d1:d9:d2:0a:c8:99:88 +-----BEGIN CERTIFICATE----- +MIIFkDCCA3igAwIBAgIQBZsbV56OITLiOQe9p3d1XDANBgkqhkiG9w0BAQwFADBi +MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3 +d3cuZGlnaWNlcnQuY29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3Qg +RzQwHhcNMTMwODAxMTIwMDAwWhcNMzgwMTE1MTIwMDAwWjBiMQswCQYDVQQGEwJV +UzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQu +Y29tMSEwHwYDVQQDExhEaWdpQ2VydCBUcnVzdGVkIFJvb3QgRzQwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQC/5pBzaN675F1KPDAiMGkz7MKnJS7JIT3y +ithZwuEppz1Yq3aaza57G4QNxDAf8xukOBbrVsaXbR2rsnnyyhHS5F/WBTxSD1If +xp4VpX6+n6lXFllVcq9ok3DCsrp1mWpzMpTREEQQLt+C8weE5nQ7bXHiLQwb7iDV +ySAdYyktzuxeTsiT+CFhmzTrBcZe7FsavOvJz82sNEBfsXpm7nfISKhmV1efVFiO +DCu3T6cw2Vbuyntd463JT17lNecxy9qTXtyOj4DatpGYQJB5w3jHtrHEtWoYOAMQ +jdjUN6QuBX2I9YI+EJFwq1WCQTLX2wRzKm6RAXwhTNS8rhsDdV14Ztk6MUSaM0C/ +CNdaSaTC5qmgZ92kJ7yhTzm1EVgX9yRcRo9k98FpiHaYdj1ZXUJ2h4mXaXpI8OCi +EhtmmnTK3kse5w5jrubU75KSOp493ADkRSWJtppEGSt+wJS00mFt6zPZxd9LBADM +fRyVw4/3IbKyEbe7f/LVjHAsQWCqsWMYRJUadmJ+9oCw++hkpjPRiQfhvbfmQ6QY +uKZ3AeEPlAwhHbJUKSWJbOUOUlFHdL4mrLZBdd56rF+NP8m800ERElvlEFDrMcXK +chYiCd98THU/Y+whX8QgUWtvsauGi0/C1kVfnSD8oR7FwI+isX4KJpn15GkvmB0t +9dmpsh3lGwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIB +hjAdBgNVHQ4EFgQU7NfjgtJxXWRM3y5nP+e6mK4cD08wDQYJKoZIhvcNAQEMBQAD +ggIBALth2X2pbL4XxJEbw6GiAI3jZGgPVs93rnD5/ZpKmbnJeFwMDF/k5hQpVgs2 +SV1EY+CtnJYYZhsjDT156W1r1lT40jzBQ0CuHVD1UvyQO7uYmWlrx8GnqGikJ9yd ++SeuMIW59mdNOj6PWTkiU0TryF0Dyu1Qen1iIQqAyHNm0aAFYF/opbSnr6j3bTWc +fFqK1qI4mfN4i/RN0iAL3gTujJtHgXINwBQy7zBZLq7gcfJW5GqXb5JQbZaNaHqa +sjYUegbyJLkJEVDXCLG4iXqEI2FCKeWjzaIgQdfRnGTZ6iahixTXTBmyUEFxPT9N +cCOGDErcgdLMMpSEDQgJlxxPwO5rIHQw0uA5NBCFIRUBCOhVMt5xSdkoF1BN5r5N +0XWs0Mr7QbhDparTwwVETyw2m+L64kW4I1NsBm9nVX9GtUw/bihaeSbSpKhil9Ie +4u1Ki7wb/UdKDd9nZn6yW0HQO+T0O/QEY+nvwlQAUaCKKsnOeMzV6ocEGLPOr0mI +r/OSmbaz5mEP0oUA51Aa5BuVnRmhuZyxm7EAHu/QD09CbMkKvO5D+jpxpchNJqU1 +/YldvIViHTLSoCtU7ZpXwdv6EM8Zt4tKG48BtieVU+i2iW1bvGjUI+iLUaJW+fCm +gKDWHrO8Dw9TdSmq6hN35N6MgSGtBxBHEa2HPQfRdbzP82Z+ +-----END CERTIFICATE----- + +# Issuer: CN=COMODO RSA Certification Authority O=COMODO CA Limited +# Subject: CN=COMODO RSA Certification Authority O=COMODO CA Limited +# Label: "COMODO RSA Certification Authority" +# Serial: 101909084537582093308941363524873193117 +# MD5 Fingerprint: 1b:31:b0:71:40:36:cc:14:36:91:ad:c4:3e:fd:ec:18 +# SHA1 Fingerprint: af:e5:d2:44:a8:d1:19:42:30:ff:47:9f:e2:f8:97:bb:cd:7a:8c:b4 +# SHA256 Fingerprint: 52:f0:e1:c4:e5:8e:c6:29:29:1b:60:31:7f:07:46:71:b8:5d:7e:a8:0d:5b:07:27:34:63:53:4b:32:b4:02:34 +-----BEGIN CERTIFICATE----- +MIIF2DCCA8CgAwIBAgIQTKr5yttjb+Af907YWwOGnTANBgkqhkiG9w0BAQwFADCB +hTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G +A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNV +BAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMTE5 +MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgT +EkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMR +Q09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBSU0EgQ2VydGlmaWNh +dGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCR +6FSS0gpWsawNJN3Fz0RndJkrN6N9I3AAcbxT38T6KhKPS38QVr2fcHK3YX/JSw8X +pz3jsARh7v8Rl8f0hj4K+j5c+ZPmNHrZFGvnnLOFoIJ6dq9xkNfs/Q36nGz637CC +9BR++b7Epi9Pf5l/tfxnQ3K9DADWietrLNPtj5gcFKt+5eNu/Nio5JIk2kNrYrhV +/erBvGy2i/MOjZrkm2xpmfh4SDBF1a3hDTxFYPwyllEnvGfDyi62a+pGx8cgoLEf +Zd5ICLqkTqnyg0Y3hOvozIFIQ2dOciqbXL1MGyiKXCJ7tKuY2e7gUYPDCUZObT6Z ++pUX2nwzV0E8jVHtC7ZcryxjGt9XyD+86V3Em69FmeKjWiS0uqlWPc9vqv9JWL7w +qP/0uK3pN/u6uPQLOvnoQ0IeidiEyxPx2bvhiWC4jChWrBQdnArncevPDt09qZah +SL0896+1DSJMwBGB7FY79tOi4lu3sgQiUpWAk2nojkxl8ZEDLXB0AuqLZxUpaVIC +u9ffUGpVRr+goyhhf3DQw6KqLCGqR84onAZFdr+CGCe01a60y1Dma/RMhnEw6abf +Fobg2P9A3fvQQoh/ozM6LlweQRGBY84YcWsr7KaKtzFcOmpH4MN5WdYgGq/yapiq +crxXStJLnbsQ/LBMQeXtHT1eKJ2czL+zUdqnR+WEUwIDAQABo0IwQDAdBgNVHQ4E +FgQUu69+Aj36pvE8hI6t7jiY7NkyMtQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB +/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAArx1UaEt65Ru2yyTUEUAJNMnMvl +wFTPoCWOAvn9sKIN9SCYPBMtrFaisNZ+EZLpLrqeLppysb0ZRGxhNaKatBYSaVqM +4dc+pBroLwP0rmEdEBsqpIt6xf4FpuHA1sj+nq6PK7o9mfjYcwlYRm6mnPTXJ9OV +2jeDchzTc+CiR5kDOF3VSXkAKRzH7JsgHAckaVd4sjn8OoSgtZx8jb8uk2Intzna +FxiuvTwJaP+EmzzV1gsD41eeFPfR60/IvYcjt7ZJQ3mFXLrrkguhxuhoqEwWsRqZ +CuhTLJK7oQkYdQxlqHvLI7cawiiFwxv/0Cti76R7CZGYZ4wUAc1oBmpjIXUDgIiK +boHGhfKppC3n9KUkEEeDys30jXlYsQab5xoq2Z0B15R97QNKyvDb6KkBPvVWmcke +jkk9u+UJueBPSZI9FoJAzMxZxuY67RIuaTxslbH9qh17f4a+Hg4yRvv7E491f0yL +S0Zj/gA0QHDBw7mh3aZw4gSzQbzpgJHqZJx64SIDqZxubw5lT2yHh17zbqD5daWb +QOhTsiedSrnAdyGN/4fy3ryM7xfft0kL0fJuMAsaDk527RH89elWsn2/x20Kk4yl +0MC2Hb46TpSi125sC8KKfPog88Tk5c0NqMuRkrF8hey1FGlmDoLnzc7ILaZRfyHB +NVOFBkpdn627G190 +-----END CERTIFICATE----- + +# Issuer: CN=USERTrust RSA Certification Authority O=The USERTRUST Network +# Subject: CN=USERTrust RSA Certification Authority O=The USERTRUST Network +# Label: "USERTrust RSA Certification Authority" +# Serial: 2645093764781058787591871645665788717 +# MD5 Fingerprint: 1b:fe:69:d1:91:b7:19:33:a3:72:a8:0f:e1:55:e5:b5 +# SHA1 Fingerprint: 2b:8f:1b:57:33:0d:bb:a2:d0:7a:6c:51:f7:0e:e9:0d:da:b9:ad:8e +# SHA256 Fingerprint: e7:93:c9:b0:2f:d8:aa:13:e2:1c:31:22:8a:cc:b0:81:19:64:3b:74:9c:89:89:64:b1:74:6d:46:c3:d4:cb:d2 +-----BEGIN CERTIFICATE----- +MIIF3jCCA8agAwIBAgIQAf1tMPyjylGoG7xkDjUDLTANBgkqhkiG9w0BAQwFADCB +iDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0pl +cnNleSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNV +BAMTJVVTRVJUcnVzdCBSU0EgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAw +MjAxMDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNV +BAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVU +aGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBSU0EgQ2Vy +dGlmaWNhdGlvbiBBdXRob3JpdHkwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK +AoICAQCAEmUXNg7D2wiz0KxXDXbtzSfTTK1Qg2HiqiBNCS1kCdzOiZ/MPans9s/B +3PHTsdZ7NygRK0faOca8Ohm0X6a9fZ2jY0K2dvKpOyuR+OJv0OwWIJAJPuLodMkY +tJHUYmTbf6MG8YgYapAiPLz+E/CHFHv25B+O1ORRxhFnRghRy4YUVD+8M/5+bJz/ +Fp0YvVGONaanZshyZ9shZrHUm3gDwFA66Mzw3LyeTP6vBZY1H1dat//O+T23LLb2 +VN3I5xI6Ta5MirdcmrS3ID3KfyI0rn47aGYBROcBTkZTmzNg95S+UzeQc0PzMsNT +79uq/nROacdrjGCT3sTHDN/hMq7MkztReJVni+49Vv4M0GkPGw/zJSZrM233bkf6 +c0Plfg6lZrEpfDKEY1WJxA3Bk1QwGROs0303p+tdOmw1XNtB1xLaqUkL39iAigmT +Yo61Zs8liM2EuLE/pDkP2QKe6xJMlXzzawWpXhaDzLhn4ugTncxbgtNMs+1b/97l +c6wjOy0AvzVVdAlJ2ElYGn+SNuZRkg7zJn0cTRe8yexDJtC/QV9AqURE9JnnV4ee +UB9XVKg+/XRjL7FQZQnmWEIuQxpMtPAlR1n6BB6T1CZGSlCBst6+eLf8ZxXhyVeE +Hg9j1uliutZfVS7qXMYoCAQlObgOK6nyTJccBz8NUvXt7y+CDwIDAQABo0IwQDAd +BgNVHQ4EFgQUU3m/WqorSs9UgOHYm8Cd8rIDZsswDgYDVR0PAQH/BAQDAgEGMA8G +A1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEMBQADggIBAFzUfA3P9wF9QZllDHPF +Up/L+M+ZBn8b2kMVn54CVVeWFPFSPCeHlCjtHzoBN6J2/FNQwISbxmtOuowhT6KO +VWKR82kV2LyI48SqC/3vqOlLVSoGIG1VeCkZ7l8wXEskEVX/JJpuXior7gtNn3/3 +ATiUFJVDBwn7YKnuHKsSjKCaXqeYalltiz8I+8jRRa8YFWSQEg9zKC7F4iRO/Fjs +8PRF/iKz6y+O0tlFYQXBl2+odnKPi4w2r78NBc5xjeambx9spnFixdjQg3IM8WcR +iQycE0xyNN+81XHfqnHd4blsjDwSXWXavVcStkNr/+XeTWYRUc+ZruwXtuhxkYze +Sf7dNXGiFSeUHM9h4ya7b6NnJSFd5t0dCy5oGzuCr+yDZ4XUmFF0sbmZgIn/f3gZ +XHlKYC6SQK5MNyosycdiyA5d9zZbyuAlJQG03RoHnHcAP9Dc1ew91Pq7P8yF1m9/ +qS3fuQL39ZeatTXaw2ewh0qpKJ4jjv9cJ2vhsE/zB+4ALtRZh8tSQZXq9EfX7mRB +VXyNWQKV3WKdwrnuWih0hKWbt5DHDAff9Yk2dDLWKMGwsAvgnEzDHNb842m1R0aB +L6KCq9NjRHDEjf8tM7qtj3u1cIiuPhnPQCjY/MiQu12ZIvVS5ljFH4gxQ+6IHdfG +jjxDah2nGN59PRbxYvnKkKj9 +-----END CERTIFICATE----- + +# Issuer: CN=USERTrust ECC Certification Authority O=The USERTRUST Network +# Subject: CN=USERTrust ECC Certification Authority O=The USERTRUST Network +# Label: "USERTrust ECC Certification Authority" +# Serial: 123013823720199481456569720443997572134 +# MD5 Fingerprint: fa:68:bc:d9:b5:7f:ad:fd:c9:1d:06:83:28:cc:24:c1 +# SHA1 Fingerprint: d1:cb:ca:5d:b2:d5:2a:7f:69:3b:67:4d:e5:f0:5a:1d:0c:95:7d:f0 +# SHA256 Fingerprint: 4f:f4:60:d5:4b:9c:86:da:bf:bc:fc:57:12:e0:40:0d:2b:ed:3f:bc:4d:4f:bd:aa:86:e0:6a:dc:d2:a9:ad:7a +-----BEGIN CERTIFICATE----- +MIICjzCCAhWgAwIBAgIQXIuZxVqUxdJxVt7NiYDMJjAKBggqhkjOPQQDAzCBiDEL +MAkGA1UEBhMCVVMxEzARBgNVBAgTCk5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNl +eSBDaXR5MR4wHAYDVQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMT +JVVTRVJUcnVzdCBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMTAwMjAx +MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCBiDELMAkGA1UEBhMCVVMxEzARBgNVBAgT +Ck5ldyBKZXJzZXkxFDASBgNVBAcTC0plcnNleSBDaXR5MR4wHAYDVQQKExVUaGUg +VVNFUlRSVVNUIE5ldHdvcmsxLjAsBgNVBAMTJVVTRVJUcnVzdCBFQ0MgQ2VydGlm +aWNhdGlvbiBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQarFRaqflo +I+d61SRvU8Za2EurxtW20eZzca7dnNYMYf3boIkDuAUU7FfO7l0/4iGzzvfUinng +o4N+LZfQYcTxmdwlkWOrfzCjtHDix6EznPO/LlxTsV+zfTJ/ijTjeXmjQjBAMB0G +A1UdDgQWBBQ64QmG1M8ZwpZ2dEl23OA1xmNjmjAOBgNVHQ8BAf8EBAMCAQYwDwYD +VR0TAQH/BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjA2Z6EWCNzklwBBHU6+4WMB +zzuqQhFkoJ2UOQIReVx7Hfpkue4WQrO/isIJxOzksU0CMQDpKmFHjFJKS04YcPbW +RNZu9YO6bVi9JNlWSOrvxKJGgYhqOkbRqZtNyWHa0V1Xahg= +-----END CERTIFICATE----- + +# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4 +# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R4 +# Label: "GlobalSign ECC Root CA - R4" +# Serial: 14367148294922964480859022125800977897474 +# MD5 Fingerprint: 20:f0:27:68:d1:7e:a0:9d:0e:e6:2a:ca:df:5c:89:8e +# SHA1 Fingerprint: 69:69:56:2e:40:80:f4:24:a1:e7:19:9f:14:ba:f3:ee:58:ab:6a:bb +# SHA256 Fingerprint: be:c9:49:11:c2:95:56:76:db:6c:0a:55:09:86:d7:6e:3b:a0:05:66:7c:44:2c:97:62:b4:fb:b7:73:de:22:8c +-----BEGIN CERTIFICATE----- +MIIB4TCCAYegAwIBAgIRKjikHJYKBN5CsiilC+g0mAIwCgYIKoZIzj0EAwIwUDEk +MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI0MRMwEQYDVQQKEwpH +bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX +DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD +QSAtIFI0MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu +MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEuMZ5049sJQ6fLjkZHAOkrprlOQcJ +FspjsbmG+IpXwVfOQvpzofdlQv8ewQCybnMO/8ch5RikqtlxP6jUuc6MHaNCMEAw +DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFSwe61F +uOJAf/sKbvu+M8k8o4TVMAoGCCqGSM49BAMCA0gAMEUCIQDckqGgE6bPA7DmxCGX +kPoUVy0D7O48027KqGx2vKLeuwIgJ6iFJzWbVsaj8kfSt24bAgAXqmemFZHe+pTs +ewv4n4Q= +-----END CERTIFICATE----- + +# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5 +# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign ECC Root CA - R5 +# Label: "GlobalSign ECC Root CA - R5" +# Serial: 32785792099990507226680698011560947931244 +# MD5 Fingerprint: 9f:ad:3b:1c:02:1e:8a:ba:17:74:38:81:0c:a2:bc:08 +# SHA1 Fingerprint: 1f:24:c6:30:cd:a4:18:ef:20:69:ff:ad:4f:dd:5f:46:3a:1b:69:aa +# SHA256 Fingerprint: 17:9f:bc:14:8a:3d:d0:0f:d2:4e:a1:34:58:cc:43:bf:a7:f5:9c:81:82:d7:83:a5:13:f6:eb:ec:10:0c:89:24 +-----BEGIN CERTIFICATE----- +MIICHjCCAaSgAwIBAgIRYFlJ4CYuu1X5CneKcflK2GwwCgYIKoZIzj0EAwMwUDEk +MCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBDQSAtIFI1MRMwEQYDVQQKEwpH +bG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWduMB4XDTEyMTExMzAwMDAwMFoX +DTM4MDExOTAzMTQwN1owUDEkMCIGA1UECxMbR2xvYmFsU2lnbiBFQ0MgUm9vdCBD +QSAtIFI1MRMwEQYDVQQKEwpHbG9iYWxTaWduMRMwEQYDVQQDEwpHbG9iYWxTaWdu +MHYwEAYHKoZIzj0CAQYFK4EEACIDYgAER0UOlvt9Xb/pOdEh+J8LttV7HpI6SFkc +8GIxLcB6KP4ap1yztsyX50XUWPrRd21DosCHZTQKH3rd6zwzocWdTaRvQZU4f8ke +hOvRnkmSh5SHDDqFSmafnVmTTZdhBoZKo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYD +VR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUPeYpSJvqB8ohREom3m7e0oPQn1kwCgYI +KoZIzj0EAwMDaAAwZQIxAOVpEslu28YxuglB4Zf4+/2a4n0Sye18ZNPLBSWLVtmg +515dTguDnFt2KaAJJiFqYgIwcdK1j1zqO+F4CYWodZI7yFz9SO8NdCKoCOJuxUnO +xwy8p2Fp8fc74SrL+SvzZpA3 +-----END CERTIFICATE----- + +# Issuer: CN=Staat der Nederlanden Root CA - G3 O=Staat der Nederlanden +# Subject: CN=Staat der Nederlanden Root CA - G3 O=Staat der Nederlanden +# Label: "Staat der Nederlanden Root CA - G3" +# Serial: 10003001 +# MD5 Fingerprint: 0b:46:67:07:db:10:2f:19:8c:35:50:60:d1:0b:f4:37 +# SHA1 Fingerprint: d8:eb:6b:41:51:92:59:e0:f3:e7:85:00:c0:3d:b6:88:97:c9:ee:fc +# SHA256 Fingerprint: 3c:4f:b0:b9:5a:b8:b3:00:32:f4:32:b8:6f:53:5f:e1:72:c1:85:d0:fd:39:86:58:37:cf:36:18:7f:a6:f4:28 +-----BEGIN CERTIFICATE----- +MIIFdDCCA1ygAwIBAgIEAJiiOTANBgkqhkiG9w0BAQsFADBaMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSswKQYDVQQDDCJTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gUm9vdCBDQSAtIEczMB4XDTEzMTExNDExMjg0MloX +DTI4MTExMzIzMDAwMFowWjELMAkGA1UEBhMCTkwxHjAcBgNVBAoMFVN0YWF0IGRl +ciBOZWRlcmxhbmRlbjErMCkGA1UEAwwiU3RhYXQgZGVyIE5lZGVybGFuZGVuIFJv +b3QgQ0EgLSBHMzCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAL4yolQP +cPssXFnrbMSkUeiFKrPMSjTysF/zDsccPVMeiAho2G89rcKezIJnByeHaHE6n3WW +IkYFsO2tx1ueKt6c/DrGlaf1F2cY5y9JCAxcz+bMNO14+1Cx3Gsy8KL+tjzk7FqX +xz8ecAgwoNzFs21v0IJyEavSgWhZghe3eJJg+szeP4TrjTgzkApyI/o1zCZxMdFy +KJLZWyNtZrVtB0LrpjPOktvA9mxjeM3KTj215VKb8b475lRgsGYeCasH/lSJEULR +9yS6YHgamPfJEf0WwTUaVHXvQ9Plrk7O53vDxk5hUUurmkVLoR9BvUhTFXFkC4az +5S6+zqQbwSmEorXLCCN2QyIkHxcE1G6cxvx/K2Ya7Irl1s9N9WMJtxU51nus6+N8 +6U78dULI7ViVDAZCopz35HCz33JvWjdAidiFpNfxC95DGdRKWCyMijmev4SH8RY7 +Ngzp07TKbBlBUgmhHbBqv4LvcFEhMtwFdozL92TkA1CvjJFnq8Xy7ljY3r735zHP +bMk7ccHViLVlvMDoFxcHErVc0qsgk7TmgoNwNsXNo42ti+yjwUOH5kPiNL6VizXt +BznaqB16nzaeErAMZRKQFWDZJkBE41ZgpRDUajz9QdwOWke275dhdU/Z/seyHdTt +XUmzqWrLZoQT1Vyg3N9udwbRcXXIV2+vD3dbAgMBAAGjQjBAMA8GA1UdEwEB/wQF +MAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRUrfrHkleuyjWcLhL75Lpd +INyUVzANBgkqhkiG9w0BAQsFAAOCAgEAMJmdBTLIXg47mAE6iqTnB/d6+Oea31BD +U5cqPco8R5gu4RV78ZLzYdqQJRZlwJ9UXQ4DO1t3ApyEtg2YXzTdO2PCwyiBwpwp +LiniyMMB8jPqKqrMCQj3ZWfGzd/TtiunvczRDnBfuCPRy5FOCvTIeuXZYzbB1N/8 +Ipf3YF3qKS9Ysr1YvY2WTxB1v0h7PVGHoTx0IsL8B3+A3MSs/mrBcDCw6Y5p4ixp +gZQJut3+TcCDjJRYwEYgr5wfAvg1VUkvRtTA8KCWAg8zxXHzniN9lLf9OtMJgwYh +/WA9rjLA0u6NpvDntIJ8CsxwyXmA+P5M9zWEGYox+wrZ13+b8KKaa8MFSu1BYBQw +0aoRQm7TIwIEC8Zl3d1Sd9qBa7Ko+gE4uZbqKmxnl4mUnrzhVNXkanjvSr0rmj1A +fsbAddJu+2gw7OyLnflJNZoaLNmzlTnVHpL3prllL+U9bTpITAjc5CgSKL59NVzq +4BZ+Extq1z7XnvwtdbLBFNUjA9tbbws+eC8N3jONFrdI54OagQ97wUNNVQQXOEpR +1VmiiXTTn74eS9fGbbeIJG9gkaSChVtWQbzQRKtqE77RLFi3EjNYsjdj3BP1lB0/ +QFH1T/U67cjF68IeHRaVesd+QnGTbksVtzDfqu1XhUisHWrdOWnk4Xl4vs4Fv6EM +94B7IWcnMFk= +-----END CERTIFICATE----- + +# Issuer: CN=Staat der Nederlanden EV Root CA O=Staat der Nederlanden +# Subject: CN=Staat der Nederlanden EV Root CA O=Staat der Nederlanden +# Label: "Staat der Nederlanden EV Root CA" +# Serial: 10000013 +# MD5 Fingerprint: fc:06:af:7b:e8:1a:f1:9a:b4:e8:d2:70:1f:c0:f5:ba +# SHA1 Fingerprint: 76:e2:7e:c1:4f:db:82:c1:c0:a6:75:b5:05:be:3d:29:b4:ed:db:bb +# SHA256 Fingerprint: 4d:24:91:41:4c:fe:95:67:46:ec:4c:ef:a6:cf:6f:72:e2:8a:13:29:43:2f:9d:8a:90:7a:c4:cb:5d:ad:c1:5a +-----BEGIN CERTIFICATE----- +MIIFcDCCA1igAwIBAgIEAJiWjTANBgkqhkiG9w0BAQsFADBYMQswCQYDVQQGEwJO +TDEeMBwGA1UECgwVU3RhYXQgZGVyIE5lZGVybGFuZGVuMSkwJwYDVQQDDCBTdGFh +dCBkZXIgTmVkZXJsYW5kZW4gRVYgUm9vdCBDQTAeFw0xMDEyMDgxMTE5MjlaFw0y +MjEyMDgxMTEwMjhaMFgxCzAJBgNVBAYTAk5MMR4wHAYDVQQKDBVTdGFhdCBkZXIg +TmVkZXJsYW5kZW4xKTAnBgNVBAMMIFN0YWF0IGRlciBOZWRlcmxhbmRlbiBFViBS +b290IENBMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA48d+ifkkSzrS +M4M1LGns3Amk41GoJSt5uAg94JG6hIXGhaTK5skuU6TJJB79VWZxXSzFYGgEt9nC +UiY4iKTWO0Cmws0/zZiTs1QUWJZV1VD+hq2kY39ch/aO5ieSZxeSAgMs3NZmdO3d +Z//BYY1jTw+bbRcwJu+r0h8QoPnFfxZpgQNH7R5ojXKhTbImxrpsX23Wr9GxE46p +rfNeaXUmGD5BKyF/7otdBwadQ8QpCiv8Kj6GyzyDOvnJDdrFmeK8eEEzduG/L13l +pJhQDBXd4Pqcfzho0LKmeqfRMb1+ilgnQ7O6M5HTp5gVXJrm0w912fxBmJc+qiXb +j5IusHsMX/FjqTf5m3VpTCgmJdrV8hJwRVXj33NeN/UhbJCONVrJ0yPr08C+eKxC +KFhmpUZtcALXEPlLVPxdhkqHz3/KRawRWrUgUY0viEeXOcDPusBCAUCZSCELa6fS +/ZbV0b5GnUngC6agIk440ME8MLxwjyx1zNDFjFE7PZQIZCZhfbnDZY8UnCHQqv0X +cgOPvZuM5l5Tnrmd74K74bzickFbIZTTRTeU0d8JOV3nI6qaHcptqAqGhYqCvkIH +1vI4gnPah1vlPNOePqc7nvQDs/nxfRN0Av+7oeX6AHkcpmZBiFxgV6YuCcS6/ZrP +px9Aw7vMWgpVSzs4dlG4Y4uElBbmVvMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB +/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFP6rAJCYniT8qcwaivsnuL8wbqg7 +MA0GCSqGSIb3DQEBCwUAA4ICAQDPdyxuVr5Os7aEAJSrR8kN0nbHhp8dB9O2tLsI +eK9p0gtJ3jPFrK3CiAJ9Brc1AsFgyb/E6JTe1NOpEyVa/m6irn0F3H3zbPB+po3u +2dfOWBfoqSmuc0iH55vKbimhZF8ZE/euBhD/UcabTVUlT5OZEAFTdfETzsemQUHS +v4ilf0X8rLiltTMMgsT7B/Zq5SWEXwbKwYY5EdtYzXc7LMJMD16a4/CrPmEbUCTC +wPTxGfARKbalGAKb12NMcIxHowNDXLldRqANb/9Zjr7dn3LDWyvfjFvO5QxGbJKy +CqNMVEIYFRIYvdr8unRu/8G2oGTYqV9Vrp9canaW2HNnh/tNf1zuacpzEPuKqf2e +vTY4SUmH9A4U8OmHuD+nT3pajnnUk+S7aFKErGzp85hwVXIy+TSrK0m1zSBi5Dp6 +Z2Orltxtrpfs/J92VoguZs9btsmksNcFuuEnL5O7Jiqik7Ab846+HUCjuTaPPoIa +Gl6I6lD4WeKDRikL40Rc4ZW2aZCaFG+XroHPaO+Zmr615+F/+PoTRxZMzG0IQOeL +eG9QgkRQP2YGiqtDhFZKDyAthg710tvSeopLzaXoTvFeJiUBWSOgftL2fiFX1ye8 +FVdMpEbB4IMeDExNH08GGeL5qPQ6gqGyeUN51q1veieQA6TqJIc/2b3Z6fJfUEkc +7uzXLg== +-----END CERTIFICATE----- + +# Issuer: CN=IdenTrust Commercial Root CA 1 O=IdenTrust +# Subject: CN=IdenTrust Commercial Root CA 1 O=IdenTrust +# Label: "IdenTrust Commercial Root CA 1" +# Serial: 13298821034946342390520003877796839426 +# MD5 Fingerprint: b3:3e:77:73:75:ee:a0:d3:e3:7e:49:63:49:59:bb:c7 +# SHA1 Fingerprint: df:71:7e:aa:4a:d9:4e:c9:55:84:99:60:2d:48:de:5f:bc:f0:3a:25 +# SHA256 Fingerprint: 5d:56:49:9b:e4:d2:e0:8b:cf:ca:d0:8a:3e:38:72:3d:50:50:3b:de:70:69:48:e4:2f:55:60:30:19:e5:28:ae +-----BEGIN CERTIFICATE----- +MIIFYDCCA0igAwIBAgIQCgFCgAAAAUUjyES1AAAAAjANBgkqhkiG9w0BAQsFADBK +MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScwJQYDVQQDEx5JZGVu +VHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwHhcNMTQwMTE2MTgxMjIzWhcNMzQw +MTE2MTgxMjIzWjBKMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MScw +JQYDVQQDEx5JZGVuVHJ1c3QgQ29tbWVyY2lhbCBSb290IENBIDEwggIiMA0GCSqG +SIb3DQEBAQUAA4ICDwAwggIKAoICAQCnUBneP5k91DNG8W9RYYKyqU+PZ4ldhNlT +3Qwo2dfw/66VQ3KZ+bVdfIrBQuExUHTRgQ18zZshq0PirK1ehm7zCYofWjK9ouuU ++ehcCuz/mNKvcbO0U59Oh++SvL3sTzIwiEsXXlfEU8L2ApeN2WIrvyQfYo3fw7gp +S0l4PJNgiCL8mdo2yMKi1CxUAGc1bnO/AljwpN3lsKImesrgNqUZFvX9t++uP0D1 +bVoE/c40yiTcdCMbXTMTEl3EASX2MN0CXZ/g1Ue9tOsbobtJSdifWwLziuQkkORi +T0/Br4sOdBeo0XKIanoBScy0RnnGF7HamB4HWfp1IYVl3ZBWzvurpWCdxJ35UrCL +vYf5jysjCiN2O/cz4ckA82n5S6LgTrx+kzmEB/dEcH7+B1rlsazRGMzyNeVJSQjK +Vsk9+w8YfYs7wRPCTY/JTw436R+hDmrfYi7LNQZReSzIJTj0+kuniVyc0uMNOYZK +dHzVWYfCP04MXFL0PfdSgvHqo6z9STQaKPNBiDoT7uje/5kdX7rL6B7yuVBgwDHT +c+XvvqDtMwt0viAgxGds8AgDelWAf0ZOlqf0Hj7h9tgJ4TNkK2PXMl6f+cB7D3hv +l7yTmvmcEpB4eoCHFddydJxVdHixuuFucAS6T6C6aMN7/zHwcz09lCqxC0EOoP5N +iGVreTO01wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB +/zAdBgNVHQ4EFgQU7UQZwNPwBovupHu+QucmVMiONnYwDQYJKoZIhvcNAQELBQAD +ggIBAA2ukDL2pkt8RHYZYR4nKM1eVO8lvOMIkPkp165oCOGUAFjvLi5+U1KMtlwH +6oi6mYtQlNeCgN9hCQCTrQ0U5s7B8jeUeLBfnLOic7iPBZM4zY0+sLj7wM+x8uwt +LRvM7Kqas6pgghstO8OEPVeKlh6cdbjTMM1gCIOQ045U8U1mwF10A0Cj7oV+wh93 +nAbowacYXVKV7cndJZ5t+qntozo00Fl72u1Q8zW/7esUTTHHYPTa8Yec4kjixsU3 ++wYQ+nVZZjFHKdp2mhzpgq7vmrlR94gjmmmVYjzlVYA211QC//G5Xc7UI2/YRYRK +W2XviQzdFKcgyxilJbQN+QHwotL0AMh0jqEqSI5l2xPE4iUXfeu+h1sXIFRRk0pT +AwvsXcoz7WL9RccvW9xYoIA55vrX/hMUpu09lEpCdNTDd1lzzY9GvlU47/rokTLq +l1gEIt44w8y8bckzOmoKaT+gyOpyj4xjhiO9bTyWnpXgSUyqorkqG5w2gXjtw+hG +4iZZRHUe2XWJUc0QhJ1hYMtd+ZciTY6Y5uN/9lu7rs3KSoFrXgvzUeF0K+l+J6fZ +mUlO+KWA2yUPHGNiiskzZ2s8EIPGrd6ozRaOjfAHN3Gf8qv8QfXBi+wAN10J5U6A +7/qxXDgGpRtK4dw4LTzcqx+QGtVKnO7RcGzM7vRX+Bi6hG6H +-----END CERTIFICATE----- + +# Issuer: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust +# Subject: CN=IdenTrust Public Sector Root CA 1 O=IdenTrust +# Label: "IdenTrust Public Sector Root CA 1" +# Serial: 13298821034946342390521976156843933698 +# MD5 Fingerprint: 37:06:a5:b0:fc:89:9d:ba:f4:6b:8c:1a:64:cd:d5:ba +# SHA1 Fingerprint: ba:29:41:60:77:98:3f:f4:f3:ef:f2:31:05:3b:2e:ea:6d:4d:45:fd +# SHA256 Fingerprint: 30:d0:89:5a:9a:44:8a:26:20:91:63:55:22:d1:f5:20:10:b5:86:7a:ca:e1:2c:78:ef:95:8f:d4:f4:38:9f:2f +-----BEGIN CERTIFICATE----- +MIIFZjCCA06gAwIBAgIQCgFCgAAAAUUjz0Z8AAAAAjANBgkqhkiG9w0BAQsFADBN +MQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0MSowKAYDVQQDEyFJZGVu +VHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwHhcNMTQwMTE2MTc1MzMyWhcN +MzQwMTE2MTc1MzMyWjBNMQswCQYDVQQGEwJVUzESMBAGA1UEChMJSWRlblRydXN0 +MSowKAYDVQQDEyFJZGVuVHJ1c3QgUHVibGljIFNlY3RvciBSb290IENBIDEwggIi +MA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2IpT8pEiv6EdrCvsnduTyP4o7 +ekosMSqMjbCpwzFrqHd2hCa2rIFCDQjrVVi7evi8ZX3yoG2LqEfpYnYeEe4IFNGy +RBb06tD6Hi9e28tzQa68ALBKK0CyrOE7S8ItneShm+waOh7wCLPQ5CQ1B5+ctMlS +bdsHyo+1W/CD80/HLaXIrcuVIKQxKFdYWuSNG5qrng0M8gozOSI5Cpcu81N3uURF +/YTLNiCBWS2ab21ISGHKTN9T0a9SvESfqy9rg3LvdYDaBjMbXcjaY8ZNzaxmMc3R +3j6HEDbhuaR672BQssvKplbgN6+rNBM5Jeg5ZuSYeqoSmJxZZoY+rfGwyj4GD3vw +EUs3oERte8uojHH01bWRNszwFcYr3lEXsZdMUD2xlVl8BX0tIdUAvwFnol57plzy +9yLxkA2T26pEUWbMfXYD62qoKjgZl3YNa4ph+bz27nb9cCvdKTz4Ch5bQhyLVi9V +GxyhLrXHFub4qjySjmm2AcG1hp2JDws4lFTo6tyePSW8Uybt1as5qsVATFSrsrTZ +2fjXctscvG29ZV/viDUqZi/u9rNl8DONfJhBaUYPQxxp+pu10GFqzcpL2UyQRqsV +WaFHVCkugyhfHMKiq3IXAAaOReyL4jM9f9oZRORicsPfIsbyVtTdX5Vy7W1f90gD +W/3FKqD2cyOEEBsB5wIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/ +BAUwAwEB/zAdBgNVHQ4EFgQU43HgntinQtnbcZFrlJPrw6PRFKMwDQYJKoZIhvcN +AQELBQADggIBAEf63QqwEZE4rU1d9+UOl1QZgkiHVIyqZJnYWv6IAcVYpZmxI1Qj +t2odIFflAWJBF9MJ23XLblSQdf4an4EKwt3X9wnQW3IV5B4Jaj0z8yGa5hV+rVHV +DRDtfULAj+7AmgjVQdZcDiFpboBhDhXAuM/FSRJSzL46zNQuOAXeNf0fb7iAaJg9 +TaDKQGXSc3z1i9kKlT/YPyNtGtEqJBnZhbMX73huqVjRI9PHE+1yJX9dsXNw0H8G +lwmEKYBhHfpe/3OsoOOJuBxxFcbeMX8S3OFtm6/n6J91eEyrRjuazr8FGF1NFTwW +mhlQBJqymm9li1JfPFgEKCXAZmExfrngdbkaqIHWchezxQMxNRF4eKLg6TCMf4Df +WN88uieW4oA0beOY02QnrEh+KHdcxiVhJfiFDGX6xDIvpZgF5PgLZxYWxoK4Mhn5 ++bl53B/N66+rDt0b20XkeucC4pVd/GnwU2lhlXV5C15V5jgclKlZM57IcXR5f1GJ +tshquDDIajjDbp7hNxbqBWJMWxJH7ae0s1hWx0nzfxJoCTFx8G34Tkf71oXuxVhA +GaQdp/lLQzfcaFpPz+vCZHTetBXZ9FRUGi8c15dxVJCO2SCdUyt/q4/i6jC8UDfv +8Ue1fXwsBOxonbRJRBD0ckscZOf85muQ3Wl9af0AVqW3rLatt8o+Ae+c +-----END CERTIFICATE----- + +# Issuer: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only +# Subject: CN=Entrust Root Certification Authority - G2 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2009 Entrust, Inc. - for authorized use only +# Label: "Entrust Root Certification Authority - G2" +# Serial: 1246989352 +# MD5 Fingerprint: 4b:e2:c9:91:96:65:0c:f4:0e:5a:93:92:a0:0a:fe:b2 +# SHA1 Fingerprint: 8c:f4:27:fd:79:0c:3a:d1:66:06:8d:e8:1e:57:ef:bb:93:22:72:d4 +# SHA256 Fingerprint: 43:df:57:74:b0:3e:7f:ef:5f:e4:0d:93:1a:7b:ed:f1:bb:2e:6b:42:73:8c:4e:6d:38:41:10:3d:3a:a7:f3:39 +-----BEGIN CERTIFICATE----- +MIIEPjCCAyagAwIBAgIESlOMKDANBgkqhkiG9w0BAQsFADCBvjELMAkGA1UEBhMC +VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50 +cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3Qs +IEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVz +dCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRzIwHhcNMDkwNzA3MTcy +NTU0WhcNMzAxMjA3MTc1NTU0WjCBvjELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUVu +dHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3d3cuZW50cnVzdC5uZXQvbGVnYWwt +dGVybXMxOTA3BgNVBAsTMChjKSAyMDA5IEVudHJ1c3QsIEluYy4gLSBmb3IgYXV0 +aG9yaXplZCB1c2Ugb25seTEyMDAGA1UEAxMpRW50cnVzdCBSb290IENlcnRpZmlj +YXRpb24gQXV0aG9yaXR5IC0gRzIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK +AoIBAQC6hLZy254Ma+KZ6TABp3bqMriVQRrJ2mFOWHLP/vaCeb9zYQYKpSfYs1/T +RU4cctZOMvJyig/3gxnQaoCAAEUesMfnmr8SVycco2gvCoe9amsOXmXzHHfV1IWN +cCG0szLni6LVhjkCsbjSR87kyUnEO6fe+1R9V77w6G7CebI6C1XiUJgWMhNcL3hW +wcKUs/Ja5CeanyTXxuzQmyWC48zCxEXFjJd6BmsqEZ+pCm5IO2/b1BEZQvePB7/1 +U1+cPvQXLOZprE4yTGJ36rfo5bs0vBmLrpxR57d+tVOxMyLlbc9wPBr64ptntoP0 +jaWvYkxN4FisZDQSA/i2jZRjJKRxAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAP +BgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRqciZ60B7vfec7aVHUbI2fkBJmqzAN +BgkqhkiG9w0BAQsFAAOCAQEAeZ8dlsa2eT8ijYfThwMEYGprmi5ZiXMRrEPR9RP/ +jTkrwPK9T3CMqS/qF8QLVJ7UG5aYMzyorWKiAHarWWluBh1+xLlEjZivEtRh2woZ +Rkfz6/djwUAFQKXSt/S1mja/qYh2iARVBCuch38aNzx+LaUa2NSJXsq9rD1s2G2v +1fN2D807iDginWyTmsQ9v4IbZT+mD12q/OWyFcq1rca8PdCE6OoGcrBNOTJ4vz4R +nAuknZoh8/CbCzB428Hch0P+vGOaysXCHMnHjf87ElgI5rY97HosTvuDls4MPGmH +VHOkc8KT/1EQrBVUAdj8BbGJoX90g5pJ19xOe4pIb4tF9g== +-----END CERTIFICATE----- + +# Issuer: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only +# Subject: CN=Entrust Root Certification Authority - EC1 O=Entrust, Inc. OU=See www.entrust.net/legal-terms/(c) 2012 Entrust, Inc. - for authorized use only +# Label: "Entrust Root Certification Authority - EC1" +# Serial: 51543124481930649114116133369 +# MD5 Fingerprint: b6:7e:1d:f0:58:c5:49:6c:24:3b:3d:ed:98:18:ed:bc +# SHA1 Fingerprint: 20:d8:06:40:df:9b:25:f5:12:25:3a:11:ea:f7:59:8a:eb:14:b5:47 +# SHA256 Fingerprint: 02:ed:0e:b2:8c:14:da:45:16:5c:56:67:91:70:0d:64:51:d7:fb:56:f0:b2:ab:1d:3b:8e:b0:70:e5:6e:df:f5 +-----BEGIN CERTIFICATE----- +MIIC+TCCAoCgAwIBAgINAKaLeSkAAAAAUNCR+TAKBggqhkjOPQQDAzCBvzELMAkG +A1UEBhMCVVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xKDAmBgNVBAsTH1NlZSB3 +d3cuZW50cnVzdC5uZXQvbGVnYWwtdGVybXMxOTA3BgNVBAsTMChjKSAyMDEyIEVu +dHJ1c3QsIEluYy4gLSBmb3IgYXV0aG9yaXplZCB1c2Ugb25seTEzMDEGA1UEAxMq +RW50cnVzdCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IC0gRUMxMB4XDTEy +MTIxODE1MjUzNloXDTM3MTIxODE1NTUzNlowgb8xCzAJBgNVBAYTAlVTMRYwFAYD +VQQKEw1FbnRydXN0LCBJbmMuMSgwJgYDVQQLEx9TZWUgd3d3LmVudHJ1c3QubmV0 +L2xlZ2FsLXRlcm1zMTkwNwYDVQQLEzAoYykgMjAxMiBFbnRydXN0LCBJbmMuIC0g +Zm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxMzAxBgNVBAMTKkVudHJ1c3QgUm9vdCBD +ZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEVDMTB2MBAGByqGSM49AgEGBSuBBAAi +A2IABIQTydC6bUF74mzQ61VfZgIaJPRbiWlH47jCffHyAsWfoPZb1YsGGYZPUxBt +ByQnoaD41UcZYUx9ypMn6nQM72+WCf5j7HBdNq1nd67JnXxVRDqiY1Ef9eNi1KlH +Bz7MIKNCMEAwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O +BBYEFLdj5xrdjekIplWDpOBqUEFlEUJJMAoGCCqGSM49BAMDA2cAMGQCMGF52OVC +R98crlOZF7ZvHH3hvxGU0QOIdeSNiaSKd0bebWHvAvX7td/M/k7//qnmpwIwW5nX +hTcGtXsI/esni0qU+eH6p44mCOh8kmhtc9hvJqwhAriZtyZBWyVgrtBIGu4G +-----END CERTIFICATE----- + +# Issuer: CN=CFCA EV ROOT O=China Financial Certification Authority +# Subject: CN=CFCA EV ROOT O=China Financial Certification Authority +# Label: "CFCA EV ROOT" +# Serial: 407555286 +# MD5 Fingerprint: 74:e1:b6:ed:26:7a:7a:44:30:33:94:ab:7b:27:81:30 +# SHA1 Fingerprint: e2:b8:29:4b:55:84:ab:6b:58:c2:90:46:6c:ac:3f:b8:39:8f:84:83 +# SHA256 Fingerprint: 5c:c3:d7:8e:4e:1d:5e:45:54:7a:04:e6:87:3e:64:f9:0c:f9:53:6d:1c:cc:2e:f8:00:f3:55:c4:c5:fd:70:fd +-----BEGIN CERTIFICATE----- +MIIFjTCCA3WgAwIBAgIEGErM1jANBgkqhkiG9w0BAQsFADBWMQswCQYDVQQGEwJD +TjEwMC4GA1UECgwnQ2hpbmEgRmluYW5jaWFsIENlcnRpZmljYXRpb24gQXV0aG9y +aXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJPT1QwHhcNMTIwODA4MDMwNzAxWhcNMjkx +MjMxMDMwNzAxWjBWMQswCQYDVQQGEwJDTjEwMC4GA1UECgwnQ2hpbmEgRmluYW5j +aWFsIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MRUwEwYDVQQDDAxDRkNBIEVWIFJP +T1QwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQDXXWvNED8fBVnVBU03 +sQ7smCuOFR36k0sXgiFxEFLXUWRwFsJVaU2OFW2fvwwbwuCjZ9YMrM8irq93VCpL +TIpTUnrD7i7es3ElweldPe6hL6P3KjzJIx1qqx2hp/Hz7KDVRM8Vz3IvHWOX6Jn5 +/ZOkVIBMUtRSqy5J35DNuF++P96hyk0g1CXohClTt7GIH//62pCfCqktQT+x8Rgp +7hZZLDRJGqgG16iI0gNyejLi6mhNbiyWZXvKWfry4t3uMCz7zEasxGPrb382KzRz +EpR/38wmnvFyXVBlWY9ps4deMm/DGIq1lY+wejfeWkU7xzbh72fROdOXW3NiGUgt +hxwG+3SYIElz8AXSG7Ggo7cbcNOIabla1jj0Ytwli3i/+Oh+uFzJlU9fpy25IGvP +a931DfSCt/SyZi4QKPaXWnuWFo8BGS1sbn85WAZkgwGDg8NNkt0yxoekN+kWzqot +aK8KgWU6cMGbrU1tVMoqLUuFG7OA5nBFDWteNfB/O7ic5ARwiRIlk9oKmSJgamNg +TnYGmE69g60dWIolhdLHZR4tjsbftsbhf4oEIRUpdPA+nJCdDC7xij5aqgwJHsfV +PKPtl8MeNPo4+QgO48BdK4PRVmrJtqhUUy54Mmc9gn900PvhtgVguXDbjgv5E1hv +cWAQUhC5wUEJ73IfZzF4/5YFjQIDAQABo2MwYTAfBgNVHSMEGDAWgBTj/i39KNAL +tbq2osS/BqoFjJP7LzAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAd +BgNVHQ4EFgQU4/4t/SjQC7W6tqLEvwaqBYyT+y8wDQYJKoZIhvcNAQELBQADggIB +ACXGumvrh8vegjmWPfBEp2uEcwPenStPuiB/vHiyz5ewG5zz13ku9Ui20vsXiObT +ej/tUxPQ4i9qecsAIyjmHjdXNYmEwnZPNDatZ8POQQaIxffu2Bq41gt/UP+TqhdL +jOztUmCypAbqTuv0axn96/Ua4CUqmtzHQTb3yHQFhDmVOdYLO6Qn+gjYXB74BGBS +ESgoA//vU2YApUo0FmZ8/Qmkrp5nGm9BC2sGE5uPhnEFtC+NiWYzKXZUmhH4J/qy +P5Hgzg0b8zAarb8iXRvTvyUFTeGSGn+ZnzxEk8rUQElsgIfXBDrDMlI1Dlb4pd19 +xIsNER9Tyx6yF7Zod1rg1MvIB671Oi6ON7fQAUtDKXeMOZePglr4UeWJoBjnaH9d +Ci77o0cOPaYjesYBx4/IXr9tgFa+iiS6M+qf4TIRnvHST4D2G0CvOJ4RUHlzEhLN +5mydLIhyPDCBBpEi6lmt2hkuIsKNuYyH4Ga8cyNfIWRjgEj1oDwYPZTISEEdQLpe +/v5WOaHIz16eGWRGENoXkbcFgKyLmZJ956LYBws2J+dIeWCKw9cTXPhyQN9Ky8+Z +AAoACxGV2lZFA4gKn2fQ1XmxqI1AbQ3CekD6819kR5LLU7m7Wc5P/dAVUwHY3+vZ +5nbv0CO7O6l5s9UCKc2Jo5YPSjXnTkLAdc0Hz+Ys63su +-----END CERTIFICATE----- + +# Issuer: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed +# Subject: CN=OISTE WISeKey Global Root GB CA O=WISeKey OU=OISTE Foundation Endorsed +# Label: "OISTE WISeKey Global Root GB CA" +# Serial: 157768595616588414422159278966750757568 +# MD5 Fingerprint: a4:eb:b9:61:28:2e:b7:2f:98:b0:35:26:90:99:51:1d +# SHA1 Fingerprint: 0f:f9:40:76:18:d3:d7:6a:4b:98:f0:a8:35:9e:0c:fd:27:ac:cc:ed +# SHA256 Fingerprint: 6b:9c:08:e8:6e:b0:f7:67:cf:ad:65:cd:98:b6:21:49:e5:49:4a:67:f5:84:5e:7b:d1:ed:01:9f:27:b8:6b:d6 +-----BEGIN CERTIFICATE----- +MIIDtTCCAp2gAwIBAgIQdrEgUnTwhYdGs/gjGvbCwDANBgkqhkiG9w0BAQsFADBt +MQswCQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUg +Rm91bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9i +YWwgUm9vdCBHQiBDQTAeFw0xNDEyMDExNTAwMzJaFw0zOTEyMDExNTEwMzFaMG0x +CzAJBgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBG +b3VuZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2Jh +bCBSb290IEdCIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2Be3 +HEokKtaXscriHvt9OO+Y9bI5mE4nuBFde9IllIiCFSZqGzG7qFshISvYD06fWvGx +WuR51jIjK+FTzJlFXHtPrby/h0oLS5daqPZI7H17Dc0hBt+eFf1Biki3IPShehtX +1F1Q/7pn2COZH8g/497/b1t3sWtuuMlk9+HKQUYOKXHQuSP8yYFfTvdv37+ErXNk +u7dCjmn21HYdfp2nuFeKUWdy19SouJVUQHMD9ur06/4oQnc/nSMbsrY9gBQHTC5P +99UKFg29ZkM3fiNDecNAhvVMKdqOmq0NpQSHiB6F4+lT1ZvIiwNjeOvgGUpuuy9r +M2RYk61pv48b74JIxwIDAQABo1EwTzALBgNVHQ8EBAMCAYYwDwYDVR0TAQH/BAUw +AwEB/zAdBgNVHQ4EFgQUNQ/INmNe4qPs+TtmFc5RUuORmj0wEAYJKwYBBAGCNxUB +BAMCAQAwDQYJKoZIhvcNAQELBQADggEBAEBM+4eymYGQfp3FsLAmzYh7KzKNbrgh +cViXfa43FK8+5/ea4n32cZiZBKpDdHij40lhPnOMTZTg+XHEthYOU3gf1qKHLwI5 +gSk8rxWYITD+KJAAjNHhy/peyP34EEY7onhCkRd0VQreUGdNZtGn//3ZwLWoo4rO +ZvUPQ82nK1d7Y0Zqqi5S2PTt4W2tKZB4SLrhI6qjiey1q5bAtEuiHZeeevJuQHHf +aPFlTc58Bd9TZaml8LGXBHAVRgOY1NK/VLSgWH1Sb9pWJmLU2NuJMW8c8CLC02Ic +Nc1MaRVUGpCY3useX8p3x8uOPUNpnJpY0CQ73xtAln41rYHHTnG6iBM= +-----END CERTIFICATE----- + +# Issuer: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A. +# Subject: CN=SZAFIR ROOT CA2 O=Krajowa Izba Rozliczeniowa S.A. +# Label: "SZAFIR ROOT CA2" +# Serial: 357043034767186914217277344587386743377558296292 +# MD5 Fingerprint: 11:64:c1:89:b0:24:b1:8c:b1:07:7e:89:9e:51:9e:99 +# SHA1 Fingerprint: e2:52:fa:95:3f:ed:db:24:60:bd:6e:28:f3:9c:cc:cf:5e:b3:3f:de +# SHA256 Fingerprint: a1:33:9d:33:28:1a:0b:56:e5:57:d3:d3:2b:1c:e7:f9:36:7e:b0:94:bd:5f:a7:2a:7e:50:04:c8:de:d7:ca:fe +-----BEGIN CERTIFICATE----- +MIIDcjCCAlqgAwIBAgIUPopdB+xV0jLVt+O2XwHrLdzk1uQwDQYJKoZIhvcNAQEL +BQAwUTELMAkGA1UEBhMCUEwxKDAmBgNVBAoMH0tyYWpvd2EgSXpiYSBSb3psaWN6 +ZW5pb3dhIFMuQS4xGDAWBgNVBAMMD1NaQUZJUiBST09UIENBMjAeFw0xNTEwMTkw +NzQzMzBaFw0zNTEwMTkwNzQzMzBaMFExCzAJBgNVBAYTAlBMMSgwJgYDVQQKDB9L +cmFqb3dhIEl6YmEgUm96bGljemVuaW93YSBTLkEuMRgwFgYDVQQDDA9TWkFGSVIg +Uk9PVCBDQTIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC3vD5QqEvN +QLXOYeeWyrSh2gwisPq1e3YAd4wLz32ohswmUeQgPYUM1ljj5/QqGJ3a0a4m7utT +3PSQ1hNKDJA8w/Ta0o4NkjrcsbH/ON7Dui1fgLkCvUqdGw+0w8LBZwPd3BucPbOw +3gAeqDRHu5rr/gsUvTaE2g0gv/pby6kWIK05YO4vdbbnl5z5Pv1+TW9NL++IDWr6 +3fE9biCloBK0TXC5ztdyO4mTp4CEHCdJckm1/zuVnsHMyAHs6A6KCpbns6aH5db5 +BSsNl0BwPLqsdVqc1U2dAgrSS5tmS0YHF2Wtn2yIANwiieDhZNRnvDF5YTy7ykHN +XGoAyDw4jlivAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQD +AgEGMB0GA1UdDgQWBBQuFqlKGLXLzPVvUPMjX/hd56zwyDANBgkqhkiG9w0BAQsF +AAOCAQEAtXP4A9xZWx126aMqe5Aosk3AM0+qmrHUuOQn/6mWmc5G4G18TKI4pAZw +8PRBEew/R40/cof5O/2kbytTAOD/OblqBw7rHRz2onKQy4I9EYKL0rufKq8h5mOG +nXkZ7/e7DDWQw4rtTw/1zBLZpD67oPwglV9PJi8RI4NOdQcPv5vRtB3pEAT+ymCP +oky4rc/hkA/NrgrHXXu3UNLUYfrVFdvXn4dRVOul4+vJhaAlIDf7js4MNIThPIGy +d05DpYhfhmehPea0XGG2Ptv+tyjFogeutcrKjSoS75ftwjCkySp6+/NNIxuZMzSg +LvWpCz/UXeHPhJ/iGcJfitYgHuNztw== +-----END CERTIFICATE----- + +# Issuer: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority +# Subject: CN=Certum Trusted Network CA 2 O=Unizeto Technologies S.A. OU=Certum Certification Authority +# Label: "Certum Trusted Network CA 2" +# Serial: 44979900017204383099463764357512596969 +# MD5 Fingerprint: 6d:46:9e:d9:25:6d:08:23:5b:5e:74:7d:1e:27:db:f2 +# SHA1 Fingerprint: d3:dd:48:3e:2b:bf:4c:05:e8:af:10:f5:fa:76:26:cf:d3:dc:30:92 +# SHA256 Fingerprint: b6:76:f2:ed:da:e8:77:5c:d3:6c:b0:f6:3c:d1:d4:60:39:61:f4:9e:62:65:ba:01:3a:2f:03:07:b6:d0:b8:04 +-----BEGIN CERTIFICATE----- +MIIF0jCCA7qgAwIBAgIQIdbQSk8lD8kyN/yqXhKN6TANBgkqhkiG9w0BAQ0FADCB +gDELMAkGA1UEBhMCUEwxIjAgBgNVBAoTGVVuaXpldG8gVGVjaG5vbG9naWVzIFMu +QS4xJzAlBgNVBAsTHkNlcnR1bSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTEkMCIG +A1UEAxMbQ2VydHVtIFRydXN0ZWQgTmV0d29yayBDQSAyMCIYDzIwMTExMDA2MDgz +OTU2WhgPMjA0NjEwMDYwODM5NTZaMIGAMQswCQYDVQQGEwJQTDEiMCAGA1UEChMZ +VW5pemV0byBUZWNobm9sb2dpZXMgUy5BLjEnMCUGA1UECxMeQ2VydHVtIENlcnRp +ZmljYXRpb24gQXV0aG9yaXR5MSQwIgYDVQQDExtDZXJ0dW0gVHJ1c3RlZCBOZXR3 +b3JrIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC9+Xj45tWA +DGSdhhuWZGc/IjoedQF97/tcZ4zJzFxrqZHmuULlIEub2pt7uZld2ZuAS9eEQCsn +0+i6MLs+CRqnSZXvK0AkwpfHp+6bJe+oCgCXhVqqndwpyeI1B+twTUrWwbNWuKFB +OJvR+zF/j+Bf4bE/D44WSWDXBo0Y+aomEKsq09DRZ40bRr5HMNUuctHFY9rnY3lE +fktjJImGLjQ/KUxSiyqnwOKRKIm5wFv5HdnnJ63/mgKXwcZQkpsCLL2puTRZCr+E +Sv/f/rOf69me4Jgj7KZrdxYq28ytOxykh9xGc14ZYmhFV+SQgkK7QtbwYeDBoz1m +o130GO6IyY0XRSmZMnUCMe4pJshrAua1YkV/NxVaI2iJ1D7eTiew8EAMvE0Xy02i +sx7QBlrd9pPPV3WZ9fqGGmd4s7+W/jTcvedSVuWz5XV710GRBdxdaeOVDUO5/IOW +OZV7bIBaTxNyxtd9KXpEulKkKtVBRgkg/iKgtlswjbyJDNXXcPiHUv3a76xRLgez +Tv7QCdpw75j6VuZt27VXS9zlLCUVyJ4ueE742pyehizKV/Ma5ciSixqClnrDvFAS +adgOWkaLOusm+iPJtrCBvkIApPjW/jAux9JG9uWOdf3yzLnQh1vMBhBgu4M1t15n +3kfsmUjxpKEV/q2MYo45VU85FrmxY53/twIDAQABo0IwQDAPBgNVHRMBAf8EBTAD +AQH/MB0GA1UdDgQWBBS2oVQ5AsOgP46KvPrU+Bym0ToO/TAOBgNVHQ8BAf8EBAMC +AQYwDQYJKoZIhvcNAQENBQADggIBAHGlDs7k6b8/ONWJWsQCYftMxRQXLYtPU2sQ +F/xlhMcQSZDe28cmk4gmb3DWAl45oPePq5a1pRNcgRRtDoGCERuKTsZPpd1iHkTf +CVn0W3cLN+mLIMb4Ck4uWBzrM9DPhmDJ2vuAL55MYIR4PSFk1vtBHxgP58l1cb29 +XN40hz5BsA72udY/CROWFC/emh1auVbONTqwX3BNXuMp8SMoclm2q8KMZiYcdywm +djWLKKdpoPk79SPdhRB0yZADVpHnr7pH1BKXESLjokmUbOe3lEu6LaTaM4tMpkT/ +WjzGHWTYtTHkpjx6qFcL2+1hGsvxznN3Y6SHb0xRONbkX8eftoEq5IVIeVheO/jb +AoJnwTnbw3RLPTYe+SmTiGhbqEQZIfCn6IENLOiTNrQ3ssqwGyZ6miUfmpqAnksq +P/ujmv5zMnHCnsZy4YpoJ/HkD7TETKVhk/iXEAcqMCWpuchxuO9ozC1+9eB+D4Ko +b7a6bINDd82Kkhehnlt4Fj1F4jNy3eFmypnTycUm/Q1oBEauttmbjL4ZvrHG8hnj +XALKLNhvSgfZyTXaQHXyxKcZb55CEJh15pWLYLztxRLXis7VmFxWlgPF7ncGNf/P +5O4/E2Hu29othfDNrp2yGAlFw5Khchf8R7agCyzxxN5DaAhqXzvwdmP7zAYspsbi +DrW5viSP +-----END CERTIFICATE----- + +# Issuer: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority +# Subject: CN=Hellenic Academic and Research Institutions RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority +# Label: "Hellenic Academic and Research Institutions RootCA 2015" +# Serial: 0 +# MD5 Fingerprint: ca:ff:e2:db:03:d9:cb:4b:e9:0f:ad:84:fd:7b:18:ce +# SHA1 Fingerprint: 01:0c:06:95:a6:98:19:14:ff:bf:5f:c6:b0:b6:95:ea:29:e9:12:a6 +# SHA256 Fingerprint: a0:40:92:9a:02:ce:53:b4:ac:f4:f2:ff:c6:98:1c:e4:49:6f:75:5e:6d:45:fe:0b:2a:69:2b:cd:52:52:3f:36 +-----BEGIN CERTIFICATE----- +MIIGCzCCA/OgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBpjELMAkGA1UEBhMCR1Ix +DzANBgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5k +IFJlc2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxQDA+BgNVBAMT +N0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgUm9v +dENBIDIwMTUwHhcNMTUwNzA3MTAxMTIxWhcNNDAwNjMwMTAxMTIxWjCBpjELMAkG +A1UEBhMCR1IxDzANBgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNh +ZGVtaWMgYW5kIFJlc2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkx +QDA+BgNVBAMTN0hlbGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1 +dGlvbnMgUm9vdENBIDIwMTUwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC +AQDC+Kk/G4n8PDwEXT2QNrCROnk8ZlrvbTkBSRq0t89/TSNTt5AA4xMqKKYx8ZEA +4yjsriFBzh/a/X0SWwGDD7mwX5nh8hKDgE0GPt+sr+ehiGsxr/CL0BgzuNtFajT0 +AoAkKAoCFZVedioNmToUW/bLy1O8E00BiDeUJRtCvCLYjqOWXjrZMts+6PAQZe10 +4S+nfK8nNLspfZu2zwnI5dMK/IhlZXQK3HMcXM1AsRzUtoSMTFDPaI6oWa7CJ06C +ojXdFPQf/7J31Ycvqm59JCfnxssm5uX+Zwdj2EUN3TpZZTlYepKZcj2chF6IIbjV +9Cz82XBST3i4vTwri5WY9bPRaM8gFH5MXF/ni+X1NYEZN9cRCLdmvtNKzoNXADrD +gfgXy5I2XdGj2HUb4Ysn6npIQf1FGQatJ5lOwXBH3bWfgVMS5bGMSF0xQxfjjMZ6 +Y5ZLKTBOhE5iGV48zpeQpX8B653g+IuJ3SWYPZK2fu/Z8VFRfS0myGlZYeCsargq +NhEEelC9MoS+L9xy1dcdFkfkR2YgP/SWxa+OAXqlD3pk9Q0Yh9muiNX6hME6wGko +LfINaFGq46V3xqSQDqE3izEjR8EJCOtu93ib14L8hCCZSRm2Ekax+0VVFqmjZayc +Bw/qa9wfLgZy7IaIEuQt218FL+TwA9MmM+eAws1CoRc0CwIDAQABo0IwQDAPBgNV +HRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUcRVnyMjJvXVd +ctA4GGqd83EkVAswDQYJKoZIhvcNAQELBQADggIBAHW7bVRLqhBYRjTyYtcWNl0I +XtVsyIe9tC5G8jH4fOpCtZMWVdyhDBKg2mF+D1hYc2Ryx+hFjtyp8iY/xnmMsVMI +M4GwVhO+5lFc2JsKT0ucVlMC6U/2DWDqTUJV6HwbISHTGzrMd/K4kPFox/la/vot +9L/J9UUbzjgQKjeKeaO04wlshYaT/4mWJ3iBj2fjRnRUjtkNaeJK9E10A/+yd+2V +Z5fkscWrv2oj6NSU4kQoYsRL4vDY4ilrGnB+JGGTe08DMiUNRSQrlrRGar9KC/ea +j8GsGsVn82800vpzY4zvFrCopEYq+OsS7HK07/grfoxSwIuEVPkvPuNVqNxmsdnh +X9izjFk0WaSrT2y7HxjbdavYy5LNlDhhDgcGH0tGEPEVvo2FXDtKK4F5D7Rpn0lQ +l033DlZdwJVqwjbDG2jJ9SrcR5q+ss7FJej6A7na+RZukYT1HCjI/CbM1xyQVqdf +bzoEvM14iQuODy+jqk+iGxI9FghAD/FGTNeqewjBCvVtJ94Cj8rDtSvK6evIIVM4 +pcw72Hc3MKJP2W/R8kCtQXoXxdZKNYm3QdV8hn9VTYNKpXMgwDqvkPGaJI7ZjnHK +e7iG2rKPmT4dEw0SEe7Uq/DpFXYC5ODfqiAeW2GFZECpkJcNrVPSWh2HagCXZWK0 +vm9qp/UsQu0yrbYhnr68 +-----END CERTIFICATE----- + +# Issuer: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority +# Subject: CN=Hellenic Academic and Research Institutions ECC RootCA 2015 O=Hellenic Academic and Research Institutions Cert. Authority +# Label: "Hellenic Academic and Research Institutions ECC RootCA 2015" +# Serial: 0 +# MD5 Fingerprint: 81:e5:b4:17:eb:c2:f5:e1:4b:0d:41:7b:49:92:fe:ef +# SHA1 Fingerprint: 9f:f1:71:8d:92:d5:9a:f3:7d:74:97:b4:bc:6f:84:68:0b:ba:b6:66 +# SHA256 Fingerprint: 44:b5:45:aa:8a:25:e6:5a:73:ca:15:dc:27:fc:36:d2:4c:1c:b9:95:3a:06:65:39:b1:15:82:dc:48:7b:48:33 +-----BEGIN CERTIFICATE----- +MIICwzCCAkqgAwIBAgIBADAKBggqhkjOPQQDAjCBqjELMAkGA1UEBhMCR1IxDzAN +BgNVBAcTBkF0aGVuczFEMEIGA1UEChM7SGVsbGVuaWMgQWNhZGVtaWMgYW5kIFJl +c2VhcmNoIEluc3RpdHV0aW9ucyBDZXJ0LiBBdXRob3JpdHkxRDBCBgNVBAMTO0hl +bGxlbmljIEFjYWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgRUNDIFJv +b3RDQSAyMDE1MB4XDTE1MDcwNzEwMzcxMloXDTQwMDYzMDEwMzcxMlowgaoxCzAJ +BgNVBAYTAkdSMQ8wDQYDVQQHEwZBdGhlbnMxRDBCBgNVBAoTO0hlbGxlbmljIEFj +YWRlbWljIGFuZCBSZXNlYXJjaCBJbnN0aXR1dGlvbnMgQ2VydC4gQXV0aG9yaXR5 +MUQwQgYDVQQDEztIZWxsZW5pYyBBY2FkZW1pYyBhbmQgUmVzZWFyY2ggSW5zdGl0 +dXRpb25zIEVDQyBSb290Q0EgMjAxNTB2MBAGByqGSM49AgEGBSuBBAAiA2IABJKg +QehLgoRc4vgxEZmGZE4JJS+dQS8KrjVPdJWyUWRrjWvmP3CV8AVER6ZyOFB2lQJa +jq4onvktTpnvLEhvTCUp6NFxW98dwXU3tNf6e3pCnGoKVlp8aQuqgAkkbH7BRqNC +MEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFLQi +C4KZJAEOnLvkDv2/+5cgk5kqMAoGCCqGSM49BAMCA2cAMGQCMGfOFmI4oqxiRaep +lSTAGiecMjvAwNW6qef4BENThe5SId6d9SWDPp5YSy/XZxMOIQIwBeF1Ad5o7Sof +TUwJCA3sS61kFyjndc5FZXIhF8siQQ6ME5g4mlRtm8rifOoCWCKR +-----END CERTIFICATE----- + +# Issuer: CN=ISRG Root X1 O=Internet Security Research Group +# Subject: CN=ISRG Root X1 O=Internet Security Research Group +# Label: "ISRG Root X1" +# Serial: 172886928669790476064670243504169061120 +# MD5 Fingerprint: 0c:d2:f9:e0:da:17:73:e9:ed:86:4d:a5:e3:70:e7:4e +# SHA1 Fingerprint: ca:bd:2a:79:a1:07:6a:31:f2:1d:25:36:35:cb:03:9d:43:29:a5:e8 +# SHA256 Fingerprint: 96:bc:ec:06:26:49:76:f3:74:60:77:9a:cf:28:c5:a7:cf:e8:a3:c0:aa:e1:1a:8f:fc:ee:05:c0:bd:df:08:c6 +-----BEGIN CERTIFICATE----- +MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw +TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh +cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4 +WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu +ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY +MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc +h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+ +0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U +A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW +T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH +B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC +B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv +KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn +OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn +jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw +qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI +rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV +HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq +hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL +ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ +3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK +NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5 +ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur +TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC +jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc +oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq +4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA +mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d +emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc= +-----END CERTIFICATE----- + +# Issuer: O=FNMT-RCM OU=AC RAIZ FNMT-RCM +# Subject: O=FNMT-RCM OU=AC RAIZ FNMT-RCM +# Label: "AC RAIZ FNMT-RCM" +# Serial: 485876308206448804701554682760554759 +# MD5 Fingerprint: e2:09:04:b4:d3:bd:d1:a0:14:fd:1a:d2:47:c4:57:1d +# SHA1 Fingerprint: ec:50:35:07:b2:15:c4:95:62:19:e2:a8:9a:5b:42:99:2c:4c:2c:20 +# SHA256 Fingerprint: eb:c5:57:0c:29:01:8c:4d:67:b1:aa:12:7b:af:12:f7:03:b4:61:1e:bc:17:b7:da:b5:57:38:94:17:9b:93:fa +-----BEGIN CERTIFICATE----- +MIIFgzCCA2ugAwIBAgIPXZONMGc2yAYdGsdUhGkHMA0GCSqGSIb3DQEBCwUAMDsx +CzAJBgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJ +WiBGTk1ULVJDTTAeFw0wODEwMjkxNTU5NTZaFw0zMDAxMDEwMDAwMDBaMDsxCzAJ +BgNVBAYTAkVTMREwDwYDVQQKDAhGTk1ULVJDTTEZMBcGA1UECwwQQUMgUkFJWiBG +Tk1ULVJDTTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBALpxgHpMhm5/ +yBNtwMZ9HACXjywMI7sQmkCpGreHiPibVmr75nuOi5KOpyVdWRHbNi63URcfqQgf +BBckWKo3Shjf5TnUV/3XwSyRAZHiItQDwFj8d0fsjz50Q7qsNI1NOHZnjrDIbzAz +WHFctPVrbtQBULgTfmxKo0nRIBnuvMApGGWn3v7v3QqQIecaZ5JCEJhfTzC8PhxF +tBDXaEAUwED653cXeuYLj2VbPNmaUtu1vZ5Gzz3rkQUCwJaydkxNEJY7kvqcfw+Z +374jNUUeAlz+taibmSXaXvMiwzn15Cou08YfxGyqxRxqAQVKL9LFwag0Jl1mpdIC +IfkYtwb1TplvqKtMUejPUBjFd8g5CSxJkjKZqLsXF3mwWsXmo8RZZUc1g16p6DUL +mbvkzSDGm0oGObVo/CK67lWMK07q87Hj/LaZmtVC+nFNCM+HHmpxffnTtOmlcYF7 +wk5HlqX2doWjKI/pgG6BU6VtX7hI+cL5NqYuSf+4lsKMB7ObiFj86xsc3i1w4peS +MKGJ47xVqCfWS+2QrYv6YyVZLag13cqXM7zlzced0ezvXg5KkAYmY6252TUtB7p2 +ZSysV4999AeU14ECll2jB0nVetBX+RvnU0Z1qrB5QstocQjpYL05ac70r8NWQMet +UqIJ5G+GR4of6ygnXYMgrwTJbFaai0b1AgMBAAGjgYMwgYAwDwYDVR0TAQH/BAUw +AwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFPd9xf3E6Jobd2Sn9R2gzL+H +YJptMD4GA1UdIAQ3MDUwMwYEVR0gADArMCkGCCsGAQUFBwIBFh1odHRwOi8vd3d3 +LmNlcnQuZm5tdC5lcy9kcGNzLzANBgkqhkiG9w0BAQsFAAOCAgEAB5BK3/MjTvDD +nFFlm5wioooMhfNzKWtN/gHiqQxjAb8EZ6WdmF/9ARP67Jpi6Yb+tmLSbkyU+8B1 +RXxlDPiyN8+sD8+Nb/kZ94/sHvJwnvDKuO+3/3Y3dlv2bojzr2IyIpMNOmqOFGYM +LVN0V2Ue1bLdI4E7pWYjJ2cJj+F3qkPNZVEI7VFY/uY5+ctHhKQV8Xa7pO6kO8Rf +77IzlhEYt8llvhjho6Tc+hj507wTmzl6NLrTQfv6MooqtyuGC2mDOL7Nii4LcK2N +JpLuHvUBKwrZ1pebbuCoGRw6IYsMHkCtA+fdZn71uSANA+iW+YJF1DngoABd15jm +fZ5nc8OaKveri6E6FO80vFIOiZiaBECEHX5FaZNXzuvO+FB8TxxuBEOb+dY7Ixjp +6o7RTUaN8Tvkasq6+yO3m/qZASlaWFot4/nUbQ4mrcFuNLwy+AwF+mWj2zs3gyLp +1txyM/1d8iC9djwj2ij3+RvrWWTV3F9yfiD8zYm1kGdNYno/Tq0dwzn+evQoFt9B +9kiABdcPUXmsEKvU7ANm5mqwujGSQkBqvjrTcuFqN1W8rB2Vt2lh8kORdOag0wok +RqEIr9baRRmW1FMdW4R58MD3R++Lj8UGrp1MYp3/RgT408m2ECVAdf4WqslKYIYv +uu8wd+RU4riEmViAqhOLUTpPSPaLtrM= +-----END CERTIFICATE----- + +# Issuer: CN=Amazon Root CA 1 O=Amazon +# Subject: CN=Amazon Root CA 1 O=Amazon +# Label: "Amazon Root CA 1" +# Serial: 143266978916655856878034712317230054538369994 +# MD5 Fingerprint: 43:c6:bf:ae:ec:fe:ad:2f:18:c6:88:68:30:fc:c8:e6 +# SHA1 Fingerprint: 8d:a7:f9:65:ec:5e:fc:37:91:0f:1c:6e:59:fd:c1:cc:6a:6e:de:16 +# SHA256 Fingerprint: 8e:cd:e6:88:4f:3d:87:b1:12:5b:a3:1a:c3:fc:b1:3d:70:16:de:7f:57:cc:90:4f:e1:cb:97:c6:ae:98:19:6e +-----BEGIN CERTIFICATE----- +MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF +ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6 +b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL +MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv +b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj +ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM +9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw +IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6 +VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L +93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm +jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC +AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA +A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI +U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs +N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv +o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU +5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy +rqXRfboQnoZsG4q5WTP468SQvvG5 +-----END CERTIFICATE----- + +# Issuer: CN=Amazon Root CA 2 O=Amazon +# Subject: CN=Amazon Root CA 2 O=Amazon +# Label: "Amazon Root CA 2" +# Serial: 143266982885963551818349160658925006970653239 +# MD5 Fingerprint: c8:e5:8d:ce:a8:42:e2:7a:c0:2a:5c:7c:9e:26:bf:66 +# SHA1 Fingerprint: 5a:8c:ef:45:d7:a6:98:59:76:7a:8c:8b:44:96:b5:78:cf:47:4b:1a +# SHA256 Fingerprint: 1b:a5:b2:aa:8c:65:40:1a:82:96:01:18:f8:0b:ec:4f:62:30:4d:83:ce:c4:71:3a:19:c3:9c:01:1e:a4:6d:b4 +-----BEGIN CERTIFICATE----- +MIIFQTCCAymgAwIBAgITBmyf0pY1hp8KD+WGePhbJruKNzANBgkqhkiG9w0BAQwF +ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6 +b24gUm9vdCBDQSAyMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTEL +MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv +b3QgQ0EgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK2Wny2cSkxK +gXlRmeyKy2tgURO8TW0G/LAIjd0ZEGrHJgw12MBvIITplLGbhQPDW9tK6Mj4kHbZ +W0/jTOgGNk3Mmqw9DJArktQGGWCsN0R5hYGCrVo34A3MnaZMUnbqQ523BNFQ9lXg +1dKmSYXpN+nKfq5clU1Imj+uIFptiJXZNLhSGkOQsL9sBbm2eLfq0OQ6PBJTYv9K +8nu+NQWpEjTj82R0Yiw9AElaKP4yRLuH3WUnAnE72kr3H9rN9yFVkE8P7K6C4Z9r +2UXTu/Bfh+08LDmG2j/e7HJV63mjrdvdfLC6HM783k81ds8P+HgfajZRRidhW+me +z/CiVX18JYpvL7TFz4QuK/0NURBs+18bvBt+xa47mAExkv8LV/SasrlX6avvDXbR +8O70zoan4G7ptGmh32n2M8ZpLpcTnqWHsFcQgTfJU7O7f/aS0ZzQGPSSbtqDT6Zj +mUyl+17vIWR6IF9sZIUVyzfpYgwLKhbcAS4y2j5L9Z469hdAlO+ekQiG+r5jqFoz +7Mt0Q5X5bGlSNscpb/xVA1wf+5+9R+vnSUeVC06JIglJ4PVhHvG/LopyboBZ/1c6 ++XUyo05f7O0oYtlNc/LMgRdg7c3r3NunysV+Ar3yVAhU/bQtCSwXVEqY0VThUWcI +0u1ufm8/0i2BWSlmy5A5lREedCf+3euvAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB +Af8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSwDPBMMPQFWAJI/TPlUq9LhONm +UjANBgkqhkiG9w0BAQwFAAOCAgEAqqiAjw54o+Ci1M3m9Zh6O+oAA7CXDpO8Wqj2 +LIxyh6mx/H9z/WNxeKWHWc8w4Q0QshNabYL1auaAn6AFC2jkR2vHat+2/XcycuUY ++gn0oJMsXdKMdYV2ZZAMA3m3MSNjrXiDCYZohMr/+c8mmpJ5581LxedhpxfL86kS +k5Nrp+gvU5LEYFiwzAJRGFuFjWJZY7attN6a+yb3ACfAXVU3dJnJUH/jWS5E4ywl +7uxMMne0nxrpS10gxdr9HIcWxkPo1LsmmkVwXqkLN1PiRnsn/eBG8om3zEK2yygm +btmlyTrIQRNg91CMFa6ybRoVGld45pIq2WWQgj9sAq+uEjonljYE1x2igGOpm/Hl +urR8FLBOybEfdF849lHqm/osohHUqS0nGkWxr7JOcQ3AWEbWaQbLU8uz/mtBzUF+ +fUwPfHJ5elnNXkoOrJupmHN5fLT0zLm4BwyydFy4x2+IoZCn9Kr5v2c69BoVYh63 +n749sSmvZ6ES8lgQGVMDMBu4Gon2nL2XA46jCfMdiyHxtN/kHNGfZQIG6lzWE7OE +76KlXIx3KadowGuuQNKotOrN8I1LOJwZmhsoVLiJkO/KdYE+HvJkJMcYr07/R54H +9jVlpNMKVv/1F2Rs76giJUmTtt8AF9pYfl3uxRuw0dFfIRDH+fO6AgonB8Xx1sfT +4PsJYGw= +-----END CERTIFICATE----- + +# Issuer: CN=Amazon Root CA 3 O=Amazon +# Subject: CN=Amazon Root CA 3 O=Amazon +# Label: "Amazon Root CA 3" +# Serial: 143266986699090766294700635381230934788665930 +# MD5 Fingerprint: a0:d4:ef:0b:f7:b5:d8:49:95:2a:ec:f5:c4:fc:81:87 +# SHA1 Fingerprint: 0d:44:dd:8c:3c:8c:1a:1a:58:75:64:81:e9:0f:2e:2a:ff:b3:d2:6e +# SHA256 Fingerprint: 18:ce:6c:fe:7b:f1:4e:60:b2:e3:47:b8:df:e8:68:cb:31:d0:2e:bb:3a:da:27:15:69:f5:03:43:b4:6d:b3:a4 +-----BEGIN CERTIFICATE----- +MIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5 +MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g +Um9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG +A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg +Q0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl +ui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j +QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr +ttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr +BqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM +YyRIHN8wfdVoOw== +-----END CERTIFICATE----- + +# Issuer: CN=Amazon Root CA 4 O=Amazon +# Subject: CN=Amazon Root CA 4 O=Amazon +# Label: "Amazon Root CA 4" +# Serial: 143266989758080763974105200630763877849284878 +# MD5 Fingerprint: 89:bc:27:d5:eb:17:8d:06:6a:69:d5:fd:89:47:b4:cd +# SHA1 Fingerprint: f6:10:84:07:d6:f8:bb:67:98:0c:c2:e2:44:c2:eb:ae:1c:ef:63:be +# SHA256 Fingerprint: e3:5d:28:41:9e:d0:20:25:cf:a6:90:38:cd:62:39:62:45:8d:a5:c6:95:fb:de:a3:c2:2b:0b:fb:25:89:70:92 +-----BEGIN CERTIFICATE----- +MIIB8jCCAXigAwIBAgITBmyf18G7EEwpQ+Vxe3ssyBrBDjAKBggqhkjOPQQDAzA5 +MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g +Um9vdCBDQSA0MB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG +A1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg +Q0EgNDB2MBAGByqGSM49AgEGBSuBBAAiA2IABNKrijdPo1MN/sGKe0uoe0ZLY7Bi +9i0b2whxIdIA6GO9mif78DluXeo9pcmBqqNbIJhFXRbb/egQbeOc4OO9X4Ri83Bk +M6DLJC9wuoihKqB1+IGuYgbEgds5bimwHvouXKNCMEAwDwYDVR0TAQH/BAUwAwEB +/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFNPsxzplbszh2naaVvuc84ZtV+WB +MAoGCCqGSM49BAMDA2gAMGUCMDqLIfG9fhGt0O9Yli/W651+kI0rz2ZVwyzjKKlw +CkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW +1KyLa2tJElMzrdfkviT8tQp21KW8EA== +-----END CERTIFICATE----- + +# Issuer: CN=LuxTrust Global Root 2 O=LuxTrust S.A. +# Subject: CN=LuxTrust Global Root 2 O=LuxTrust S.A. +# Label: "LuxTrust Global Root 2" +# Serial: 59914338225734147123941058376788110305822489521 +# MD5 Fingerprint: b2:e1:09:00:61:af:f7:f1:91:6f:c4:ad:8d:5e:3b:7c +# SHA1 Fingerprint: 1e:0e:56:19:0a:d1:8b:25:98:b2:04:44:ff:66:8a:04:17:99:5f:3f +# SHA256 Fingerprint: 54:45:5f:71:29:c2:0b:14:47:c4:18:f9:97:16:8f:24:c5:8f:c5:02:3b:f5:da:5b:e2:eb:6e:1d:d8:90:2e:d5 +-----BEGIN CERTIFICATE----- +MIIFwzCCA6ugAwIBAgIUCn6m30tEntpqJIWe5rgV0xZ/u7EwDQYJKoZIhvcNAQEL +BQAwRjELMAkGA1UEBhMCTFUxFjAUBgNVBAoMDUx1eFRydXN0IFMuQS4xHzAdBgNV +BAMMFkx1eFRydXN0IEdsb2JhbCBSb290IDIwHhcNMTUwMzA1MTMyMTU3WhcNMzUw +MzA1MTMyMTU3WjBGMQswCQYDVQQGEwJMVTEWMBQGA1UECgwNTHV4VHJ1c3QgUy5B +LjEfMB0GA1UEAwwWTHV4VHJ1c3QgR2xvYmFsIFJvb3QgMjCCAiIwDQYJKoZIhvcN +AQEBBQADggIPADCCAgoCggIBANeFl78RmOnwYoNMPIf5U2o3C/IPPIfOb9wmKb3F +ibrJgz337spbxm1Jc7TJRqMbNBM/wYlFV/TZsfs2ZUv7COJIcRHIbjuend+JZTem +hfY7RBi2xjcwYkSSl2l9QjAk5A0MiWtj3sXh306pFGxT4GHO9hcvHTy95iJMHZP1 +EMShduxq3sVs35a0VkBCwGKSMKEtFZSg0iAGCW5qbeXrt77U8PEVfIvmTroTzEsn +Xpk8F12PgX8zPU/TPxvsXD/wPEx1bvKm1Z3aLQdjAsZy6ZS8TEmVT4hSyNvoaYL4 +zDRbIvCGp4m9SAptZoFtyMhk+wHh9OHe2Z7d21vUKpkmFRseTJIpgp7VkoGSQXAZ +96Tlk0u8d2cx3Rz9MXANF5kM+Qw5GSoXtTBxVdUPrljhPS80m8+f9niFwpN6cj5m +j5wWEWCPnolvZ77gR1o7DJpni89Gxq44o/KnvObWhWszJHAiS8sIm7vI+AIpHb4g +DEa/a4ebsypmQjVGbKq6rfmYe+lQVRQxv7HaLe2ArWgk+2mr2HETMOZns4dA/Yl+ +8kPREd8vZS9kzl8UubG/Mb2HeFpZZYiq/FkySIbWTLkpS5XTdvN3JW1CHDiDTf2j +X5t/Lax5Gw5CMZdjpPuKadUiDTSQMC6otOBttpSsvItO13D8xTiOZCXhTTmQzsmH +hFhxAgMBAAGjgagwgaUwDwYDVR0TAQH/BAUwAwEB/zBCBgNVHSAEOzA5MDcGByuB +KwEBAQowLDAqBggrBgEFBQcCARYeaHR0cHM6Ly9yZXBvc2l0b3J5Lmx1eHRydXN0 +Lmx1MA4GA1UdDwEB/wQEAwIBBjAfBgNVHSMEGDAWgBT/GCh2+UgFLKGu8SsbK7JT ++Et8szAdBgNVHQ4EFgQU/xgodvlIBSyhrvErGyuyU/hLfLMwDQYJKoZIhvcNAQEL +BQADggIBAGoZFO1uecEsh9QNcH7X9njJCwROxLHOk3D+sFTAMs2ZMGQXvw/l4jP9 +BzZAcg4atmpZ1gDlaCDdLnINH2pkMSCEfUmmWjfrRcmF9dTHF5kH5ptV5AzoqbTO +jFu1EVzPig4N1qx3gf4ynCSecs5U89BvolbW7MM3LGVYvlcAGvI1+ut7MV3CwRI9 +loGIlonBWVx65n9wNOeD4rHh4bhY79SV5GCc8JaXcozrhAIuZY+kt9J/Z93I055c +qqmkoCUUBpvsT34tC38ddfEz2O3OuHVtPlu5mB0xDVbYQw8wkbIEa91WvpWAVWe+ +2M2D2RjuLg+GLZKecBPs3lHJQ3gCpU3I+V/EkVhGFndadKpAvAefMLmx9xIX3eP/ +JEAdemrRTxgKqpAd60Ae36EeRJIQmvKN4dFLRp7oRUKX6kWZ8+xm1QL68qZKJKre +zrnK+T+Tb/mjuuqlPpmt/f97mfVl7vBZKGfXkJWkE4SphMHozs51k2MavDzq1WQf +LSoSOcbDWjLtR5EWDrw4wVDej8oqkDQc7kGUnF4ZLvhFSZl0kbAEb+MEWrGrKqv+ +x9CWttrhSmQGbmBNvUJO/3jaJMobtNeWOWyu8Q6qp31IiyBMz2TWuJdGsE7RKlY6 +oJO9r4Ak4Ap+58rVyuiFVdw2KuGUaJPHZnJED4AhMmwlxyOAgwrr +-----END CERTIFICATE----- + +# Issuer: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM +# Subject: CN=TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1 O=Turkiye Bilimsel ve Teknolojik Arastirma Kurumu - TUBITAK OU=Kamu Sertifikasyon Merkezi - Kamu SM +# Label: "TUBITAK Kamu SM SSL Kok Sertifikasi - Surum 1" +# Serial: 1 +# MD5 Fingerprint: dc:00:81:dc:69:2f:3e:2f:b0:3b:f6:3d:5a:91:8e:49 +# SHA1 Fingerprint: 31:43:64:9b:ec:ce:27:ec:ed:3a:3f:0b:8f:0d:e4:e8:91:dd:ee:ca +# SHA256 Fingerprint: 46:ed:c3:68:90:46:d5:3a:45:3f:b3:10:4a:b8:0d:ca:ec:65:8b:26:60:ea:16:29:dd:7e:86:79:90:64:87:16 +-----BEGIN CERTIFICATE----- +MIIEYzCCA0ugAwIBAgIBATANBgkqhkiG9w0BAQsFADCB0jELMAkGA1UEBhMCVFIx +GDAWBgNVBAcTD0dlYnplIC0gS29jYWVsaTFCMEAGA1UEChM5VHVya2l5ZSBCaWxp +bXNlbCB2ZSBUZWtub2xvamlrIEFyYXN0aXJtYSBLdXJ1bXUgLSBUVUJJVEFLMS0w +KwYDVQQLEyRLYW11IFNlcnRpZmlrYXN5b24gTWVya2V6aSAtIEthbXUgU00xNjA0 +BgNVBAMTLVRVQklUQUsgS2FtdSBTTSBTU0wgS29rIFNlcnRpZmlrYXNpIC0gU3Vy +dW0gMTAeFw0xMzExMjUwODI1NTVaFw00MzEwMjUwODI1NTVaMIHSMQswCQYDVQQG +EwJUUjEYMBYGA1UEBxMPR2ViemUgLSBLb2NhZWxpMUIwQAYDVQQKEzlUdXJraXll +IEJpbGltc2VsIHZlIFRla25vbG9qaWsgQXJhc3Rpcm1hIEt1cnVtdSAtIFRVQklU +QUsxLTArBgNVBAsTJEthbXUgU2VydGlmaWthc3lvbiBNZXJrZXppIC0gS2FtdSBT +TTE2MDQGA1UEAxMtVFVCSVRBSyBLYW11IFNNIFNTTCBLb2sgU2VydGlmaWthc2kg +LSBTdXJ1bSAxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAr3UwM6q7 +a9OZLBI3hNmNe5eA027n/5tQlT6QlVZC1xl8JoSNkvoBHToP4mQ4t4y86Ij5iySr +LqP1N+RAjhgleYN1Hzv/bKjFxlb4tO2KRKOrbEz8HdDc72i9z+SqzvBV96I01INr +N3wcwv61A+xXzry0tcXtAA9TNypN9E8Mg/uGz8v+jE69h/mniyFXnHrfA2eJLJ2X +YacQuFWQfw4tJzh03+f92k4S400VIgLI4OD8D62K18lUUMw7D8oWgITQUVbDjlZ/ +iSIzL+aFCr2lqBs23tPcLG07xxO9WSMs5uWk99gL7eqQQESolbuT1dCANLZGeA4f +AJNG4e7p+exPFwIDAQABo0IwQDAdBgNVHQ4EFgQUZT/HiobGPN08VFw1+DrtUgxH +V8gwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL +BQADggEBACo/4fEyjq7hmFxLXs9rHmoJ0iKpEsdeV31zVmSAhHqT5Am5EM2fKifh +AHe+SMg1qIGf5LgsyX8OsNJLN13qudULXjS99HMpw+0mFZx+CFOKWI3QSyjfwbPf +IPP54+M638yclNhOT8NrF7f3cuitZjO1JVOr4PhMqZ398g26rrnZqsZr+ZO7rqu4 +lzwDGrpDxpa5RXI4s6ehlj2Re37AIVNMh+3yC1SVUZPVIqUNivGTDj5UDrDYyU7c +8jEyVupk+eq1nRZmQnLzf9OxMUP8pI4X8W0jq5Rm+K37DwhuJi1/FwcJsoz7UMCf +lo3Ptv0AnVoUmr8CRPXBwp8iXqIPoeM= +-----END CERTIFICATE----- + +# Issuer: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD. +# Subject: CN=GDCA TrustAUTH R5 ROOT O=GUANG DONG CERTIFICATE AUTHORITY CO.,LTD. +# Label: "GDCA TrustAUTH R5 ROOT" +# Serial: 9009899650740120186 +# MD5 Fingerprint: 63:cc:d9:3d:34:35:5c:6f:53:a3:e2:08:70:48:1f:b4 +# SHA1 Fingerprint: 0f:36:38:5b:81:1a:25:c3:9b:31:4e:83:ca:e9:34:66:70:cc:74:b4 +# SHA256 Fingerprint: bf:ff:8f:d0:44:33:48:7d:6a:8a:a6:0c:1a:29:76:7a:9f:c2:bb:b0:5e:42:0f:71:3a:13:b9:92:89:1d:38:93 +-----BEGIN CERTIFICATE----- +MIIFiDCCA3CgAwIBAgIIfQmX/vBH6nowDQYJKoZIhvcNAQELBQAwYjELMAkGA1UE +BhMCQ04xMjAwBgNVBAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZ +IENPLixMVEQuMR8wHQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMB4XDTE0 +MTEyNjA1MTMxNVoXDTQwMTIzMTE1NTk1OVowYjELMAkGA1UEBhMCQ04xMjAwBgNV +BAoMKUdVQU5HIERPTkcgQ0VSVElGSUNBVEUgQVVUSE9SSVRZIENPLixMVEQuMR8w +HQYDVQQDDBZHRENBIFRydXN0QVVUSCBSNSBST09UMIICIjANBgkqhkiG9w0BAQEF +AAOCAg8AMIICCgKCAgEA2aMW8Mh0dHeb7zMNOwZ+Vfy1YI92hhJCfVZmPoiC7XJj +Dp6L3TQsAlFRwxn9WVSEyfFrs0yw6ehGXTjGoqcuEVe6ghWinI9tsJlKCvLriXBj +TnnEt1u9ol2x8kECK62pOqPseQrsXzrj/e+APK00mxqriCZ7VqKChh/rNYmDf1+u +KU49tm7srsHwJ5uu4/Ts765/94Y9cnrrpftZTqfrlYwiOXnhLQiPzLyRuEH3FMEj +qcOtmkVEs7LXLM3GKeJQEK5cy4KOFxg2fZfmiJqwTTQJ9Cy5WmYqsBebnh52nUpm +MUHfP/vFBu8btn4aRjb3ZGM74zkYI+dndRTVdVeSN72+ahsmUPI2JgaQxXABZG12 +ZuGR224HwGGALrIuL4xwp9E7PLOR5G62xDtw8mySlwnNR30YwPO7ng/Wi64HtloP +zgsMR6flPri9fcebNaBhlzpBdRfMK5Z3KpIhHtmVdiBnaM8Nvd/WHwlqmuLMc3Gk +L30SgLdTMEZeS1SZD2fJpcjyIMGC7J0R38IC+xo70e0gmu9lZJIQDSri3nDxGGeC +jGHeuLzRL5z7D9Ar7Rt2ueQ5Vfj4oR24qoAATILnsn8JuLwwoC8N9VKejveSswoA +HQBUlwbgsQfZxw9cZX08bVlX5O2ljelAU58VS6Bx9hoh49pwBiFYFIeFd3mqgnkC +AwEAAaNCMEAwHQYDVR0OBBYEFOLJQJ9NzuiaoXzPDj9lxSmIahlRMA8GA1UdEwEB +/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQDRSVfg +p8xoWLoBDysZzY2wYUWsEe1jUGn4H3++Fo/9nesLqjJHdtJnJO29fDMylyrHBYZm +DRd9FBUb1Ov9H5r2XpdptxolpAqzkT9fNqyL7FeoPueBihhXOYV0GkLH6VsTX4/5 +COmSdI31R9KrO9b7eGZONn356ZLpBN79SWP8bfsUcZNnL0dKt7n/HipzcEYwv1ry +L3ml4Y0M2fmyYzeMN2WFcGpcWwlyua1jPLHd+PwyvzeG5LuOmCd+uh8W4XAR8gPf +JWIyJyYYMoSf/wA6E7qaTfRPuBRwIrHKK5DOKcFw9C+df/KQHtZa37dG/OaG+svg +IHZ6uqbL9XzeYqWxi+7egmaKTjowHz+Ay60nugxe19CxVsp3cbK1daFQqUBDF8Io +2c9Si1vIY9RCPqAzekYu9wogRlR+ak8x8YF+QnQ4ZXMn7sZ8uI7XpTrXmKGcjBBV +09tL7ECQ8s1uV9JiDnxXk7Gnbc2dg7sq5+W2O3FYrf3RRbxake5TFW/TRQl1brqQ +XR4EzzffHqhmsYzmIGrv/EhOdJhCrylvLmrH+33RZjEizIYAfmaDDEL0vTSSwxrq +T8p+ck0LcIymSLumoRT2+1hEmRSuqguTaaApJUqlyyvdimYHFngVV3Eb7PVHhPOe +MTd61X8kreS8/f3MboPoDKi3QWwH3b08hpcv0g== +-----END CERTIFICATE----- + +# Issuer: CN=TrustCor RootCert CA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority +# Subject: CN=TrustCor RootCert CA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority +# Label: "TrustCor RootCert CA-1" +# Serial: 15752444095811006489 +# MD5 Fingerprint: 6e:85:f1:dc:1a:00:d3:22:d5:b2:b2:ac:6b:37:05:45 +# SHA1 Fingerprint: ff:bd:cd:e7:82:c8:43:5e:3c:6f:26:86:5c:ca:a8:3a:45:5b:c3:0a +# SHA256 Fingerprint: d4:0e:9c:86:cd:8f:e4:68:c1:77:69:59:f4:9e:a7:74:fa:54:86:84:b6:c4:06:f3:90:92:61:f4:dc:e2:57:5c +-----BEGIN CERTIFICATE----- +MIIEMDCCAxigAwIBAgIJANqb7HHzA7AZMA0GCSqGSIb3DQEBCwUAMIGkMQswCQYD +VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk +MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U +cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxHzAdBgNVBAMMFlRydXN0Q29y +IFJvb3RDZXJ0IENBLTEwHhcNMTYwMjA0MTIzMjE2WhcNMjkxMjMxMTcyMzE2WjCB +pDELMAkGA1UEBhMCUEExDzANBgNVBAgMBlBhbmFtYTEUMBIGA1UEBwwLUGFuYW1h +IENpdHkxJDAiBgNVBAoMG1RydXN0Q29yIFN5c3RlbXMgUy4gZGUgUi5MLjEnMCUG +A1UECwweVHJ1c3RDb3IgQ2VydGlmaWNhdGUgQXV0aG9yaXR5MR8wHQYDVQQDDBZU +cnVzdENvciBSb290Q2VydCBDQS0xMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB +CgKCAQEAv463leLCJhJrMxnHQFgKq1mqjQCj/IDHUHuO1CAmujIS2CNUSSUQIpid +RtLByZ5OGy4sDjjzGiVoHKZaBeYei0i/mJZ0PmnK6bV4pQa81QBeCQryJ3pS/C3V +seq0iWEk8xoT26nPUu0MJLq5nux+AHT6k61sKZKuUbS701e/s/OojZz0JEsq1pme +9J7+wH5COucLlVPat2gOkEz7cD+PSiyU8ybdY2mplNgQTsVHCJCZGxdNuWxu72CV +EY4hgLW9oHPY0LJ3xEXqWib7ZnZ2+AYfYW0PVcWDtxBWcgYHpfOxGgMFZA6dWorW +hnAbJN7+KIor0Gqw/Hqi3LJ5DotlDwIDAQABo2MwYTAdBgNVHQ4EFgQU7mtJPHo/ +DeOxCbeKyKsZn3MzUOcwHwYDVR0jBBgwFoAU7mtJPHo/DeOxCbeKyKsZn3MzUOcw +DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD +ggEBACUY1JGPE+6PHh0RU9otRCkZoB5rMZ5NDp6tPVxBb5UrJKF5mDo4Nvu7Zp5I +/5CQ7z3UuJu0h3U/IJvOcs+hVcFNZKIZBqEHMwwLKeXx6quj7LUKdJDHfXLy11yf +ke+Ri7fc7Waiz45mO7yfOgLgJ90WmMCV1Aqk5IGadZQ1nJBfiDcGrVmVCrDRZ9MZ +yonnMlo2HD6CqFqTvsbQZJG2z9m2GM/bftJlo6bEjhcxwft+dtvTheNYsnd6djts +L1Ac59v2Z3kf9YKVmgenFK+P3CghZwnS1k1aHBkcjndcw5QkPTJrS37UeJSDvjdN +zl/HHk484IkzlQsPpTLWPFp5LBk= +-----END CERTIFICATE----- + +# Issuer: CN=TrustCor RootCert CA-2 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority +# Subject: CN=TrustCor RootCert CA-2 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority +# Label: "TrustCor RootCert CA-2" +# Serial: 2711694510199101698 +# MD5 Fingerprint: a2:e1:f8:18:0b:ba:45:d5:c7:41:2a:bb:37:52:45:64 +# SHA1 Fingerprint: b8:be:6d:cb:56:f1:55:b9:63:d4:12:ca:4e:06:34:c7:94:b2:1c:c0 +# SHA256 Fingerprint: 07:53:e9:40:37:8c:1b:d5:e3:83:6e:39:5d:ae:a5:cb:83:9e:50:46:f1:bd:0e:ae:19:51:cf:10:fe:c7:c9:65 +-----BEGIN CERTIFICATE----- +MIIGLzCCBBegAwIBAgIIJaHfyjPLWQIwDQYJKoZIhvcNAQELBQAwgaQxCzAJBgNV +BAYTAlBBMQ8wDQYDVQQIDAZQYW5hbWExFDASBgNVBAcMC1BhbmFtYSBDaXR5MSQw +IgYDVQQKDBtUcnVzdENvciBTeXN0ZW1zIFMuIGRlIFIuTC4xJzAlBgNVBAsMHlRy +dXN0Q29yIENlcnRpZmljYXRlIEF1dGhvcml0eTEfMB0GA1UEAwwWVHJ1c3RDb3Ig +Um9vdENlcnQgQ0EtMjAeFw0xNjAyMDQxMjMyMjNaFw0zNDEyMzExNzI2MzlaMIGk +MQswCQYDVQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEg +Q2l0eTEkMCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYD +VQQLDB5UcnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxHzAdBgNVBAMMFlRy +dXN0Q29yIFJvb3RDZXJ0IENBLTIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK +AoICAQCnIG7CKqJiJJWQdsg4foDSq8GbZQWU9MEKENUCrO2fk8eHyLAnK0IMPQo+ +QVqedd2NyuCb7GgypGmSaIwLgQ5WoD4a3SwlFIIvl9NkRvRUqdw6VC0xK5mC8tkq +1+9xALgxpL56JAfDQiDyitSSBBtlVkxs1Pu2YVpHI7TYabS3OtB0PAx1oYxOdqHp +2yqlO/rOsP9+aij9JxzIsekp8VduZLTQwRVtDr4uDkbIXvRR/u8OYzo7cbrPb1nK +DOObXUm4TOJXsZiKQlecdu/vvdFoqNL0Cbt3Nb4lggjEFixEIFapRBF37120Hape +az6LMvYHL1cEksr1/p3C6eizjkxLAjHZ5DxIgif3GIJ2SDpxsROhOdUuxTTCHWKF +3wP+TfSvPd9cW436cOGlfifHhi5qjxLGhF5DUVCcGZt45vz27Ud+ez1m7xMTiF88 +oWP7+ayHNZ/zgp6kPwqcMWmLmaSISo5uZk3vFsQPeSghYA2FFn3XVDjxklb9tTNM +g9zXEJ9L/cb4Qr26fHMC4P99zVvh1Kxhe1fVSntb1IVYJ12/+CtgrKAmrhQhJ8Z3 +mjOAPF5GP/fDsaOGM8boXg25NSyqRsGFAnWAoOsk+xWq5Gd/bnc/9ASKL3x74xdh +8N0JqSDIvgmk0H5Ew7IwSjiqqewYmgeCK9u4nBit2uBGF6zPXQIDAQABo2MwYTAd +BgNVHQ4EFgQU2f4hQG6UnrybPZx9mCAZ5YwwYrIwHwYDVR0jBBgwFoAU2f4hQG6U +nrybPZx9mCAZ5YwwYrIwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYw +DQYJKoZIhvcNAQELBQADggIBAJ5Fngw7tu/hOsh80QA9z+LqBrWyOrsGS2h60COX +dKcs8AjYeVrXWoSK2BKaG9l9XE1wxaX5q+WjiYndAfrs3fnpkpfbsEZC89NiqpX+ +MWcUaViQCqoL7jcjx1BRtPV+nuN79+TMQjItSQzL/0kMmx40/W5ulop5A7Zv2wnL +/V9lFDfhOPXzYRZY5LVtDQsEGz9QLX+zx3oaFoBg+Iof6Rsqxvm6ARppv9JYx1RX +CI/hOWB3S6xZhBqI8d3LT3jX5+EzLfzuQfogsL7L9ziUwOHQhQ+77Sxzq+3+knYa +ZH9bDTMJBzN7Bj8RpFxwPIXAz+OQqIN3+tvmxYxoZxBnpVIt8MSZj3+/0WvitUfW +2dCFmU2Umw9Lje4AWkcdEQOsQRivh7dvDDqPys/cA8GiCcjl/YBeyGBCARsaU1q7 +N6a3vLqE6R5sGtRk2tRD/pOLS/IseRYQ1JMLiI+h2IYURpFHmygk71dSTlxCnKr3 +Sewn6EAes6aJInKc9Q0ztFijMDvd1GpUk74aTfOTlPf8hAs/hCBcNANExdqtvArB +As8e5ZTZ845b2EzwnexhF7sUMlQMAimTHpKG9n/v55IFDlndmQguLvqcAFLTxWYp +5KeXRKQOKIETNcX2b2TmQcTVL8w0RSXPQQCWPUouwpaYT05KnJe32x+SMsj/D1Fu +1uwJ +-----END CERTIFICATE----- + +# Issuer: CN=TrustCor ECA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority +# Subject: CN=TrustCor ECA-1 O=TrustCor Systems S. de R.L. OU=TrustCor Certificate Authority +# Label: "TrustCor ECA-1" +# Serial: 9548242946988625984 +# MD5 Fingerprint: 27:92:23:1d:0a:f5:40:7c:e9:e6:6b:9d:d8:f5:e7:6c +# SHA1 Fingerprint: 58:d1:df:95:95:67:6b:63:c0:f0:5b:1c:17:4d:8b:84:0b:c8:78:bd +# SHA256 Fingerprint: 5a:88:5d:b1:9c:01:d9:12:c5:75:93:88:93:8c:af:bb:df:03:1a:b2:d4:8e:91:ee:15:58:9b:42:97:1d:03:9c +-----BEGIN CERTIFICATE----- +MIIEIDCCAwigAwIBAgIJAISCLF8cYtBAMA0GCSqGSIb3DQEBCwUAMIGcMQswCQYD +VQQGEwJQQTEPMA0GA1UECAwGUGFuYW1hMRQwEgYDVQQHDAtQYW5hbWEgQ2l0eTEk +MCIGA1UECgwbVHJ1c3RDb3IgU3lzdGVtcyBTLiBkZSBSLkwuMScwJQYDVQQLDB5U +cnVzdENvciBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkxFzAVBgNVBAMMDlRydXN0Q29y +IEVDQS0xMB4XDTE2MDIwNDEyMzIzM1oXDTI5MTIzMTE3MjgwN1owgZwxCzAJBgNV +BAYTAlBBMQ8wDQYDVQQIDAZQYW5hbWExFDASBgNVBAcMC1BhbmFtYSBDaXR5MSQw +IgYDVQQKDBtUcnVzdENvciBTeXN0ZW1zIFMuIGRlIFIuTC4xJzAlBgNVBAsMHlRy +dXN0Q29yIENlcnRpZmljYXRlIEF1dGhvcml0eTEXMBUGA1UEAwwOVHJ1c3RDb3Ig +RUNBLTEwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDPj+ARtZ+odnbb +3w9U73NjKYKtR8aja+3+XzP4Q1HpGjORMRegdMTUpwHmspI+ap3tDvl0mEDTPwOA +BoJA6LHip1GnHYMma6ve+heRK9jGrB6xnhkB1Zem6g23xFUfJ3zSCNV2HykVh0A5 +3ThFEXXQmqc04L/NyFIduUd+Dbi7xgz2c1cWWn5DkR9VOsZtRASqnKmcp0yJF4Ou +owReUoCLHhIlERnXDH19MURB6tuvsBzvgdAsxZohmz3tQjtQJvLsznFhBmIhVE5/ +wZ0+fyCMgMsq2JdiyIMzkX2woloPV+g7zPIlstR8L+xNxqE6FXrntl019fZISjZF +ZtS6mFjBAgMBAAGjYzBhMB0GA1UdDgQWBBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAf +BgNVHSMEGDAWgBREnkj1zG1I1KBLf/5ZJC+Dl5mahjAPBgNVHRMBAf8EBTADAQH/ +MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAQEABT41XBVwm8nHc2Fv +civUwo/yQ10CzsSUuZQRg2dd4mdsdXa/uwyqNsatR5Nj3B5+1t4u/ukZMjgDfxT2 +AHMsWbEhBuH7rBiVDKP/mZb3Kyeb1STMHd3BOuCYRLDE5D53sXOpZCz2HAF8P11F +hcCF5yWPldwX8zyfGm6wyuMdKulMY/okYWLW2n62HGz1Ah3UKt1VkOsqEUc8Ll50 +soIipX1TH0XsJ5F95yIW6MBoNtjG8U+ARDL54dHRHareqKucBK+tIA5kmE2la8BI +WJZpTdwHjFGTot+fDz2LYLSCjaoITmJF4PkL0uDgPFveXHEnJcLmA4GLEFPjx1Wi +tJ/X5g== +-----END CERTIFICATE----- + +# Issuer: CN=SSL.com Root Certification Authority RSA O=SSL Corporation +# Subject: CN=SSL.com Root Certification Authority RSA O=SSL Corporation +# Label: "SSL.com Root Certification Authority RSA" +# Serial: 8875640296558310041 +# MD5 Fingerprint: 86:69:12:c0:70:f1:ec:ac:ac:c2:d5:bc:a5:5b:a1:29 +# SHA1 Fingerprint: b7:ab:33:08:d1:ea:44:77:ba:14:80:12:5a:6f:bd:a9:36:49:0c:bb +# SHA256 Fingerprint: 85:66:6a:56:2e:e0:be:5c:e9:25:c1:d8:89:0a:6f:76:a8:7e:c1:6d:4d:7d:5f:29:ea:74:19:cf:20:12:3b:69 +-----BEGIN CERTIFICATE----- +MIIF3TCCA8WgAwIBAgIIeyyb0xaAMpkwDQYJKoZIhvcNAQELBQAwfDELMAkGA1UE +BhMCVVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQK +DA9TU0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZp +Y2F0aW9uIEF1dGhvcml0eSBSU0EwHhcNMTYwMjEyMTczOTM5WhcNNDEwMjEyMTcz +OTM5WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv +dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNv +bSBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IFJTQTCCAiIwDQYJKoZIhvcN +AQEBBQADggIPADCCAgoCggIBAPkP3aMrfcvQKv7sZ4Wm5y4bunfh4/WvpOz6Sl2R +xFdHaxh3a3by/ZPkPQ/CFp4LZsNWlJ4Xg4XOVu/yFv0AYvUiCVToZRdOQbngT0aX +qhvIuG5iXmmxX9sqAn78bMrzQdjt0Oj8P2FI7bADFB0QDksZ4LtO7IZl/zbzXmcC +C52GVWH9ejjt/uIZALdvoVBidXQ8oPrIJZK0bnoix/geoeOy3ZExqysdBP+lSgQ3 +6YWkMyv94tZVNHwZpEpox7Ko07fKoZOI68GXvIz5HdkihCR0xwQ9aqkpk8zruFvh +/l8lqjRYyMEjVJ0bmBHDOJx+PYZspQ9AhnwC9FwCTyjLrnGfDzrIM/4RJTXq/LrF +YD3ZfBjVsqnTdXgDciLKOsMf7yzlLqn6niy2UUb9rwPW6mBo6oUWNmuF6R7As93E +JNyAKoFBbZQ+yODJgUEAnl6/f8UImKIYLEJAs/lvOCdLToD0PYFH4Ih86hzOtXVc +US4cK38acijnALXRdMbX5J+tB5O2UzU1/Dfkw/ZdFr4hc96SCvigY2q8lpJqPvi8 +ZVWb3vUNiSYE/CUapiVpy8JtynziWV+XrOvvLsi81xtZPCvM8hnIk2snYxnP/Okm ++Mpxm3+T/jRnhE6Z6/yzeAkzcLpmpnbtG3PrGqUNxCITIJRWCk4sbE6x/c+cCbqi +M+2HAgMBAAGjYzBhMB0GA1UdDgQWBBTdBAkHovV6fVJTEpKV7jiAJQ2mWTAPBgNV +HRMBAf8EBTADAQH/MB8GA1UdIwQYMBaAFN0ECQei9Xp9UlMSkpXuOIAlDaZZMA4G +A1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOCAgEAIBgRlCn7Jp0cHh5wYfGV +cpNxJK1ok1iOMq8bs3AD/CUrdIWQPXhq9LmLpZc7tRiRux6n+UBbkflVma8eEdBc +Hadm47GUBwwyOabqG7B52B2ccETjit3E+ZUfijhDPwGFpUenPUayvOUiaPd7nNgs +PgohyC0zrL/FgZkxdMF1ccW+sfAjRfSda/wZY52jvATGGAslu1OJD7OAUN5F7kR/ +q5R4ZJjT9ijdh9hwZXT7DrkT66cPYakylszeu+1jTBi7qUD3oFRuIIhxdRjqerQ0 +cuAjJ3dctpDqhiVAq+8zD8ufgr6iIPv2tS0a5sKFsXQP+8hlAqRSAUfdSSLBv9jr +a6x+3uxjMxW3IwiPxg+NQVrdjsW5j+VFP3jbutIbQLH+cU0/4IGiul607BXgk90I +H37hVZkLId6Tngr75qNJvTYw/ud3sqB1l7UtgYgXZSD32pAAn8lSzDLKNXz1PQ/Y +K9f1JmzJBjSWFupwWRoyeXkLtoh/D1JIPb9s2KJELtFOt3JY04kTlf5Eq/jXixtu +nLwsoFvVagCvXzfh1foQC5ichucmj87w7G6KVwuA406ywKBjYZC6VWg3dGq2ktuf +oYYitmUnDuy2n0Jg5GfCtdpBC8TTi2EbvPofkSvXRAdeuims2cXp71NIWuuA8ShY +Ic2wBlX7Jz9TkHCpBB5XJ7k= +-----END CERTIFICATE----- + +# Issuer: CN=SSL.com Root Certification Authority ECC O=SSL Corporation +# Subject: CN=SSL.com Root Certification Authority ECC O=SSL Corporation +# Label: "SSL.com Root Certification Authority ECC" +# Serial: 8495723813297216424 +# MD5 Fingerprint: 2e:da:e4:39:7f:9c:8f:37:d1:70:9f:26:17:51:3a:8e +# SHA1 Fingerprint: c3:19:7c:39:24:e6:54:af:1b:c4:ab:20:95:7a:e2:c3:0e:13:02:6a +# SHA256 Fingerprint: 34:17:bb:06:cc:60:07:da:1b:96:1c:92:0b:8a:b4:ce:3f:ad:82:0e:4a:a3:0b:9a:cb:c4:a7:4e:bd:ce:bc:65 +-----BEGIN CERTIFICATE----- +MIICjTCCAhSgAwIBAgIIdebfy8FoW6gwCgYIKoZIzj0EAwIwfDELMAkGA1UEBhMC +VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T +U0wgQ29ycG9yYXRpb24xMTAvBgNVBAMMKFNTTC5jb20gUm9vdCBDZXJ0aWZpY2F0 +aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNDAzWhcNNDEwMjEyMTgxNDAz +WjB8MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hvdXN0 +b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjExMC8GA1UEAwwoU1NMLmNvbSBS +b290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49AgEGBSuB +BAAiA2IABEVuqVDEpiM2nl8ojRfLliJkP9x6jh3MCLOicSS6jkm5BBtHllirLZXI +7Z4INcgn64mMU1jrYor+8FsPazFSY0E7ic3s7LaNGdM0B9y7xgZ/wkWV7Mt/qCPg +CemB+vNH06NjMGEwHQYDVR0OBBYEFILRhXMw5zUE044CkvvlpNHEIejNMA8GA1Ud +EwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUgtGFczDnNQTTjgKS++Wk0cQh6M0wDgYD +VR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2cAMGQCMG/n61kRpGDPYbCWe+0F+S8T +kdzt5fxQaxFGRrMcIQBiu77D5+jNB5n5DQtdcj7EqgIwH7y6C+IwJPt8bYBVCpk+ +gA0z5Wajs6O7pdWLjwkspl1+4vAHCGht0nxpbl/f5Wpl +-----END CERTIFICATE----- + +# Issuer: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation +# Subject: CN=SSL.com EV Root Certification Authority RSA R2 O=SSL Corporation +# Label: "SSL.com EV Root Certification Authority RSA R2" +# Serial: 6248227494352943350 +# MD5 Fingerprint: e1:1e:31:58:1a:ae:54:53:02:f6:17:6a:11:7b:4d:95 +# SHA1 Fingerprint: 74:3a:f0:52:9b:d0:32:a0:f4:4a:83:cd:d4:ba:a9:7b:7c:2e:c4:9a +# SHA256 Fingerprint: 2e:7b:f1:6c:c2:24:85:a7:bb:e2:aa:86:96:75:07:61:b0:ae:39:be:3b:2f:e9:d0:cc:6d:4e:f7:34:91:42:5c +-----BEGIN CERTIFICATE----- +MIIF6zCCA9OgAwIBAgIIVrYpzTS8ePYwDQYJKoZIhvcNAQELBQAwgYIxCzAJBgNV +BAYTAlVTMQ4wDAYDVQQIDAVUZXhhczEQMA4GA1UEBwwHSG91c3RvbjEYMBYGA1UE +CgwPU1NMIENvcnBvcmF0aW9uMTcwNQYDVQQDDC5TU0wuY29tIEVWIFJvb3QgQ2Vy +dGlmaWNhdGlvbiBBdXRob3JpdHkgUlNBIFIyMB4XDTE3MDUzMTE4MTQzN1oXDTQy +MDUzMDE4MTQzN1owgYIxCzAJBgNVBAYTAlVTMQ4wDAYDVQQIDAVUZXhhczEQMA4G +A1UEBwwHSG91c3RvbjEYMBYGA1UECgwPU1NMIENvcnBvcmF0aW9uMTcwNQYDVQQD +DC5TU0wuY29tIEVWIFJvb3QgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgUlNBIFIy +MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAjzZlQOHWTcDXtOlG2mvq +M0fNTPl9fb69LT3w23jhhqXZuglXaO1XPqDQCEGD5yhBJB/jchXQARr7XnAjssuf +OePPxU7Gkm0mxnu7s9onnQqG6YE3Bf7wcXHswxzpY6IXFJ3vG2fThVUCAtZJycxa +4bH3bzKfydQ7iEGonL3Lq9ttewkfokxykNorCPzPPFTOZw+oz12WGQvE43LrrdF9 +HSfvkusQv1vrO6/PgN3B0pYEW3p+pKk8OHakYo6gOV7qd89dAFmPZiw+B6KjBSYR +aZfqhbcPlgtLyEDhULouisv3D5oi53+aNxPN8k0TayHRwMwi8qFG9kRpnMphNQcA +b9ZhCBHqurj26bNg5U257J8UZslXWNvNh2n4ioYSA0e/ZhN2rHd9NCSFg83XqpyQ +Gp8hLH94t2S42Oim9HizVcuE0jLEeK6jj2HdzghTreyI/BXkmg3mnxp3zkyPuBQV +PWKchjgGAGYS5Fl2WlPAApiiECtoRHuOec4zSnaqW4EWG7WK2NAAe15itAnWhmMO +pgWVSbooi4iTsjQc2KRVbrcc0N6ZVTsj9CLg+SlmJuwgUHfbSguPvuUCYHBBXtSu +UDkiFCbLsjtzdFVHB3mBOagwE0TlBIqulhMlQg+5U8Sb/M3kHN48+qvWBkofZ6aY +MBzdLNvcGJVXZsb/XItW9XcCAwEAAaNjMGEwDwYDVR0TAQH/BAUwAwEB/zAfBgNV +HSMEGDAWgBT5YLvU49U09rj1BoAlp3PbRmmonjAdBgNVHQ4EFgQU+WC71OPVNPa4 +9QaAJadz20ZpqJ4wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4ICAQBW +s47LCp1Jjr+kxJG7ZhcFUZh1++VQLHqe8RT6q9OKPv+RKY9ji9i0qVQBDb6Thi/5 +Sm3HXvVX+cpVHBK+Rw82xd9qt9t1wkclf7nxY/hoLVUE0fKNsKTPvDxeH3jnpaAg +cLAExbf3cqfeIg29MyVGjGSSJuM+LmOW2puMPfgYCdcDzH2GguDKBAdRUNf/ktUM +79qGn5nX67evaOI5JpS6aLe/g9Pqemc9YmeuJeVy6OLk7K4S9ksrPJ/psEDzOFSz +/bdoyNrGj1E8svuR3Bznm53htw1yj+KkxKl4+esUrMZDBcJlOSgYAsOCsp0FvmXt +ll9ldDz7CTUue5wT/RsPXcdtgTpWD8w74a8CLyKsRspGPKAcTNZEtF4uXBVmCeEm +Kf7GUmG6sXP/wwyc5WxqlD8UykAWlYTzWamsX0xhk23RO8yilQwipmdnRC652dKK +QbNmC1r7fSOl8hqw/96bg5Qu0T/fkreRrwU7ZcegbLHNYhLDkBvjJc40vG93drEQ +w/cFGsDWr3RiSBd3kmmQYRzelYB0VI8YHMPzA9C/pEN1hlMYegouCRw2n5H9gooi +S9EOUCXdywMMF8mDAAhONU2Ki+3wApRmLER/y5UnlhetCTCstnEXbosX9hwJ1C07 +mKVx01QT2WDz9UtmT/rx7iASjbSsV7FFY6GsdqnC+w== +-----END CERTIFICATE----- + +# Issuer: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation +# Subject: CN=SSL.com EV Root Certification Authority ECC O=SSL Corporation +# Label: "SSL.com EV Root Certification Authority ECC" +# Serial: 3182246526754555285 +# MD5 Fingerprint: 59:53:22:65:83:42:01:54:c0:ce:42:b9:5a:7c:f2:90 +# SHA1 Fingerprint: 4c:dd:51:a3:d1:f5:20:32:14:b0:c6:c5:32:23:03:91:c7:46:42:6d +# SHA256 Fingerprint: 22:a2:c1:f7:bd:ed:70:4c:c1:e7:01:b5:f4:08:c3:10:88:0f:e9:56:b5:de:2a:4a:44:f9:9c:87:3a:25:a7:c8 +-----BEGIN CERTIFICATE----- +MIIClDCCAhqgAwIBAgIILCmcWxbtBZUwCgYIKoZIzj0EAwIwfzELMAkGA1UEBhMC +VVMxDjAMBgNVBAgMBVRleGFzMRAwDgYDVQQHDAdIb3VzdG9uMRgwFgYDVQQKDA9T +U0wgQ29ycG9yYXRpb24xNDAyBgNVBAMMK1NTTC5jb20gRVYgUm9vdCBDZXJ0aWZp +Y2F0aW9uIEF1dGhvcml0eSBFQ0MwHhcNMTYwMjEyMTgxNTIzWhcNNDEwMjEyMTgx +NTIzWjB/MQswCQYDVQQGEwJVUzEOMAwGA1UECAwFVGV4YXMxEDAOBgNVBAcMB0hv +dXN0b24xGDAWBgNVBAoMD1NTTCBDb3Jwb3JhdGlvbjE0MDIGA1UEAwwrU1NMLmNv +bSBFViBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5IEVDQzB2MBAGByqGSM49 +AgEGBSuBBAAiA2IABKoSR5CYG/vvw0AHgyBO8TCCogbR8pKGYfL2IWjKAMTH6kMA +VIbc/R/fALhBYlzccBYy3h+Z1MzFB8gIH2EWB1E9fVwHU+M1OIzfzZ/ZLg1Kthku +WnBaBu2+8KGwytAJKaNjMGEwHQYDVR0OBBYEFFvKXuXe0oGqzagtZFG22XKbl+ZP +MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUW8pe5d7SgarNqC1kUbbZcpuX +5k8wDgYDVR0PAQH/BAQDAgGGMAoGCCqGSM49BAMCA2gAMGUCMQCK5kCJN+vp1RPZ +ytRrJPOwPYdGWBrssd9v+1a6cGvHOMzosYxPD/fxZ3YOg9AeUY8CMD32IygmTMZg +h5Mmm7I1HrrW9zzRHM76JTymGoEVW/MSD2zuZYrJh6j5B+BimoxcSg== +-----END CERTIFICATE----- + +# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6 +# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R6 +# Label: "GlobalSign Root CA - R6" +# Serial: 1417766617973444989252670301619537 +# MD5 Fingerprint: 4f:dd:07:e4:d4:22:64:39:1e:0c:37:42:ea:d1:c6:ae +# SHA1 Fingerprint: 80:94:64:0e:b5:a7:a1:ca:11:9c:1f:dd:d5:9f:81:02:63:a7:fb:d1 +# SHA256 Fingerprint: 2c:ab:ea:fe:37:d0:6c:a2:2a:ba:73:91:c0:03:3d:25:98:29:52:c4:53:64:73:49:76:3a:3a:b5:ad:6c:cf:69 +-----BEGIN CERTIFICATE----- +MIIFgzCCA2ugAwIBAgIORea7A4Mzw4VlSOb/RVEwDQYJKoZIhvcNAQEMBQAwTDEg +MB4GA1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjYxEzARBgNVBAoTCkdsb2Jh +bFNpZ24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMTQxMjEwMDAwMDAwWhcNMzQx +MjEwMDAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSNjET +MBEGA1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCAiIwDQYJ +KoZIhvcNAQEBBQADggIPADCCAgoCggIBAJUH6HPKZvnsFMp7PPcNCPG0RQssgrRI +xutbPK6DuEGSMxSkb3/pKszGsIhrxbaJ0cay/xTOURQh7ErdG1rG1ofuTToVBu1k +ZguSgMpE3nOUTvOniX9PeGMIyBJQbUJmL025eShNUhqKGoC3GYEOfsSKvGRMIRxD +aNc9PIrFsmbVkJq3MQbFvuJtMgamHvm566qjuL++gmNQ0PAYid/kD3n16qIfKtJw +LnvnvJO7bVPiSHyMEAc4/2ayd2F+4OqMPKq0pPbzlUoSB239jLKJz9CgYXfIWHSw +1CM69106yqLbnQneXUQtkPGBzVeS+n68UARjNN9rkxi+azayOeSsJDa38O+2HBNX +k7besvjihbdzorg1qkXy4J02oW9UivFyVm4uiMVRQkQVlO6jxTiWm05OWgtH8wY2 +SXcwvHE35absIQh1/OZhFj931dmRl4QKbNQCTXTAFO39OfuD8l4UoQSwC+n+7o/h +bguyCLNhZglqsQY6ZZZZwPA1/cnaKI0aEYdwgQqomnUdnjqGBQCe24DWJfncBZ4n +WUx2OVvq+aWh2IMP0f/fMBH5hc8zSPXKbWQULHpYT9NLCEnFlWQaYw55PfWzjMpY +rZxCRXluDocZXFSxZba/jJvcE+kNb7gu3GduyYsRtYQUigAZcIN5kZeR1Bonvzce +MgfYFGM8KEyvAgMBAAGjYzBhMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTAD +AQH/MB0GA1UdDgQWBBSubAWjkxPioufi1xzWx/B/yGdToDAfBgNVHSMEGDAWgBSu +bAWjkxPioufi1xzWx/B/yGdToDANBgkqhkiG9w0BAQwFAAOCAgEAgyXt6NH9lVLN +nsAEoJFp5lzQhN7craJP6Ed41mWYqVuoPId8AorRbrcWc+ZfwFSY1XS+wc3iEZGt +Ixg93eFyRJa0lV7Ae46ZeBZDE1ZXs6KzO7V33EByrKPrmzU+sQghoefEQzd5Mr61 +55wsTLxDKZmOMNOsIeDjHfrYBzN2VAAiKrlNIC5waNrlU/yDXNOd8v9EDERm8tLj +vUYAGm0CuiVdjaExUd1URhxN25mW7xocBFymFe944Hn+Xds+qkxV/ZoVqW/hpvvf +cDDpw+5CRu3CkwWJ+n1jez/QcYF8AOiYrg54NMMl+68KnyBr3TsTjxKM4kEaSHpz +oHdpx7Zcf4LIHv5YGygrqGytXm3ABdJ7t+uA/iU3/gKbaKxCXcPu9czc8FB10jZp +nOZ7BN9uBmm23goJSFmH63sUYHpkqmlD75HHTOwY3WzvUy2MmeFe8nI+z1TIvWfs +pA9MRf/TuTAjB0yPEL+GltmZWrSZVxykzLsViVO6LAUP5MSeGbEYNNVMnbrt9x+v +JJUEeKgDu+6B5dpffItKoZB0JaezPkvILFa9x8jvOOJckvB595yEunQtYQEgfn7R +8k8HWV+LLUNS60YMlOH1Zkd5d9VUWx+tJDfLRVpOoERIyNiwmcUVhAn21klJwGW4 +5hpxbqCo8YLoRT5s1gLXCmeDBVrJpBA= +-----END CERTIFICATE----- + +# Issuer: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed +# Subject: CN=OISTE WISeKey Global Root GC CA O=WISeKey OU=OISTE Foundation Endorsed +# Label: "OISTE WISeKey Global Root GC CA" +# Serial: 44084345621038548146064804565436152554 +# MD5 Fingerprint: a9:d6:b9:2d:2f:93:64:f8:a5:69:ca:91:e9:68:07:23 +# SHA1 Fingerprint: e0:11:84:5e:34:de:be:88:81:b9:9c:f6:16:26:d1:96:1f:c3:b9:31 +# SHA256 Fingerprint: 85:60:f9:1c:36:24:da:ba:95:70:b5:fe:a0:db:e3:6f:f1:1a:83:23:be:94:86:85:4f:b3:f3:4a:55:71:19:8d +-----BEGIN CERTIFICATE----- +MIICaTCCAe+gAwIBAgIQISpWDK7aDKtARb8roi066jAKBggqhkjOPQQDAzBtMQsw +CQYDVQQGEwJDSDEQMA4GA1UEChMHV0lTZUtleTEiMCAGA1UECxMZT0lTVEUgRm91 +bmRhdGlvbiBFbmRvcnNlZDEoMCYGA1UEAxMfT0lTVEUgV0lTZUtleSBHbG9iYWwg +Um9vdCBHQyBDQTAeFw0xNzA1MDkwOTQ4MzRaFw00MjA1MDkwOTU4MzNaMG0xCzAJ +BgNVBAYTAkNIMRAwDgYDVQQKEwdXSVNlS2V5MSIwIAYDVQQLExlPSVNURSBGb3Vu +ZGF0aW9uIEVuZG9yc2VkMSgwJgYDVQQDEx9PSVNURSBXSVNlS2V5IEdsb2JhbCBS +b290IEdDIENBMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAETOlQwMYPchi82PG6s4ni +eUqjFqdrVCTbUf/q9Akkwwsin8tqJ4KBDdLArzHkdIJuyiXZjHWd8dvQmqJLIX4W +p2OQ0jnUsYd4XxiWD1AbNTcPasbc2RNNpI6QN+a9WzGRo1QwUjAOBgNVHQ8BAf8E +BAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUSIcUrOPDnpBgOtfKie7T +rYy0UGYwEAYJKwYBBAGCNxUBBAMCAQAwCgYIKoZIzj0EAwMDaAAwZQIwJsdpW9zV +57LnyAyMjMPdeYwbY9XJUpROTYJKcx6ygISpJcBMWm1JKWB4E+J+SOtkAjEA2zQg +Mgj/mkkCtojeFK9dbJlxjRo/i9fgojaGHAeCOnZT/cKi7e97sIBPWA9LUzm9 +-----END CERTIFICATE----- + +# Issuer: CN=GTS Root R1 O=Google Trust Services LLC +# Subject: CN=GTS Root R1 O=Google Trust Services LLC +# Label: "GTS Root R1" +# Serial: 146587175971765017618439757810265552097 +# MD5 Fingerprint: 82:1a:ef:d4:d2:4a:f2:9f:e2:3d:97:06:14:70:72:85 +# SHA1 Fingerprint: e1:c9:50:e6:ef:22:f8:4c:56:45:72:8b:92:20:60:d7:d5:a7:a3:e8 +# SHA256 Fingerprint: 2a:57:54:71:e3:13:40:bc:21:58:1c:bd:2c:f1:3e:15:84:63:20:3e:ce:94:bc:f9:d3:cc:19:6b:f0:9a:54:72 +-----BEGIN CERTIFICATE----- +MIIFWjCCA0KgAwIBAgIQbkepxUtHDA3sM9CJuRz04TANBgkqhkiG9w0BAQwFADBH +MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM +QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy +MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl +cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjEwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQC2EQKLHuOhd5s73L+UPreVp0A8of2C+X0yBoJx9vaM +f/vo27xqLpeXo4xL+Sv2sfnOhB2x+cWX3u+58qPpvBKJXqeqUqv4IyfLpLGcY9vX +mX7wCl7raKb0xlpHDU0QM+NOsROjyBhsS+z8CZDfnWQpJSMHobTSPS5g4M/SCYe7 +zUjwTcLCeoiKu7rPWRnWr4+wB7CeMfGCwcDfLqZtbBkOtdh+JhpFAz2weaSUKK0P +fyblqAj+lug8aJRT7oM6iCsVlgmy4HqMLnXWnOunVmSPlk9orj2XwoSPwLxAwAtc +vfaHszVsrBhQf4TgTM2S0yDpM7xSma8ytSmzJSq0SPly4cpk9+aCEI3oncKKiPo4 +Zor8Y/kB+Xj9e1x3+naH+uzfsQ55lVe0vSbv1gHR6xYKu44LtcXFilWr06zqkUsp +zBmkMiVOKvFlRNACzqrOSbTqn3yDsEB750Orp2yjj32JgfpMpf/VjsPOS+C12LOO +Rc92wO1AK/1TD7Cn1TsNsYqiA94xrcx36m97PtbfkSIS5r762DL8EGMUUXLeXdYW +k70paDPvOmbsB4om3xPXV2V4J95eSRQAogB/mqghtqmxlbCluQ0WEdrHbEg8QOB+ +DVrNVjzRlwW5y0vtOUucxD/SVRNuJLDWcfr0wbrM7Rv1/oFB2ACYPTrIrnqYNxgF +lQIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV +HQ4EFgQU5K8rJnEaK0gnhS9SZizv8IkTcT4wDQYJKoZIhvcNAQEMBQADggIBADiW +Cu49tJYeX++dnAsznyvgyv3SjgofQXSlfKqE1OXyHuY3UjKcC9FhHb8owbZEKTV1 +d5iyfNm9dKyKaOOpMQkpAWBz40d8U6iQSifvS9efk+eCNs6aaAyC58/UEBZvXw6Z +XPYfcX3v73svfuo21pdwCxXu11xWajOl40k4DLh9+42FpLFZXvRq4d2h9mREruZR +gyFmxhE+885H7pwoHyXa/6xmld01D1zvICxi/ZG6qcz8WpyTgYMpl0p8WnK0OdC3 +d8t5/Wk6kjftbjhlRn7pYL15iJdfOBL07q9bgsiG1eGZbYwE8na6SfZu6W0eX6Dv +J4J2QPim01hcDyxC2kLGe4g0x8HYRZvBPsVhHdljUEn2NIVq4BjFbkerQUIpm/Zg +DdIx02OYI5NaAIFItO/Nis3Jz5nu2Z6qNuFoS3FJFDYoOj0dzpqPJeaAcWErtXvM ++SUWgeExX6GjfhaknBZqlxi9dnKlC54dNuYvoS++cJEPqOba+MSSQGwlfnuzCdyy +F62ARPBopY+Udf90WuioAnwMCeKpSwughQtiue+hMZL77/ZRBIls6Kl0obsXs7X9 +SQ98POyDGCBDTtWTurQ0sR8WNh8M5mQ5Fkzc4P4dyKliPUDqysU0ArSuiYgzNdws +E3PYJ/HQcu51OyLemGhmW/HGY0dVHLqlCFF1pkgl +-----END CERTIFICATE----- + +# Issuer: CN=GTS Root R2 O=Google Trust Services LLC +# Subject: CN=GTS Root R2 O=Google Trust Services LLC +# Label: "GTS Root R2" +# Serial: 146587176055767053814479386953112547951 +# MD5 Fingerprint: 44:ed:9a:0e:a4:09:3b:00:f2:ae:4c:a3:c6:61:b0:8b +# SHA1 Fingerprint: d2:73:96:2a:2a:5e:39:9f:73:3f:e1:c7:1e:64:3f:03:38:34:fc:4d +# SHA256 Fingerprint: c4:5d:7b:b0:8e:6d:67:e6:2e:42:35:11:0b:56:4e:5f:78:fd:92:ef:05:8c:84:0a:ea:4e:64:55:d7:58:5c:60 +-----BEGIN CERTIFICATE----- +MIIFWjCCA0KgAwIBAgIQbkepxlqz5yDFMJo/aFLybzANBgkqhkiG9w0BAQwFADBH +MQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExM +QzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIy +MDAwMDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNl +cnZpY2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjIwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQDO3v2m++zsFDQ8BwZabFn3GTXd98GdVarTzTukk3Lv +CvptnfbwhYBboUhSnznFt+4orO/LdmgUud+tAWyZH8QiHZ/+cnfgLFuv5AS/T3Kg +GjSY6Dlo7JUle3ah5mm5hRm9iYz+re026nO8/4Piy33B0s5Ks40FnotJk9/BW9Bu +XvAuMC6C/Pq8tBcKSOWIm8Wba96wyrQD8Nr0kLhlZPdcTK3ofmZemde4wj7I0BOd +re7kRXuJVfeKH2JShBKzwkCX44ofR5GmdFrS+LFjKBC4swm4VndAoiaYecb+3yXu +PuWgf9RhD1FLPD+M2uFwdNjCaKH5wQzpoeJ/u1U8dgbuak7MkogwTZq9TwtImoS1 +mKPV+3PBV2HdKFZ1E66HjucMUQkQdYhMvI35ezzUIkgfKtzra7tEscszcTJGr61K +8YzodDqs5xoic4DSMPclQsciOzsSrZYuxsN2B6ogtzVJV+mSSeh2FnIxZyuWfoqj +x5RWIr9qS34BIbIjMt/kmkRtWVtd9QCgHJvGeJeNkP+byKq0rxFROV7Z+2et1VsR +nTKaG73VululycslaVNVJ1zgyjbLiGH7HrfQy+4W+9OmTN6SpdTi3/UGVN4unUu0 +kzCqgc7dGtxRcw1PcOnlthYhGXmy5okLdWTK1au8CcEYof/UVKGFPP0UJAOyh9Ok +twIDAQABo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNV +HQ4EFgQUu//KjiOfT5nK2+JopqUVJxce2Q4wDQYJKoZIhvcNAQEMBQADggIBALZp +8KZ3/p7uC4Gt4cCpx/k1HUCCq+YEtN/L9x0Pg/B+E02NjO7jMyLDOfxA325BS0JT +vhaI8dI4XsRomRyYUpOM52jtG2pzegVATX9lO9ZY8c6DR2Dj/5epnGB3GFW1fgiT +z9D2PGcDFWEJ+YF59exTpJ/JjwGLc8R3dtyDovUMSRqodt6Sm2T4syzFJ9MHwAiA +pJiS4wGWAqoC7o87xdFtCjMwc3i5T1QWvwsHoaRc5svJXISPD+AVdyx+Jn7axEvb +pxZ3B7DNdehyQtaVhJ2Gg/LkkM0JR9SLA3DaWsYDQvTtN6LwG1BUSw7YhN4ZKJmB +R64JGz9I0cNv4rBgF/XuIwKl2gBbbZCr7qLpGzvpx0QnRY5rn/WkhLx3+WuXrD5R +RaIRpsyF7gpo8j5QOHokYh4XIDdtak23CZvJ/KRY9bb7nE4Yu5UC56GtmwfuNmsk +0jmGwZODUNKBRqhfYlcsu2xkiAhu7xNUX90txGdj08+JN7+dIPT7eoOboB6BAFDC +5AwiWVIQ7UNWhwD4FFKnHYuTjKJNRn8nxnGbJN7k2oaLDX5rIMHAnuFl2GqjpuiF +izoHCBy69Y9Vmhh1fuXsgWbRIXOhNUQLgD1bnF5vKheW0YMjiGZt5obicDIvUiLn +yOd/xCxgXS/Dr55FBcOEArf9LAhST4Ldo/DUhgkC +-----END CERTIFICATE----- + +# Issuer: CN=GTS Root R3 O=Google Trust Services LLC +# Subject: CN=GTS Root R3 O=Google Trust Services LLC +# Label: "GTS Root R3" +# Serial: 146587176140553309517047991083707763997 +# MD5 Fingerprint: 1a:79:5b:6b:04:52:9c:5d:c7:74:33:1b:25:9a:f9:25 +# SHA1 Fingerprint: 30:d4:24:6f:07:ff:db:91:89:8a:0b:e9:49:66:11:eb:8c:5e:46:e5 +# SHA256 Fingerprint: 15:d5:b8:77:46:19:ea:7d:54:ce:1c:a6:d0:b0:c4:03:e0:37:a9:17:f1:31:e8:a0:4e:1e:6b:7a:71:ba:bc:e5 +-----BEGIN CERTIFICATE----- +MIICDDCCAZGgAwIBAgIQbkepx2ypcyRAiQ8DVd2NHTAKBggqhkjOPQQDAzBHMQsw +CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU +MBIGA1UEAxMLR1RTIFJvb3QgUjMwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw +MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp +Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjMwdjAQBgcqhkjOPQIBBgUrgQQA +IgNiAAQfTzOHMymKoYTey8chWEGJ6ladK0uFxh1MJ7x/JlFyb+Kf1qPKzEUURout +736GjOyxfi//qXGdGIRFBEFVbivqJn+7kAHjSxm65FSWRQmx1WyRRK2EE46ajA2A +DDL24CejQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud +DgQWBBTB8Sa6oC2uhYHP0/EqEr24Cmf9vDAKBggqhkjOPQQDAwNpADBmAjEAgFuk +fCPAlaUs3L6JbyO5o91lAFJekazInXJ0glMLfalAvWhgxeG4VDvBNhcl2MG9AjEA +njWSdIUlUfUk7GRSJFClH9voy8l27OyCbvWFGFPouOOaKaqW04MjyaR7YbPMAuhd +-----END CERTIFICATE----- + +# Issuer: CN=GTS Root R4 O=Google Trust Services LLC +# Subject: CN=GTS Root R4 O=Google Trust Services LLC +# Label: "GTS Root R4" +# Serial: 146587176229350439916519468929765261721 +# MD5 Fingerprint: 5d:b6:6a:c4:60:17:24:6a:1a:99:a8:4b:ee:5e:b4:26 +# SHA1 Fingerprint: 2a:1d:60:27:d9:4a:b1:0a:1c:4d:91:5c:cd:33:a0:cb:3e:2d:54:cb +# SHA256 Fingerprint: 71:cc:a5:39:1f:9e:79:4b:04:80:25:30:b3:63:e1:21:da:8a:30:43:bb:26:66:2f:ea:4d:ca:7f:c9:51:a4:bd +-----BEGIN CERTIFICATE----- +MIICCjCCAZGgAwIBAgIQbkepyIuUtui7OyrYorLBmTAKBggqhkjOPQQDAzBHMQsw +CQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZpY2VzIExMQzEU +MBIGA1UEAxMLR1RTIFJvb3QgUjQwHhcNMTYwNjIyMDAwMDAwWhcNMzYwNjIyMDAw +MDAwWjBHMQswCQYDVQQGEwJVUzEiMCAGA1UEChMZR29vZ2xlIFRydXN0IFNlcnZp +Y2VzIExMQzEUMBIGA1UEAxMLR1RTIFJvb3QgUjQwdjAQBgcqhkjOPQIBBgUrgQQA +IgNiAATzdHOnaItgrkO4NcWBMHtLSZ37wWHO5t5GvWvVYRg1rkDdc/eJkTBa6zzu +hXyiQHY7qca4R9gq55KRanPpsXI5nymfopjTX15YhmUPoYRlBtHci8nHc8iMai/l +xKvRHYqjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud +DgQWBBSATNbrdP9JNqPV2Py1PsVq8JQdjDAKBggqhkjOPQQDAwNnADBkAjBqUFJ0 +CMRw3J5QdCHojXohw0+WbhXRIjVhLfoIN+4Zba3bssx9BzT1YBkstTTZbyACMANx +sbqjYAuG7ZoIapVon+Kz4ZNkfF6Tpt95LY2F45TPI11xzPKwTdb+mciUqXWi4w== +-----END CERTIFICATE----- + +# Issuer: CN=UCA Global G2 Root O=UniTrust +# Subject: CN=UCA Global G2 Root O=UniTrust +# Label: "UCA Global G2 Root" +# Serial: 124779693093741543919145257850076631279 +# MD5 Fingerprint: 80:fe:f0:c4:4a:f0:5c:62:32:9f:1c:ba:78:a9:50:f8 +# SHA1 Fingerprint: 28:f9:78:16:19:7a:ff:18:25:18:aa:44:fe:c1:a0:ce:5c:b6:4c:8a +# SHA256 Fingerprint: 9b:ea:11:c9:76:fe:01:47:64:c1:be:56:a6:f9:14:b5:a5:60:31:7a:bd:99:88:39:33:82:e5:16:1a:a0:49:3c +-----BEGIN CERTIFICATE----- +MIIFRjCCAy6gAwIBAgIQXd+x2lqj7V2+WmUgZQOQ7zANBgkqhkiG9w0BAQsFADA9 +MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxGzAZBgNVBAMMElVDQSBH +bG9iYWwgRzIgUm9vdDAeFw0xNjAzMTEwMDAwMDBaFw00MDEyMzEwMDAwMDBaMD0x +CzAJBgNVBAYTAkNOMREwDwYDVQQKDAhVbmlUcnVzdDEbMBkGA1UEAwwSVUNBIEds +b2JhbCBHMiBSb290MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxeYr +b3zvJgUno4Ek2m/LAfmZmqkywiKHYUGRO8vDaBsGxUypK8FnFyIdK+35KYmToni9 +kmugow2ifsqTs6bRjDXVdfkX9s9FxeV67HeToI8jrg4aA3++1NDtLnurRiNb/yzm +VHqUwCoV8MmNsHo7JOHXaOIxPAYzRrZUEaalLyJUKlgNAQLx+hVRZ2zA+te2G3/R +VogvGjqNO7uCEeBHANBSh6v7hn4PJGtAnTRnvI3HLYZveT6OqTwXS3+wmeOwcWDc +C/Vkw85DvG1xudLeJ1uK6NjGruFZfc8oLTW4lVYa8bJYS7cSN8h8s+1LgOGN+jIj +tm+3SJUIsUROhYw6AlQgL9+/V087OpAh18EmNVQg7Mc/R+zvWr9LesGtOxdQXGLY +D0tK3Cv6brxzks3sx1DoQZbXqX5t2Okdj4q1uViSukqSKwxW/YDrCPBeKW4bHAyv +j5OJrdu9o54hyokZ7N+1wxrrFv54NkzWbtA+FxyQF2smuvt6L78RHBgOLXMDj6Dl +NaBa4kx1HXHhOThTeEDMg5PXCp6dW4+K5OXgSORIskfNTip1KnvyIvbJvgmRlld6 +iIis7nCs+dwp4wwcOxJORNanTrAmyPPZGpeRaOrvjUYG0lZFWJo8DA+DuAUlwznP +O6Q0ibd5Ei9Hxeepl2n8pndntd978XplFeRhVmUCAwEAAaNCMEAwDgYDVR0PAQH/ +BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIHEjMz15DD/pQwIX4wV +ZyF0Ad/fMA0GCSqGSIb3DQEBCwUAA4ICAQATZSL1jiutROTL/7lo5sOASD0Ee/oj +L3rtNtqyzm325p7lX1iPyzcyochltq44PTUbPrw7tgTQvPlJ9Zv3hcU2tsu8+Mg5 +1eRfB70VVJd0ysrtT7q6ZHafgbiERUlMjW+i67HM0cOU2kTC5uLqGOiiHycFutfl +1qnN3e92mI0ADs0b+gO3joBYDic/UvuUospeZcnWhNq5NXHzJsBPd+aBJ9J3O5oU +b3n09tDh05S60FdRvScFDcH9yBIw7m+NESsIndTUv4BFFJqIRNow6rSn4+7vW4LV +PtateJLbXDzz2K36uGt/xDYotgIVilQsnLAXc47QN6MUPJiVAAwpBVueSUmxX8fj +y88nZY41F7dXyDDZQVu5FLbowg+UMaeUmMxq67XhJ/UQqAHojhJi6IjMtX9Gl8Cb +EGY4GjZGXyJoPd/JxhMnq1MGrKI8hgZlb7F+sSlEmqO6SWkoaY/X5V+tBIZkbxqg +DMUIYs6Ao9Dz7GjevjPHF1t/gMRMTLGmhIrDO7gJzRSBuhjjVFc2/tsvfEehOjPI ++Vg7RE+xygKJBJYoaMVLuCaJu9YzL1DV/pqJuhgyklTGW+Cd+V7lDSKb9triyCGy +YiGqhkCyLmTTX8jjfhFnRR8F/uOi77Oos/N9j/gMHyIfLXC0uAE0djAA5SN4p1bX +UB+K+wb1whnw0A== +-----END CERTIFICATE----- + +# Issuer: CN=UCA Extended Validation Root O=UniTrust +# Subject: CN=UCA Extended Validation Root O=UniTrust +# Label: "UCA Extended Validation Root" +# Serial: 106100277556486529736699587978573607008 +# MD5 Fingerprint: a1:f3:5f:43:c6:34:9b:da:bf:8c:7e:05:53:ad:96:e2 +# SHA1 Fingerprint: a3:a1:b0:6f:24:61:23:4a:e3:36:a5:c2:37:fc:a6:ff:dd:f0:d7:3a +# SHA256 Fingerprint: d4:3a:f9:b3:54:73:75:5c:96:84:fc:06:d7:d8:cb:70:ee:5c:28:e7:73:fb:29:4e:b4:1e:e7:17:22:92:4d:24 +-----BEGIN CERTIFICATE----- +MIIFWjCCA0KgAwIBAgIQT9Irj/VkyDOeTzRYZiNwYDANBgkqhkiG9w0BAQsFADBH +MQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNVBAMMHFVDQSBF +eHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwHhcNMTUwMzEzMDAwMDAwWhcNMzgxMjMx +MDAwMDAwWjBHMQswCQYDVQQGEwJDTjERMA8GA1UECgwIVW5pVHJ1c3QxJTAjBgNV +BAMMHFVDQSBFeHRlbmRlZCBWYWxpZGF0aW9uIFJvb3QwggIiMA0GCSqGSIb3DQEB +AQUAA4ICDwAwggIKAoICAQCpCQcoEwKwmeBkqh5DFnpzsZGgdT6o+uM4AHrsiWog +D4vFsJszA1qGxliG1cGFu0/GnEBNyr7uaZa4rYEwmnySBesFK5pI0Lh2PpbIILvS +sPGP2KxFRv+qZ2C0d35qHzwaUnoEPQc8hQ2E0B92CvdqFN9y4zR8V05WAT558aop +O2z6+I9tTcg1367r3CTueUWnhbYFiN6IXSV8l2RnCdm/WhUFhvMJHuxYMjMR83dk +sHYf5BA1FxvyDrFspCqjc/wJHx4yGVMR59mzLC52LqGj3n5qiAno8geK+LLNEOfi +c0CTuwjRP+H8C5SzJe98ptfRr5//lpr1kXuYC3fUfugH0mK1lTnj8/FtDw5lhIpj +VMWAtuCeS31HJqcBCF3RiJ7XwzJE+oJKCmhUfzhTA8ykADNkUVkLo4KRel7sFsLz +KuZi2irbWWIQJUoqgQtHB0MGcIfS+pMRKXpITeuUx3BNr2fVUbGAIAEBtHoIppB/ +TuDvB0GHr2qlXov7z1CymlSvw4m6WC31MJixNnI5fkkE/SmnTHnkBVfblLkWU41G +sx2VYVdWf6/wFlthWG82UBEL2KwrlRYaDh8IzTY0ZRBiZtWAXxQgXy0MoHgKaNYs +1+lvK9JKBZP8nm9rZ/+I8U6laUpSNwXqxhaN0sSZ0YIrO7o1dfdRUVjzyAfd5LQD +fwIDAQABo0IwQDAdBgNVHQ4EFgQU2XQ65DA9DfcS3H5aBZ8eNJr34RQwDwYDVR0T +AQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQADggIBADaN +l8xCFWQpN5smLNb7rhVpLGsaGvdftvkHTFnq88nIua7Mui563MD1sC3AO6+fcAUR +ap8lTwEpcOPlDOHqWnzcSbvBHiqB9RZLcpHIojG5qtr8nR/zXUACE/xOHAbKsxSQ +VBcZEhrxH9cMaVr2cXj0lH2RC47skFSOvG+hTKv8dGT9cZr4QQehzZHkPJrgmzI5 +c6sq1WnIeJEmMX3ixzDx/BR4dxIOE/TdFpS/S2d7cFOFyrC78zhNLJA5wA3CXWvp +4uXViI3WLL+rG761KIcSF3Ru/H38j9CHJrAb+7lsq+KePRXBOy5nAliRn+/4Qh8s +t2j1da3Ptfb/EX3C8CSlrdP6oDyp+l3cpaDvRKS+1ujl5BOWF3sGPjLtx7dCvHaj +2GU4Kzg1USEODm8uNBNA4StnDG1KQTAYI1oyVZnJF+A83vbsea0rWBmirSwiGpWO +vpaQXUJXxPkUAzUrHC1RVwinOt4/5Mi0A3PCwSaAuwtCH60NryZy2sy+s6ODWA2C +xR9GUeOcGMyNm43sSet1UNWMKFnKdDTajAshqx7qG+XH/RU+wBeq+yNuJkbL+vmx +cmtpzyKEC2IPrNkZAJSidjzULZrtBJ4tBmIQN1IchXIbJ+XMxjHsN+xjWZsLHXbM +fjKaiJUINlK73nZfdklJrX+9ZSCyycErdhh2n1ax +-----END CERTIFICATE----- + +# Issuer: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036 +# Subject: CN=Certigna Root CA O=Dhimyotis OU=0002 48146308100036 +# Label: "Certigna Root CA" +# Serial: 269714418870597844693661054334862075617 +# MD5 Fingerprint: 0e:5c:30:62:27:eb:5b:bc:d7:ae:62:ba:e9:d5:df:77 +# SHA1 Fingerprint: 2d:0d:52:14:ff:9e:ad:99:24:01:74:20:47:6e:6c:85:27:27:f5:43 +# SHA256 Fingerprint: d4:8d:3d:23:ee:db:50:a4:59:e5:51:97:60:1c:27:77:4b:9d:7b:18:c9:4d:5a:05:95:11:a1:02:50:b9:31:68 +-----BEGIN CERTIFICATE----- +MIIGWzCCBEOgAwIBAgIRAMrpG4nxVQMNo+ZBbcTjpuEwDQYJKoZIhvcNAQELBQAw +WjELMAkGA1UEBhMCRlIxEjAQBgNVBAoMCURoaW15b3RpczEcMBoGA1UECwwTMDAw +MiA0ODE0NjMwODEwMDAzNjEZMBcGA1UEAwwQQ2VydGlnbmEgUm9vdCBDQTAeFw0x +MzEwMDEwODMyMjdaFw0zMzEwMDEwODMyMjdaMFoxCzAJBgNVBAYTAkZSMRIwEAYD +VQQKDAlEaGlteW90aXMxHDAaBgNVBAsMEzAwMDIgNDgxNDYzMDgxMDAwMzYxGTAX +BgNVBAMMEENlcnRpZ25hIFJvb3QgQ0EwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAw +ggIKAoICAQDNGDllGlmx6mQWDoyUJJV8g9PFOSbcDO8WV43X2KyjQn+Cyu3NW9sO +ty3tRQgXstmzy9YXUnIo245Onoq2C/mehJpNdt4iKVzSs9IGPjA5qXSjklYcoW9M +CiBtnyN6tMbaLOQdLNyzKNAT8kxOAkmhVECe5uUFoC2EyP+YbNDrihqECB63aCPu +I9Vwzm1RaRDuoXrC0SIxwoKF0vJVdlB8JXrJhFwLrN1CTivngqIkicuQstDuI7pm +TLtipPlTWmR7fJj6o0ieD5Wupxj0auwuA0Wv8HT4Ks16XdG+RCYyKfHx9WzMfgIh +C59vpD++nVPiz32pLHxYGpfhPTc3GGYo0kDFUYqMwy3OU4gkWGQwFsWq4NYKpkDf +ePb1BHxpE4S80dGnBs8B92jAqFe7OmGtBIyT46388NtEbVncSVmurJqZNjBBe3Yz +IoejwpKGbvlw7q6Hh5UbxHq9MfPU0uWZ/75I7HX1eBYdpnDBfzwboZL7z8g81sWT +Co/1VTp2lc5ZmIoJlXcymoO6LAQ6l73UL77XbJuiyn1tJslV1c/DeVIICZkHJC1k +JWumIWmbat10TWuXekG9qxf5kBdIjzb5LdXF2+6qhUVB+s06RbFo5jZMm5BX7CO5 +hwjCxAnxl4YqKE3idMDaxIzb3+KhF1nOJFl0Mdp//TBt2dzhauH8XwIDAQABo4IB +GjCCARYwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE +FBiHVuBud+4kNTxOc5of1uHieX4rMB8GA1UdIwQYMBaAFBiHVuBud+4kNTxOc5of +1uHieX4rMEQGA1UdIAQ9MDswOQYEVR0gADAxMC8GCCsGAQUFBwIBFiNodHRwczov +L3d3d3cuY2VydGlnbmEuZnIvYXV0b3JpdGVzLzBtBgNVHR8EZjBkMC+gLaArhilo +dHRwOi8vY3JsLmNlcnRpZ25hLmZyL2NlcnRpZ25hcm9vdGNhLmNybDAxoC+gLYYr +aHR0cDovL2NybC5kaGlteW90aXMuY29tL2NlcnRpZ25hcm9vdGNhLmNybDANBgkq +hkiG9w0BAQsFAAOCAgEAlLieT/DjlQgi581oQfccVdV8AOItOoldaDgvUSILSo3L +6btdPrtcPbEo/uRTVRPPoZAbAh1fZkYJMyjhDSSXcNMQH+pkV5a7XdrnxIxPTGRG +HVyH41neQtGbqH6mid2PHMkwgu07nM3A6RngatgCdTer9zQoKJHyBApPNeNgJgH6 +0BGM+RFq7q89w1DTj18zeTyGqHNFkIwgtnJzFyO+B2XleJINugHA64wcZr+shncB +lA2c5uk5jR+mUYyZDDl34bSb+hxnV29qao6pK0xXeXpXIs/NX2NGjVxZOob4Mkdi +o2cNGJHc+6Zr9UhhcyNZjgKnvETq9Emd8VRY+WCv2hikLyhF3HqgiIZd8zvn/yk1 +gPxkQ5Tm4xxvvq0OKmOZK8l+hfZx6AYDlf7ej0gcWtSS6Cvu5zHbugRqh5jnxV/v +faci9wHYTfmJ0A6aBVmknpjZbyvKcL5kwlWj9Omvw5Ip3IgWJJk8jSaYtlu3zM63 +Nwf9JtmYhST/WSMDmu2dnajkXjjO11INb9I/bbEFa0nOipFGc/T2L/Coc3cOZayh +jWZSaX5LaAzHHjcng6WMxwLkFM1JAbBzs/3GkDpv0mztO+7skb6iQ12LAEpmJURw +3kAP+HwV96LOPNdeE4yBFxgX0b3xdxA61GU5wSesVywlVP+i2k+KYTlerj1KjL0= +-----END CERTIFICATE----- + +# Issuer: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI +# Subject: CN=emSign Root CA - G1 O=eMudhra Technologies Limited OU=emSign PKI +# Label: "emSign Root CA - G1" +# Serial: 235931866688319308814040 +# MD5 Fingerprint: 9c:42:84:57:dd:cb:0b:a7:2e:95:ad:b6:f3:da:bc:ac +# SHA1 Fingerprint: 8a:c7:ad:8f:73:ac:4e:c1:b5:75:4d:a5:40:f4:fc:cf:7c:b5:8e:8c +# SHA256 Fingerprint: 40:f6:af:03:46:a9:9a:a1:cd:1d:55:5a:4e:9c:ce:62:c7:f9:63:46:03:ee:40:66:15:83:3d:c8:c8:d0:03:67 +-----BEGIN CERTIFICATE----- +MIIDlDCCAnygAwIBAgIKMfXkYgxsWO3W2DANBgkqhkiG9w0BAQsFADBnMQswCQYD +VQQGEwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBU +ZWNobm9sb2dpZXMgTGltaXRlZDEcMBoGA1UEAxMTZW1TaWduIFJvb3QgQ0EgLSBH +MTAeFw0xODAyMTgxODMwMDBaFw00MzAyMTgxODMwMDBaMGcxCzAJBgNVBAYTAklO +MRMwEQYDVQQLEwplbVNpZ24gUEtJMSUwIwYDVQQKExxlTXVkaHJhIFRlY2hub2xv +Z2llcyBMaW1pdGVkMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEcxMIIBIjAN +BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAk0u76WaK7p1b1TST0Bsew+eeuGQz +f2N4aLTNLnF115sgxk0pvLZoYIr3IZpWNVrzdr3YzZr/k1ZLpVkGoZM0Kd0WNHVO +8oG0x5ZOrRkVUkr+PHB1cM2vK6sVmjM8qrOLqs1D/fXqcP/tzxE7lM5OMhbTI0Aq +d7OvPAEsbO2ZLIvZTmmYsvePQbAyeGHWDV/D+qJAkh1cF+ZwPjXnorfCYuKrpDhM +tTk1b+oDafo6VGiFbdbyL0NVHpENDtjVaqSW0RM8LHhQ6DqS0hdW5TUaQBw+jSzt +Od9C4INBdN+jzcKGYEho42kLVACL5HZpIQ15TjQIXhTCzLG3rdd8cIrHhQIDAQAB +o0IwQDAdBgNVHQ4EFgQU++8Nhp6w492pufEhF38+/PB3KxowDgYDVR0PAQH/BAQD +AgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEBAFn/8oz1h31x +PaOfG1vR2vjTnGs2vZupYeveFix0PZ7mddrXuqe8QhfnPZHr5X3dPpzxz5KsbEjM +wiI/aTvFthUvozXGaCocV685743QNcMYDHsAVhzNixl03r4PEuDQqqE/AjSxcM6d +GNYIAwlG7mDgfrbESQRRfXBgvKqy/3lyeqYdPV8q+Mri/Tm3R7nrft8EI6/6nAYH +6ftjk4BAtcZsCjEozgyfz7MjNYBBjWzEN3uBL4ChQEKF6dk4jeihU80Bv2noWgby +RQuQ+q7hv53yrlc8pa6yVvSLZUDp/TGBLPQ5Cdjua6e0ph0VpZj3AYHYhX3zUVxx +iN66zB+Afko= +-----END CERTIFICATE----- + +# Issuer: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI +# Subject: CN=emSign ECC Root CA - G3 O=eMudhra Technologies Limited OU=emSign PKI +# Label: "emSign ECC Root CA - G3" +# Serial: 287880440101571086945156 +# MD5 Fingerprint: ce:0b:72:d1:9f:88:8e:d0:50:03:e8:e3:b8:8b:67:40 +# SHA1 Fingerprint: 30:43:fa:4f:f2:57:dc:a0:c3:80:ee:2e:58:ea:78:b2:3f:e6:bb:c1 +# SHA256 Fingerprint: 86:a1:ec:ba:08:9c:4a:8d:3b:be:27:34:c6:12:ba:34:1d:81:3e:04:3c:f9:e8:a8:62:cd:5c:57:a3:6b:be:6b +-----BEGIN CERTIFICATE----- +MIICTjCCAdOgAwIBAgIKPPYHqWhwDtqLhDAKBggqhkjOPQQDAzBrMQswCQYDVQQG +EwJJTjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNo +bm9sb2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0g +RzMwHhcNMTgwMjE4MTgzMDAwWhcNNDMwMjE4MTgzMDAwWjBrMQswCQYDVQQGEwJJ +TjETMBEGA1UECxMKZW1TaWduIFBLSTElMCMGA1UEChMcZU11ZGhyYSBUZWNobm9s +b2dpZXMgTGltaXRlZDEgMB4GA1UEAxMXZW1TaWduIEVDQyBSb290IENBIC0gRzMw +djAQBgcqhkjOPQIBBgUrgQQAIgNiAAQjpQy4LRL1KPOxst3iAhKAnjlfSU2fySU0 +WXTsuwYc58Byr+iuL+FBVIcUqEqy6HyC5ltqtdyzdc6LBtCGI79G1Y4PPwT01xyS +fvalY8L1X44uT6EYGQIrMgqCZH0Wk9GjQjBAMB0GA1UdDgQWBBR8XQKEE9TMipuB +zhccLikenEhjQjAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAKBggq +hkjOPQQDAwNpADBmAjEAvvNhzwIQHWSVB7gYboiFBS+DCBeQyh+KTOgNG3qxrdWB +CUfvO6wIBHxcmbHtRwfSAjEAnbpV/KlK6O3t5nYBQnvI+GDZjVGLVTv7jHvrZQnD ++JbNR6iC8hZVdyR+EhCVBCyj +-----END CERTIFICATE----- + +# Issuer: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI +# Subject: CN=emSign Root CA - C1 O=eMudhra Inc OU=emSign PKI +# Label: "emSign Root CA - C1" +# Serial: 825510296613316004955058 +# MD5 Fingerprint: d8:e3:5d:01:21:fa:78:5a:b0:df:ba:d2:ee:2a:5f:68 +# SHA1 Fingerprint: e7:2e:f1:df:fc:b2:09:28:cf:5d:d4:d5:67:37:b1:51:cb:86:4f:01 +# SHA256 Fingerprint: 12:56:09:aa:30:1d:a0:a2:49:b9:7a:82:39:cb:6a:34:21:6f:44:dc:ac:9f:39:54:b1:42:92:f2:e8:c8:60:8f +-----BEGIN CERTIFICATE----- +MIIDczCCAlugAwIBAgILAK7PALrEzzL4Q7IwDQYJKoZIhvcNAQELBQAwVjELMAkG +A1UEBhMCVVMxEzARBgNVBAsTCmVtU2lnbiBQS0kxFDASBgNVBAoTC2VNdWRocmEg +SW5jMRwwGgYDVQQDExNlbVNpZ24gUm9vdCBDQSAtIEMxMB4XDTE4MDIxODE4MzAw +MFoXDTQzMDIxODE4MzAwMFowVjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln +biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMRwwGgYDVQQDExNlbVNpZ24gUm9v +dCBDQSAtIEMxMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAz+upufGZ +BczYKCFK83M0UYRWEPWgTywS4/oTmifQz/l5GnRfHXk5/Fv4cI7gklL35CX5VIPZ +HdPIWoU/Xse2B+4+wM6ar6xWQio5JXDWv7V7Nq2s9nPczdcdioOl+yuQFTdrHCZH +3DspVpNqs8FqOp099cGXOFgFixwR4+S0uF2FHYP+eF8LRWgYSKVGczQ7/g/IdrvH +GPMF0Ybzhe3nudkyrVWIzqa2kbBPrH4VI5b2P/AgNBbeCsbEBEV5f6f9vtKppa+c +xSMq9zwhbL2vj07FOrLzNBL834AaSaTUqZX3noleoomslMuoaJuvimUnzYnu3Yy1 +aylwQ6BpC+S5DwIDAQABo0IwQDAdBgNVHQ4EFgQU/qHgcB4qAzlSWkK+XJGFehiq +TbUwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEL +BQADggEBAMJKVvoVIXsoounlHfv4LcQ5lkFMOycsxGwYFYDGrK9HWS8mC+M2sO87 +/kOXSTKZEhVb3xEp/6tT+LvBeA+snFOvV71ojD1pM/CjoCNjO2RnIkSt1XHLVip4 +kqNPEjE2NuLe/gDEo2APJ62gsIq1NnpSob0n9CAnYuhNlCQT5AoE6TyrLshDCUrG +YQTlSTR+08TI9Q/Aqum6VF7zYytPT1DU/rl7mYw9wC68AivTxEDkigcxHpvOJpkT ++xHqmiIMERnHXhuBUDDIlhJu58tBf5E7oke3VIAb3ADMmpDqw8NQBmIMMMAVSKeo +WXzhriKi4gp6D/piq1JM4fHfyr6DDUI= +-----END CERTIFICATE----- + +# Issuer: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI +# Subject: CN=emSign ECC Root CA - C3 O=eMudhra Inc OU=emSign PKI +# Label: "emSign ECC Root CA - C3" +# Serial: 582948710642506000014504 +# MD5 Fingerprint: 3e:53:b3:a3:81:ee:d7:10:f8:d3:b0:1d:17:92:f5:d5 +# SHA1 Fingerprint: b6:af:43:c2:9b:81:53:7d:f6:ef:6b:c3:1f:1f:60:15:0c:ee:48:66 +# SHA256 Fingerprint: bc:4d:80:9b:15:18:9d:78:db:3e:1d:8c:f4:f9:72:6a:79:5d:a1:64:3c:a5:f1:35:8e:1d:db:0e:dc:0d:7e:b3 +-----BEGIN CERTIFICATE----- +MIICKzCCAbGgAwIBAgIKe3G2gla4EnycqDAKBggqhkjOPQQDAzBaMQswCQYDVQQG +EwJVUzETMBEGA1UECxMKZW1TaWduIFBLSTEUMBIGA1UEChMLZU11ZGhyYSBJbmMx +IDAeBgNVBAMTF2VtU2lnbiBFQ0MgUm9vdCBDQSAtIEMzMB4XDTE4MDIxODE4MzAw +MFoXDTQzMDIxODE4MzAwMFowWjELMAkGA1UEBhMCVVMxEzARBgNVBAsTCmVtU2ln +biBQS0kxFDASBgNVBAoTC2VNdWRocmEgSW5jMSAwHgYDVQQDExdlbVNpZ24gRUND +IFJvb3QgQ0EgLSBDMzB2MBAGByqGSM49AgEGBSuBBAAiA2IABP2lYa57JhAd6bci +MK4G9IGzsUJxlTm801Ljr6/58pc1kjZGDoeVjbk5Wum739D+yAdBPLtVb4Ojavti +sIGJAnB9SMVK4+kiVCJNk7tCDK93nCOmfddhEc5lx/h//vXyqaNCMEAwHQYDVR0O +BBYEFPtaSNCAIEDyqOkAB2kZd6fmw/TPMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMB +Af8EBTADAQH/MAoGCCqGSM49BAMDA2gAMGUCMQC02C8Cif22TGK6Q04ThHK1rt0c +3ta13FaPWEBaLd4gTCKDypOofu4SQMfWh0/434UCMBwUZOR8loMRnLDRWmFLpg9J +0wD8ofzkpf9/rdcw0Md3f76BB1UwUCAU9Vc4CqgxUQ== +-----END CERTIFICATE----- + +# Issuer: CN=Hongkong Post Root CA 3 O=Hongkong Post +# Subject: CN=Hongkong Post Root CA 3 O=Hongkong Post +# Label: "Hongkong Post Root CA 3" +# Serial: 46170865288971385588281144162979347873371282084 +# MD5 Fingerprint: 11:fc:9f:bd:73:30:02:8a:fd:3f:f3:58:b9:cb:20:f0 +# SHA1 Fingerprint: 58:a2:d0:ec:20:52:81:5b:c1:f3:f8:64:02:24:4e:c2:8e:02:4b:02 +# SHA256 Fingerprint: 5a:2f:c0:3f:0c:83:b0:90:bb:fa:40:60:4b:09:88:44:6c:76:36:18:3d:f9:84:6e:17:10:1a:44:7f:b8:ef:d6 +-----BEGIN CERTIFICATE----- +MIIFzzCCA7egAwIBAgIUCBZfikyl7ADJk0DfxMauI7gcWqQwDQYJKoZIhvcNAQEL +BQAwbzELMAkGA1UEBhMCSEsxEjAQBgNVBAgTCUhvbmcgS29uZzESMBAGA1UEBxMJ +SG9uZyBLb25nMRYwFAYDVQQKEw1Ib25na29uZyBQb3N0MSAwHgYDVQQDExdIb25n +a29uZyBQb3N0IFJvb3QgQ0EgMzAeFw0xNzA2MDMwMjI5NDZaFw00MjA2MDMwMjI5 +NDZaMG8xCzAJBgNVBAYTAkhLMRIwEAYDVQQIEwlIb25nIEtvbmcxEjAQBgNVBAcT +CUhvbmcgS29uZzEWMBQGA1UEChMNSG9uZ2tvbmcgUG9zdDEgMB4GA1UEAxMXSG9u +Z2tvbmcgUG9zdCBSb290IENBIDMwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIK +AoICAQCziNfqzg8gTr7m1gNt7ln8wlffKWihgw4+aMdoWJwcYEuJQwy51BWy7sFO +dem1p+/l6TWZ5Mwc50tfjTMwIDNT2aa71T4Tjukfh0mtUC1Qyhi+AViiE3CWu4mI +VoBc+L0sPOFMV4i707mV78vH9toxdCim5lSJ9UExyuUmGs2C4HDaOym71QP1mbpV +9WTRYA6ziUm4ii8F0oRFKHyPaFASePwLtVPLwpgchKOesL4jpNrcyCse2m5FHomY +2vkALgbpDDtw1VAliJnLzXNg99X/NWfFobxeq81KuEXryGgeDQ0URhLj0mRiikKY +vLTGCAj4/ahMZJx2Ab0vqWwzD9g/KLg8aQFChn5pwckGyuV6RmXpwtZQQS4/t+Tt +bNe/JgERohYpSms0BpDsE9K2+2p20jzt8NYt3eEV7KObLyzJPivkaTv/ciWxNoZb +x39ri1UbSsUgYT2uy1DhCDq+sI9jQVMwCFk8mB13umOResoQUGC/8Ne8lYePl8X+ +l2oBlKN8W4UdKjk60FSh0Tlxnf0h+bV78OLgAo9uliQlLKAeLKjEiafv7ZkGL7YK +TE/bosw3Gq9HhS2KX8Q0NEwA/RiTZxPRN+ZItIsGxVd7GYYKecsAyVKvQv83j+Gj +Hno9UKtjBucVtT+2RTeUN7F+8kjDf8V1/peNRY8apxpyKBpADwIDAQABo2MwYTAP +BgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAfBgNVHSMEGDAWgBQXnc0e +i9Y5K3DTXNSguB+wAPzFYTAdBgNVHQ4EFgQUF53NHovWOStw01zUoLgfsAD8xWEw +DQYJKoZIhvcNAQELBQADggIBAFbVe27mIgHSQpsY1Q7XZiNc4/6gx5LS6ZStS6LG +7BJ8dNVI0lkUmcDrudHr9EgwW62nV3OZqdPlt9EuWSRY3GguLmLYauRwCy0gUCCk +MpXRAJi70/33MvJJrsZ64Ee+bs7Lo3I6LWldy8joRTnU+kLBEUx3XZL7av9YROXr +gZ6voJmtvqkBZss4HTzfQx/0TW60uhdG/H39h4F5ag0zD/ov+BS5gLNdTaqX4fnk +GMX41TiMJjz98iji7lpJiCzfeT2OnpA8vUFKOt1b9pq0zj8lMH8yfaIDlNDceqFS +3m6TjRgm/VWsvY+b0s+v54Ysyx8Jb6NvqYTUc79NoXQbTiNg8swOqn+knEwlqLJm +Ozj/2ZQw9nKEvmhVEA/GcywWaZMH/rFF7buiVWqw2rVKAiUnhde3t4ZEFolsgCs+ +l6mc1X5VTMbeRRAc6uk7nwNT7u56AQIWeNTowr5GdogTPyK7SBIdUgC0An4hGh6c +JfTzPV4e0hz5sy229zdcxsshTrD3mUcYhcErulWuBurQB7Lcq9CClnXO0lD+mefP +L5/ndtFhKvshuzHQqp9HpLIiyhY6UFfEW0NnxWViA0kB60PZ2Pierc+xYw5F9KBa +LJstxabArahH9CdMOA0uG0k7UvToiIMrVCjU8jVStDKDYmlkDJGcn5fqdBb9HxEG +mpv0 +-----END CERTIFICATE----- diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/core.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/core.py new file mode 100644 index 0000000000000000000000000000000000000000..7271acf40ee1e1f6bcba51cc620b6f07c8bfe044 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/certifi/core.py @@ -0,0 +1,15 @@ +# -*- coding: utf-8 -*- + +""" +certifi.py +~~~~~~~~~~ + +This module returns the installation location of cacert.pem. +""" +import os + + +def where(): + f = os.path.dirname(__file__) + + return os.path.join(f, 'cacert.pem') diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..0f9f820ef6e5f21042efd0e9dc18d097388d7207 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/__init__.py @@ -0,0 +1,39 @@ +######################## BEGIN LICENSE BLOCK ######################## +# 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 .compat import PY2, PY3 +from .universaldetector import UniversalDetector +from .version import __version__, VERSION + + +def detect(byte_str): + """ + Detect the encoding of the given byte string. + + :param byte_str: The byte sequence to examine. + :type byte_str: ``bytes`` or ``bytearray`` + """ + if not isinstance(byte_str, bytearray): + if not isinstance(byte_str, bytes): + raise TypeError('Expected object of type bytes or bytearray, got: ' + '{0}'.format(type(byte_str))) + else: + byte_str = bytearray(byte_str) + detector = UniversalDetector() + detector.feed(byte_str) + return detector.close() diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/big5freq.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/big5freq.py new file mode 100644 index 0000000000000000000000000000000000000000..38f32517aa8f6cf5970f7ceddd1a415289184c3e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/big5freq.py @@ -0,0 +1,386 @@ +######################## 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 ######################### + +# Big5 frequency table +# by Taiwan's Mandarin Promotion Council +# +# +# 128 --> 0.42261 +# 256 --> 0.57851 +# 512 --> 0.74851 +# 1024 --> 0.89384 +# 2048 --> 0.97583 +# +# Ideal 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 + +BIG5_TYPICAL_DISTRIBUTION_RATIO = 0.75 + +#Char to FreqOrder table +BIG5_TABLE_SIZE = 5376 + +BIG5_CHAR_TO_FREQ_ORDER = ( + 1,1801,1506, 255,1431, 198, 9, 82, 6,5008, 177, 202,3681,1256,2821, 110, # 16 +3814, 33,3274, 261, 76, 44,2114, 16,2946,2187,1176, 659,3971, 26,3451,2653, # 32 +1198,3972,3350,4202, 410,2215, 302, 590, 361,1964, 8, 204, 58,4510,5009,1932, # 48 + 63,5010,5011, 317,1614, 75, 222, 159,4203,2417,1480,5012,3555,3091, 224,2822, # 64 +3682, 3, 10,3973,1471, 29,2787,1135,2866,1940, 873, 130,3275,1123, 312,5013, # 80 +4511,2052, 507, 252, 682,5014, 142,1915, 124, 206,2947, 34,3556,3204, 64, 604, # 96 +5015,2501,1977,1978, 155,1991, 645, 641,1606,5016,3452, 337, 72, 406,5017, 80, # 112 + 630, 238,3205,1509, 263, 939,1092,2654, 756,1440,1094,3453, 449, 69,2987, 591, # 128 + 179,2096, 471, 115,2035,1844, 60, 50,2988, 134, 806,1869, 734,2036,3454, 180, # 144 + 995,1607, 156, 537,2907, 688,5018, 319,1305, 779,2145, 514,2379, 298,4512, 359, # 160 +2502, 90,2716,1338, 663, 11, 906,1099,2553, 20,2441, 182, 532,1716,5019, 732, # 176 +1376,4204,1311,1420,3206, 25,2317,1056, 113, 399, 382,1950, 242,3455,2474, 529, # 192 +3276, 475,1447,3683,5020, 117, 21, 656, 810,1297,2300,2334,3557,5021, 126,4205, # 208 + 706, 456, 150, 613,4513, 71,1118,2037,4206, 145,3092, 85, 835, 486,2115,1246, # 224 +1426, 428, 727,1285,1015, 800, 106, 623, 303,1281,5022,2128,2359, 347,3815, 221, # 240 +3558,3135,5023,1956,1153,4207, 83, 296,1199,3093, 192, 624, 93,5024, 822,1898, # 256 +2823,3136, 795,2065, 991,1554,1542,1592, 27, 43,2867, 859, 139,1456, 860,4514, # 272 + 437, 712,3974, 164,2397,3137, 695, 211,3037,2097, 195,3975,1608,3559,3560,3684, # 288 +3976, 234, 811,2989,2098,3977,2233,1441,3561,1615,2380, 668,2077,1638, 305, 228, # 304 +1664,4515, 467, 415,5025, 262,2099,1593, 239, 108, 300, 200,1033, 512,1247,2078, # 320 +5026,5027,2176,3207,3685,2682, 593, 845,1062,3277, 88,1723,2038,3978,1951, 212, # 336 + 266, 152, 149, 468,1899,4208,4516, 77, 187,5028,3038, 37, 5,2990,5029,3979, # 352 +5030,5031, 39,2524,4517,2908,3208,2079, 55, 148, 74,4518, 545, 483,1474,1029, # 368 +1665, 217,1870,1531,3138,1104,2655,4209, 24, 172,3562, 900,3980,3563,3564,4519, # 384 + 32,1408,2824,1312, 329, 487,2360,2251,2717, 784,2683, 4,3039,3351,1427,1789, # 400 + 188, 109, 499,5032,3686,1717,1790, 888,1217,3040,4520,5033,3565,5034,3352,1520, # 416 +3687,3981, 196,1034, 775,5035,5036, 929,1816, 249, 439, 38,5037,1063,5038, 794, # 432 +3982,1435,2301, 46, 178,3278,2066,5039,2381,5040, 214,1709,4521, 804, 35, 707, # 448 + 324,3688,1601,2554, 140, 459,4210,5041,5042,1365, 839, 272, 978,2262,2580,3456, # 464 +2129,1363,3689,1423, 697, 100,3094, 48, 70,1231, 495,3139,2196,5043,1294,5044, # 480 +2080, 462, 586,1042,3279, 853, 256, 988, 185,2382,3457,1698, 434,1084,5045,3458, # 496 + 314,2625,2788,4522,2335,2336, 569,2285, 637,1817,2525, 757,1162,1879,1616,3459, # 512 + 287,1577,2116, 768,4523,1671,2868,3566,2526,1321,3816, 909,2418,5046,4211, 933, # 528 +3817,4212,2053,2361,1222,4524, 765,2419,1322, 786,4525,5047,1920,1462,1677,2909, # 544 +1699,5048,4526,1424,2442,3140,3690,2600,3353,1775,1941,3460,3983,4213, 309,1369, # 560 +1130,2825, 364,2234,1653,1299,3984,3567,3985,3986,2656, 525,1085,3041, 902,2001, # 576 +1475, 964,4527, 421,1845,1415,1057,2286, 940,1364,3141, 376,4528,4529,1381, 7, # 592 +2527, 983,2383, 336,1710,2684,1846, 321,3461, 559,1131,3042,2752,1809,1132,1313, # 608 + 265,1481,1858,5049, 352,1203,2826,3280, 167,1089, 420,2827, 776, 792,1724,3568, # 624 +4214,2443,3281,5050,4215,5051, 446, 229, 333,2753, 901,3818,1200,1557,4530,2657, # 640 +1921, 395,2754,2685,3819,4216,1836, 125, 916,3209,2626,4531,5052,5053,3820,5054, # 656 +5055,5056,4532,3142,3691,1133,2555,1757,3462,1510,2318,1409,3569,5057,2146, 438, # 672 +2601,2910,2384,3354,1068, 958,3043, 461, 311,2869,2686,4217,1916,3210,4218,1979, # 688 + 383, 750,2755,2627,4219, 274, 539, 385,1278,1442,5058,1154,1965, 384, 561, 210, # 704 + 98,1295,2556,3570,5059,1711,2420,1482,3463,3987,2911,1257, 129,5060,3821, 642, # 720 + 523,2789,2790,2658,5061, 141,2235,1333, 68, 176, 441, 876, 907,4220, 603,2602, # 736 + 710, 171,3464, 404, 549, 18,3143,2398,1410,3692,1666,5062,3571,4533,2912,4534, # 752 +5063,2991, 368,5064, 146, 366, 99, 871,3693,1543, 748, 807,1586,1185, 22,2263, # 768 + 379,3822,3211,5065,3212, 505,1942,2628,1992,1382,2319,5066, 380,2362, 218, 702, # 784 +1818,1248,3465,3044,3572,3355,3282,5067,2992,3694, 930,3283,3823,5068, 59,5069, # 800 + 585, 601,4221, 497,3466,1112,1314,4535,1802,5070,1223,1472,2177,5071, 749,1837, # 816 + 690,1900,3824,1773,3988,1476, 429,1043,1791,2236,2117, 917,4222, 447,1086,1629, # 832 +5072, 556,5073,5074,2021,1654, 844,1090, 105, 550, 966,1758,2828,1008,1783, 686, # 848 +1095,5075,2287, 793,1602,5076,3573,2603,4536,4223,2948,2302,4537,3825, 980,2503, # 864 + 544, 353, 527,4538, 908,2687,2913,5077, 381,2629,1943,1348,5078,1341,1252, 560, # 880 +3095,5079,3467,2870,5080,2054, 973, 886,2081, 143,4539,5081,5082, 157,3989, 496, # 896 +4224, 57, 840, 540,2039,4540,4541,3468,2118,1445, 970,2264,1748,1966,2082,4225, # 912 +3144,1234,1776,3284,2829,3695, 773,1206,2130,1066,2040,1326,3990,1738,1725,4226, # 928 + 279,3145, 51,1544,2604, 423,1578,2131,2067, 173,4542,1880,5083,5084,1583, 264, # 944 + 610,3696,4543,2444, 280, 154,5085,5086,5087,1739, 338,1282,3096, 693,2871,1411, # 960 +1074,3826,2445,5088,4544,5089,5090,1240, 952,2399,5091,2914,1538,2688, 685,1483, # 976 +4227,2475,1436, 953,4228,2055,4545, 671,2400, 79,4229,2446,3285, 608, 567,2689, # 992 +3469,4230,4231,1691, 393,1261,1792,2401,5092,4546,5093,5094,5095,5096,1383,1672, # 1008 +3827,3213,1464, 522,1119, 661,1150, 216, 675,4547,3991,1432,3574, 609,4548,2690, # 1024 +2402,5097,5098,5099,4232,3045, 0,5100,2476, 315, 231,2447, 301,3356,4549,2385, # 1040 +5101, 233,4233,3697,1819,4550,4551,5102, 96,1777,1315,2083,5103, 257,5104,1810, # 1056 +3698,2718,1139,1820,4234,2022,1124,2164,2791,1778,2659,5105,3097, 363,1655,3214, # 1072 +5106,2993,5107,5108,5109,3992,1567,3993, 718, 103,3215, 849,1443, 341,3357,2949, # 1088 +1484,5110,1712, 127, 67, 339,4235,2403, 679,1412, 821,5111,5112, 834, 738, 351, # 1104 +2994,2147, 846, 235,1497,1881, 418,1993,3828,2719, 186,1100,2148,2756,3575,1545, # 1120 +1355,2950,2872,1377, 583,3994,4236,2581,2995,5113,1298,3699,1078,2557,3700,2363, # 1136 + 78,3829,3830, 267,1289,2100,2002,1594,4237, 348, 369,1274,2197,2178,1838,4552, # 1152 +1821,2830,3701,2757,2288,2003,4553,2951,2758, 144,3358, 882,4554,3995,2759,3470, # 1168 +4555,2915,5114,4238,1726, 320,5115,3996,3046, 788,2996,5116,2831,1774,1327,2873, # 1184 +3997,2832,5117,1306,4556,2004,1700,3831,3576,2364,2660, 787,2023, 506, 824,3702, # 1200 + 534, 323,4557,1044,3359,2024,1901, 946,3471,5118,1779,1500,1678,5119,1882,4558, # 1216 + 165, 243,4559,3703,2528, 123, 683,4239, 764,4560, 36,3998,1793, 589,2916, 816, # 1232 + 626,1667,3047,2237,1639,1555,1622,3832,3999,5120,4000,2874,1370,1228,1933, 891, # 1248 +2084,2917, 304,4240,5121, 292,2997,2720,3577, 691,2101,4241,1115,4561, 118, 662, # 1264 +5122, 611,1156, 854,2386,1316,2875, 2, 386, 515,2918,5123,5124,3286, 868,2238, # 1280 +1486, 855,2661, 785,2216,3048,5125,1040,3216,3578,5126,3146, 448,5127,1525,5128, # 1296 +2165,4562,5129,3833,5130,4242,2833,3579,3147, 503, 818,4001,3148,1568, 814, 676, # 1312 +1444, 306,1749,5131,3834,1416,1030, 197,1428, 805,2834,1501,4563,5132,5133,5134, # 1328 +1994,5135,4564,5136,5137,2198, 13,2792,3704,2998,3149,1229,1917,5138,3835,2132, # 1344 +5139,4243,4565,2404,3580,5140,2217,1511,1727,1120,5141,5142, 646,3836,2448, 307, # 1360 +5143,5144,1595,3217,5145,5146,5147,3705,1113,1356,4002,1465,2529,2530,5148, 519, # 1376 +5149, 128,2133, 92,2289,1980,5150,4003,1512, 342,3150,2199,5151,2793,2218,1981, # 1392 +3360,4244, 290,1656,1317, 789, 827,2365,5152,3837,4566, 562, 581,4004,5153, 401, # 1408 +4567,2252, 94,4568,5154,1399,2794,5155,1463,2025,4569,3218,1944,5156, 828,1105, # 1424 +4245,1262,1394,5157,4246, 605,4570,5158,1784,2876,5159,2835, 819,2102, 578,2200, # 1440 +2952,5160,1502, 436,3287,4247,3288,2836,4005,2919,3472,3473,5161,2721,2320,5162, # 1456 +5163,2337,2068, 23,4571, 193, 826,3838,2103, 699,1630,4248,3098, 390,1794,1064, # 1472 +3581,5164,1579,3099,3100,1400,5165,4249,1839,1640,2877,5166,4572,4573, 137,4250, # 1488 + 598,3101,1967, 780, 104, 974,2953,5167, 278, 899, 253, 402, 572, 504, 493,1339, # 1504 +5168,4006,1275,4574,2582,2558,5169,3706,3049,3102,2253, 565,1334,2722, 863, 41, # 1520 +5170,5171,4575,5172,1657,2338, 19, 463,2760,4251, 606,5173,2999,3289,1087,2085, # 1536 +1323,2662,3000,5174,1631,1623,1750,4252,2691,5175,2878, 791,2723,2663,2339, 232, # 1552 +2421,5176,3001,1498,5177,2664,2630, 755,1366,3707,3290,3151,2026,1609, 119,1918, # 1568 +3474, 862,1026,4253,5178,4007,3839,4576,4008,4577,2265,1952,2477,5179,1125, 817, # 1584 +4254,4255,4009,1513,1766,2041,1487,4256,3050,3291,2837,3840,3152,5180,5181,1507, # 1600 +5182,2692, 733, 40,1632,1106,2879, 345,4257, 841,2531, 230,4578,3002,1847,3292, # 1616 +3475,5183,1263, 986,3476,5184, 735, 879, 254,1137, 857, 622,1300,1180,1388,1562, # 1632 +4010,4011,2954, 967,2761,2665,1349, 592,2134,1692,3361,3003,1995,4258,1679,4012, # 1648 +1902,2188,5185, 739,3708,2724,1296,1290,5186,4259,2201,2202,1922,1563,2605,2559, # 1664 +1871,2762,3004,5187, 435,5188, 343,1108, 596, 17,1751,4579,2239,3477,3709,5189, # 1680 +4580, 294,3582,2955,1693, 477, 979, 281,2042,3583, 643,2043,3710,2631,2795,2266, # 1696 +1031,2340,2135,2303,3584,4581, 367,1249,2560,5190,3585,5191,4582,1283,3362,2005, # 1712 + 240,1762,3363,4583,4584, 836,1069,3153, 474,5192,2149,2532, 268,3586,5193,3219, # 1728 +1521,1284,5194,1658,1546,4260,5195,3587,3588,5196,4261,3364,2693,1685,4262, 961, # 1744 +1673,2632, 190,2006,2203,3841,4585,4586,5197, 570,2504,3711,1490,5198,4587,2633, # 1760 +3293,1957,4588, 584,1514, 396,1045,1945,5199,4589,1968,2449,5200,5201,4590,4013, # 1776 + 619,5202,3154,3294, 215,2007,2796,2561,3220,4591,3221,4592, 763,4263,3842,4593, # 1792 +5203,5204,1958,1767,2956,3365,3712,1174, 452,1477,4594,3366,3155,5205,2838,1253, # 1808 +2387,2189,1091,2290,4264, 492,5206, 638,1169,1825,2136,1752,4014, 648, 926,1021, # 1824 +1324,4595, 520,4596, 997, 847,1007, 892,4597,3843,2267,1872,3713,2405,1785,4598, # 1840 +1953,2957,3103,3222,1728,4265,2044,3714,4599,2008,1701,3156,1551, 30,2268,4266, # 1856 +5207,2027,4600,3589,5208, 501,5209,4267, 594,3478,2166,1822,3590,3479,3591,3223, # 1872 + 829,2839,4268,5210,1680,3157,1225,4269,5211,3295,4601,4270,3158,2341,5212,4602, # 1888 +4271,5213,4015,4016,5214,1848,2388,2606,3367,5215,4603, 374,4017, 652,4272,4273, # 1904 + 375,1140, 798,5216,5217,5218,2366,4604,2269, 546,1659, 138,3051,2450,4605,5219, # 1920 +2254, 612,1849, 910, 796,3844,1740,1371, 825,3845,3846,5220,2920,2562,5221, 692, # 1936 + 444,3052,2634, 801,4606,4274,5222,1491, 244,1053,3053,4275,4276, 340,5223,4018, # 1952 +1041,3005, 293,1168, 87,1357,5224,1539, 959,5225,2240, 721, 694,4277,3847, 219, # 1968 +1478, 644,1417,3368,2666,1413,1401,1335,1389,4019,5226,5227,3006,2367,3159,1826, # 1984 + 730,1515, 184,2840, 66,4607,5228,1660,2958, 246,3369, 378,1457, 226,3480, 975, # 2000 +4020,2959,1264,3592, 674, 696,5229, 163,5230,1141,2422,2167, 713,3593,3370,4608, # 2016 +4021,5231,5232,1186, 15,5233,1079,1070,5234,1522,3224,3594, 276,1050,2725, 758, # 2032 +1126, 653,2960,3296,5235,2342, 889,3595,4022,3104,3007, 903,1250,4609,4023,3481, # 2048 +3596,1342,1681,1718, 766,3297, 286, 89,2961,3715,5236,1713,5237,2607,3371,3008, # 2064 +5238,2962,2219,3225,2880,5239,4610,2505,2533, 181, 387,1075,4024, 731,2190,3372, # 2080 +5240,3298, 310, 313,3482,2304, 770,4278, 54,3054, 189,4611,3105,3848,4025,5241, # 2096 +1230,1617,1850, 355,3597,4279,4612,3373, 111,4280,3716,1350,3160,3483,3055,4281, # 2112 +2150,3299,3598,5242,2797,4026,4027,3009, 722,2009,5243,1071, 247,1207,2343,2478, # 2128 +1378,4613,2010, 864,1437,1214,4614, 373,3849,1142,2220, 667,4615, 442,2763,2563, # 2144 +3850,4028,1969,4282,3300,1840, 837, 170,1107, 934,1336,1883,5244,5245,2119,4283, # 2160 +2841, 743,1569,5246,4616,4284, 582,2389,1418,3484,5247,1803,5248, 357,1395,1729, # 2176 +3717,3301,2423,1564,2241,5249,3106,3851,1633,4617,1114,2086,4285,1532,5250, 482, # 2192 +2451,4618,5251,5252,1492, 833,1466,5253,2726,3599,1641,2842,5254,1526,1272,3718, # 2208 +4286,1686,1795, 416,2564,1903,1954,1804,5255,3852,2798,3853,1159,2321,5256,2881, # 2224 +4619,1610,1584,3056,2424,2764, 443,3302,1163,3161,5257,5258,4029,5259,4287,2506, # 2240 +3057,4620,4030,3162,2104,1647,3600,2011,1873,4288,5260,4289, 431,3485,5261, 250, # 2256 + 97, 81,4290,5262,1648,1851,1558, 160, 848,5263, 866, 740,1694,5264,2204,2843, # 2272 +3226,4291,4621,3719,1687, 950,2479, 426, 469,3227,3720,3721,4031,5265,5266,1188, # 2288 + 424,1996, 861,3601,4292,3854,2205,2694, 168,1235,3602,4293,5267,2087,1674,4622, # 2304 +3374,3303, 220,2565,1009,5268,3855, 670,3010, 332,1208, 717,5269,5270,3603,2452, # 2320 +4032,3375,5271, 513,5272,1209,2882,3376,3163,4623,1080,5273,5274,5275,5276,2534, # 2336 +3722,3604, 815,1587,4033,4034,5277,3605,3486,3856,1254,4624,1328,3058,1390,4035, # 2352 +1741,4036,3857,4037,5278, 236,3858,2453,3304,5279,5280,3723,3859,1273,3860,4625, # 2368 +5281, 308,5282,4626, 245,4627,1852,2480,1307,2583, 430, 715,2137,2454,5283, 270, # 2384 + 199,2883,4038,5284,3606,2727,1753, 761,1754, 725,1661,1841,4628,3487,3724,5285, # 2400 +5286, 587, 14,3305, 227,2608, 326, 480,2270, 943,2765,3607, 291, 650,1884,5287, # 2416 +1702,1226, 102,1547, 62,3488, 904,4629,3489,1164,4294,5288,5289,1224,1548,2766, # 2432 + 391, 498,1493,5290,1386,1419,5291,2056,1177,4630, 813, 880,1081,2368, 566,1145, # 2448 +4631,2291,1001,1035,2566,2609,2242, 394,1286,5292,5293,2069,5294, 86,1494,1730, # 2464 +4039, 491,1588, 745, 897,2963, 843,3377,4040,2767,2884,3306,1768, 998,2221,2070, # 2480 + 397,1827,1195,1970,3725,3011,3378, 284,5295,3861,2507,2138,2120,1904,5296,4041, # 2496 +2151,4042,4295,1036,3490,1905, 114,2567,4296, 209,1527,5297,5298,2964,2844,2635, # 2512 +2390,2728,3164, 812,2568,5299,3307,5300,1559, 737,1885,3726,1210, 885, 28,2695, # 2528 +3608,3862,5301,4297,1004,1780,4632,5302, 346,1982,2222,2696,4633,3863,1742, 797, # 2544 +1642,4043,1934,1072,1384,2152, 896,4044,3308,3727,3228,2885,3609,5303,2569,1959, # 2560 +4634,2455,1786,5304,5305,5306,4045,4298,1005,1308,3728,4299,2729,4635,4636,1528, # 2576 +2610, 161,1178,4300,1983, 987,4637,1101,4301, 631,4046,1157,3229,2425,1343,1241, # 2592 +1016,2243,2570, 372, 877,2344,2508,1160, 555,1935, 911,4047,5307, 466,1170, 169, # 2608 +1051,2921,2697,3729,2481,3012,1182,2012,2571,1251,2636,5308, 992,2345,3491,1540, # 2624 +2730,1201,2071,2406,1997,2482,5309,4638, 528,1923,2191,1503,1874,1570,2369,3379, # 2640 +3309,5310, 557,1073,5311,1828,3492,2088,2271,3165,3059,3107, 767,3108,2799,4639, # 2656 +1006,4302,4640,2346,1267,2179,3730,3230, 778,4048,3231,2731,1597,2667,5312,4641, # 2672 +5313,3493,5314,5315,5316,3310,2698,1433,3311, 131, 95,1504,4049, 723,4303,3166, # 2688 +1842,3610,2768,2192,4050,2028,2105,3731,5317,3013,4051,1218,5318,3380,3232,4052, # 2704 +4304,2584, 248,1634,3864, 912,5319,2845,3732,3060,3865, 654, 53,5320,3014,5321, # 2720 +1688,4642, 777,3494,1032,4053,1425,5322, 191, 820,2121,2846, 971,4643, 931,3233, # 2736 + 135, 664, 783,3866,1998, 772,2922,1936,4054,3867,4644,2923,3234, 282,2732, 640, # 2752 +1372,3495,1127, 922, 325,3381,5323,5324, 711,2045,5325,5326,4055,2223,2800,1937, # 2768 +4056,3382,2224,2255,3868,2305,5327,4645,3869,1258,3312,4057,3235,2139,2965,4058, # 2784 +4059,5328,2225, 258,3236,4646, 101,1227,5329,3313,1755,5330,1391,3314,5331,2924, # 2800 +2057, 893,5332,5333,5334,1402,4305,2347,5335,5336,3237,3611,5337,5338, 878,1325, # 2816 +1781,2801,4647, 259,1385,2585, 744,1183,2272,4648,5339,4060,2509,5340, 684,1024, # 2832 +4306,5341, 472,3612,3496,1165,3315,4061,4062, 322,2153, 881, 455,1695,1152,1340, # 2848 + 660, 554,2154,4649,1058,4650,4307, 830,1065,3383,4063,4651,1924,5342,1703,1919, # 2864 +5343, 932,2273, 122,5344,4652, 947, 677,5345,3870,2637, 297,1906,1925,2274,4653, # 2880 +2322,3316,5346,5347,4308,5348,4309, 84,4310, 112, 989,5349, 547,1059,4064, 701, # 2896 +3613,1019,5350,4311,5351,3497, 942, 639, 457,2306,2456, 993,2966, 407, 851, 494, # 2912 +4654,3384, 927,5352,1237,5353,2426,3385, 573,4312, 680, 921,2925,1279,1875, 285, # 2928 + 790,1448,1984, 719,2168,5354,5355,4655,4065,4066,1649,5356,1541, 563,5357,1077, # 2944 +5358,3386,3061,3498, 511,3015,4067,4068,3733,4069,1268,2572,3387,3238,4656,4657, # 2960 +5359, 535,1048,1276,1189,2926,2029,3167,1438,1373,2847,2967,1134,2013,5360,4313, # 2976 +1238,2586,3109,1259,5361, 700,5362,2968,3168,3734,4314,5363,4315,1146,1876,1907, # 2992 +4658,2611,4070, 781,2427, 132,1589, 203, 147, 273,2802,2407, 898,1787,2155,4071, # 3008 +4072,5364,3871,2803,5365,5366,4659,4660,5367,3239,5368,1635,3872, 965,5369,1805, # 3024 +2699,1516,3614,1121,1082,1329,3317,4073,1449,3873, 65,1128,2848,2927,2769,1590, # 3040 +3874,5370,5371, 12,2668, 45, 976,2587,3169,4661, 517,2535,1013,1037,3240,5372, # 3056 +3875,2849,5373,3876,5374,3499,5375,2612, 614,1999,2323,3877,3110,2733,2638,5376, # 3072 +2588,4316, 599,1269,5377,1811,3735,5378,2700,3111, 759,1060, 489,1806,3388,3318, # 3088 +1358,5379,5380,2391,1387,1215,2639,2256, 490,5381,5382,4317,1759,2392,2348,5383, # 3104 +4662,3878,1908,4074,2640,1807,3241,4663,3500,3319,2770,2349, 874,5384,5385,3501, # 3120 +3736,1859, 91,2928,3737,3062,3879,4664,5386,3170,4075,2669,5387,3502,1202,1403, # 3136 +3880,2969,2536,1517,2510,4665,3503,2511,5388,4666,5389,2701,1886,1495,1731,4076, # 3152 +2370,4667,5390,2030,5391,5392,4077,2702,1216, 237,2589,4318,2324,4078,3881,4668, # 3168 +4669,2703,3615,3504, 445,4670,5393,5394,5395,5396,2771, 61,4079,3738,1823,4080, # 3184 +5397, 687,2046, 935, 925, 405,2670, 703,1096,1860,2734,4671,4081,1877,1367,2704, # 3200 +3389, 918,2106,1782,2483, 334,3320,1611,1093,4672, 564,3171,3505,3739,3390, 945, # 3216 +2641,2058,4673,5398,1926, 872,4319,5399,3506,2705,3112, 349,4320,3740,4082,4674, # 3232 +3882,4321,3741,2156,4083,4675,4676,4322,4677,2408,2047, 782,4084, 400, 251,4323, # 3248 +1624,5400,5401, 277,3742, 299,1265, 476,1191,3883,2122,4324,4325,1109, 205,5402, # 3264 +2590,1000,2157,3616,1861,5403,5404,5405,4678,5406,4679,2573, 107,2484,2158,4085, # 3280 +3507,3172,5407,1533, 541,1301, 158, 753,4326,2886,3617,5408,1696, 370,1088,4327, # 3296 +4680,3618, 579, 327, 440, 162,2244, 269,1938,1374,3508, 968,3063, 56,1396,3113, # 3312 +2107,3321,3391,5409,1927,2159,4681,3016,5410,3619,5411,5412,3743,4682,2485,5413, # 3328 +2804,5414,1650,4683,5415,2613,5416,5417,4086,2671,3392,1149,3393,4087,3884,4088, # 3344 +5418,1076, 49,5419, 951,3242,3322,3323, 450,2850, 920,5420,1812,2805,2371,4328, # 3360 +1909,1138,2372,3885,3509,5421,3243,4684,1910,1147,1518,2428,4685,3886,5422,4686, # 3376 +2393,2614, 260,1796,3244,5423,5424,3887,3324, 708,5425,3620,1704,5426,3621,1351, # 3392 +1618,3394,3017,1887, 944,4329,3395,4330,3064,3396,4331,5427,3744, 422, 413,1714, # 3408 +3325, 500,2059,2350,4332,2486,5428,1344,1911, 954,5429,1668,5430,5431,4089,2409, # 3424 +4333,3622,3888,4334,5432,2307,1318,2512,3114, 133,3115,2887,4687, 629, 31,2851, # 3440 +2706,3889,4688, 850, 949,4689,4090,2970,1732,2089,4335,1496,1853,5433,4091, 620, # 3456 +3245, 981,1242,3745,3397,1619,3746,1643,3326,2140,2457,1971,1719,3510,2169,5434, # 3472 +3246,5435,5436,3398,1829,5437,1277,4690,1565,2048,5438,1636,3623,3116,5439, 869, # 3488 +2852, 655,3890,3891,3117,4092,3018,3892,1310,3624,4691,5440,5441,5442,1733, 558, # 3504 +4692,3747, 335,1549,3065,1756,4336,3748,1946,3511,1830,1291,1192, 470,2735,2108, # 3520 +2806, 913,1054,4093,5443,1027,5444,3066,4094,4693, 982,2672,3399,3173,3512,3247, # 3536 +3248,1947,2807,5445, 571,4694,5446,1831,5447,3625,2591,1523,2429,5448,2090, 984, # 3552 +4695,3749,1960,5449,3750, 852, 923,2808,3513,3751, 969,1519, 999,2049,2325,1705, # 3568 +5450,3118, 615,1662, 151, 597,4095,2410,2326,1049, 275,4696,3752,4337, 568,3753, # 3584 +3626,2487,4338,3754,5451,2430,2275, 409,3249,5452,1566,2888,3514,1002, 769,2853, # 3600 + 194,2091,3174,3755,2226,3327,4339, 628,1505,5453,5454,1763,2180,3019,4096, 521, # 3616 +1161,2592,1788,2206,2411,4697,4097,1625,4340,4341, 412, 42,3119, 464,5455,2642, # 3632 +4698,3400,1760,1571,2889,3515,2537,1219,2207,3893,2643,2141,2373,4699,4700,3328, # 3648 +1651,3401,3627,5456,5457,3628,2488,3516,5458,3756,5459,5460,2276,2092, 460,5461, # 3664 +4701,5462,3020, 962, 588,3629, 289,3250,2644,1116, 52,5463,3067,1797,5464,5465, # 3680 +5466,1467,5467,1598,1143,3757,4342,1985,1734,1067,4702,1280,3402, 465,4703,1572, # 3696 + 510,5468,1928,2245,1813,1644,3630,5469,4704,3758,5470,5471,2673,1573,1534,5472, # 3712 +5473, 536,1808,1761,3517,3894,3175,2645,5474,5475,5476,4705,3518,2929,1912,2809, # 3728 +5477,3329,1122, 377,3251,5478, 360,5479,5480,4343,1529, 551,5481,2060,3759,1769, # 3744 +2431,5482,2930,4344,3330,3120,2327,2109,2031,4706,1404, 136,1468,1479, 672,1171, # 3760 +3252,2308, 271,3176,5483,2772,5484,2050, 678,2736, 865,1948,4707,5485,2014,4098, # 3776 +2971,5486,2737,2227,1397,3068,3760,4708,4709,1735,2931,3403,3631,5487,3895, 509, # 3792 +2854,2458,2890,3896,5488,5489,3177,3178,4710,4345,2538,4711,2309,1166,1010, 552, # 3808 + 681,1888,5490,5491,2972,2973,4099,1287,1596,1862,3179, 358, 453, 736, 175, 478, # 3824 +1117, 905,1167,1097,5492,1854,1530,5493,1706,5494,2181,3519,2292,3761,3520,3632, # 3840 +4346,2093,4347,5495,3404,1193,2489,4348,1458,2193,2208,1863,1889,1421,3331,2932, # 3856 +3069,2182,3521, 595,2123,5496,4100,5497,5498,4349,1707,2646, 223,3762,1359, 751, # 3872 +3121, 183,3522,5499,2810,3021, 419,2374, 633, 704,3897,2394, 241,5500,5501,5502, # 3888 + 838,3022,3763,2277,2773,2459,3898,1939,2051,4101,1309,3122,2246,1181,5503,1136, # 3904 +2209,3899,2375,1446,4350,2310,4712,5504,5505,4351,1055,2615, 484,3764,5506,4102, # 3920 + 625,4352,2278,3405,1499,4353,4103,5507,4104,4354,3253,2279,2280,3523,5508,5509, # 3936 +2774, 808,2616,3765,3406,4105,4355,3123,2539, 526,3407,3900,4356, 955,5510,1620, # 3952 +4357,2647,2432,5511,1429,3766,1669,1832, 994, 928,5512,3633,1260,5513,5514,5515, # 3968 +1949,2293, 741,2933,1626,4358,2738,2460, 867,1184, 362,3408,1392,5516,5517,4106, # 3984 +4359,1770,1736,3254,2934,4713,4714,1929,2707,1459,1158,5518,3070,3409,2891,1292, # 4000 +1930,2513,2855,3767,1986,1187,2072,2015,2617,4360,5519,2574,2514,2170,3768,2490, # 4016 +3332,5520,3769,4715,5521,5522, 666,1003,3023,1022,3634,4361,5523,4716,1814,2257, # 4032 + 574,3901,1603, 295,1535, 705,3902,4362, 283, 858, 417,5524,5525,3255,4717,4718, # 4048 +3071,1220,1890,1046,2281,2461,4107,1393,1599, 689,2575, 388,4363,5526,2491, 802, # 4064 +5527,2811,3903,2061,1405,2258,5528,4719,3904,2110,1052,1345,3256,1585,5529, 809, # 4080 +5530,5531,5532, 575,2739,3524, 956,1552,1469,1144,2328,5533,2329,1560,2462,3635, # 4096 +3257,4108, 616,2210,4364,3180,2183,2294,5534,1833,5535,3525,4720,5536,1319,3770, # 4112 +3771,1211,3636,1023,3258,1293,2812,5537,5538,5539,3905, 607,2311,3906, 762,2892, # 4128 +1439,4365,1360,4721,1485,3072,5540,4722,1038,4366,1450,2062,2648,4367,1379,4723, # 4144 +2593,5541,5542,4368,1352,1414,2330,2935,1172,5543,5544,3907,3908,4724,1798,1451, # 4160 +5545,5546,5547,5548,2936,4109,4110,2492,2351, 411,4111,4112,3637,3333,3124,4725, # 4176 +1561,2674,1452,4113,1375,5549,5550, 47,2974, 316,5551,1406,1591,2937,3181,5552, # 4192 +1025,2142,3125,3182, 354,2740, 884,2228,4369,2412, 508,3772, 726,3638, 996,2433, # 4208 +3639, 729,5553, 392,2194,1453,4114,4726,3773,5554,5555,2463,3640,2618,1675,2813, # 4224 + 919,2352,2975,2353,1270,4727,4115, 73,5556,5557, 647,5558,3259,2856,2259,1550, # 4240 +1346,3024,5559,1332, 883,3526,5560,5561,5562,5563,3334,2775,5564,1212, 831,1347, # 4256 +4370,4728,2331,3909,1864,3073, 720,3910,4729,4730,3911,5565,4371,5566,5567,4731, # 4272 +5568,5569,1799,4732,3774,2619,4733,3641,1645,2376,4734,5570,2938, 669,2211,2675, # 4288 +2434,5571,2893,5572,5573,1028,3260,5574,4372,2413,5575,2260,1353,5576,5577,4735, # 4304 +3183, 518,5578,4116,5579,4373,1961,5580,2143,4374,5581,5582,3025,2354,2355,3912, # 4320 + 516,1834,1454,4117,2708,4375,4736,2229,2620,1972,1129,3642,5583,2776,5584,2976, # 4336 +1422, 577,1470,3026,1524,3410,5585,5586, 432,4376,3074,3527,5587,2594,1455,2515, # 4352 +2230,1973,1175,5588,1020,2741,4118,3528,4737,5589,2742,5590,1743,1361,3075,3529, # 4368 +2649,4119,4377,4738,2295, 895, 924,4378,2171, 331,2247,3076, 166,1627,3077,1098, # 4384 +5591,1232,2894,2231,3411,4739, 657, 403,1196,2377, 542,3775,3412,1600,4379,3530, # 4400 +5592,4740,2777,3261, 576, 530,1362,4741,4742,2540,2676,3776,4120,5593, 842,3913, # 4416 +5594,2814,2032,1014,4121, 213,2709,3413, 665, 621,4380,5595,3777,2939,2435,5596, # 4432 +2436,3335,3643,3414,4743,4381,2541,4382,4744,3644,1682,4383,3531,1380,5597, 724, # 4448 +2282, 600,1670,5598,1337,1233,4745,3126,2248,5599,1621,4746,5600, 651,4384,5601, # 4464 +1612,4385,2621,5602,2857,5603,2743,2312,3078,5604, 716,2464,3079, 174,1255,2710, # 4480 +4122,3645, 548,1320,1398, 728,4123,1574,5605,1891,1197,3080,4124,5606,3081,3082, # 4496 +3778,3646,3779, 747,5607, 635,4386,4747,5608,5609,5610,4387,5611,5612,4748,5613, # 4512 +3415,4749,2437, 451,5614,3780,2542,2073,4388,2744,4389,4125,5615,1764,4750,5616, # 4528 +4390, 350,4751,2283,2395,2493,5617,4391,4126,2249,1434,4127, 488,4752, 458,4392, # 4544 +4128,3781, 771,1330,2396,3914,2576,3184,2160,2414,1553,2677,3185,4393,5618,2494, # 4560 +2895,2622,1720,2711,4394,3416,4753,5619,2543,4395,5620,3262,4396,2778,5621,2016, # 4576 +2745,5622,1155,1017,3782,3915,5623,3336,2313, 201,1865,4397,1430,5624,4129,5625, # 4592 +5626,5627,5628,5629,4398,1604,5630, 414,1866, 371,2595,4754,4755,3532,2017,3127, # 4608 +4756,1708, 960,4399, 887, 389,2172,1536,1663,1721,5631,2232,4130,2356,2940,1580, # 4624 +5632,5633,1744,4757,2544,4758,4759,5634,4760,5635,2074,5636,4761,3647,3417,2896, # 4640 +4400,5637,4401,2650,3418,2815, 673,2712,2465, 709,3533,4131,3648,4402,5638,1148, # 4656 + 502, 634,5639,5640,1204,4762,3649,1575,4763,2623,3783,5641,3784,3128, 948,3263, # 4672 + 121,1745,3916,1110,5642,4403,3083,2516,3027,4132,3785,1151,1771,3917,1488,4133, # 4688 +1987,5643,2438,3534,5644,5645,2094,5646,4404,3918,1213,1407,2816, 531,2746,2545, # 4704 +3264,1011,1537,4764,2779,4405,3129,1061,5647,3786,3787,1867,2897,5648,2018, 120, # 4720 +4406,4407,2063,3650,3265,2314,3919,2678,3419,1955,4765,4134,5649,3535,1047,2713, # 4736 +1266,5650,1368,4766,2858, 649,3420,3920,2546,2747,1102,2859,2679,5651,5652,2000, # 4752 +5653,1111,3651,2977,5654,2495,3921,3652,2817,1855,3421,3788,5655,5656,3422,2415, # 4768 +2898,3337,3266,3653,5657,2577,5658,3654,2818,4135,1460, 856,5659,3655,5660,2899, # 4784 +2978,5661,2900,3922,5662,4408, 632,2517, 875,3923,1697,3924,2296,5663,5664,4767, # 4800 +3028,1239, 580,4768,4409,5665, 914, 936,2075,1190,4136,1039,2124,5666,5667,5668, # 4816 +5669,3423,1473,5670,1354,4410,3925,4769,2173,3084,4137, 915,3338,4411,4412,3339, # 4832 +1605,1835,5671,2748, 398,3656,4413,3926,4138, 328,1913,2860,4139,3927,1331,4414, # 4848 +3029, 937,4415,5672,3657,4140,4141,3424,2161,4770,3425, 524, 742, 538,3085,1012, # 4864 +5673,5674,3928,2466,5675, 658,1103, 225,3929,5676,5677,4771,5678,4772,5679,3267, # 4880 +1243,5680,4142, 963,2250,4773,5681,2714,3658,3186,5682,5683,2596,2332,5684,4774, # 4896 +5685,5686,5687,3536, 957,3426,2547,2033,1931,2941,2467, 870,2019,3659,1746,2780, # 4912 +2781,2439,2468,5688,3930,5689,3789,3130,3790,3537,3427,3791,5690,1179,3086,5691, # 4928 +3187,2378,4416,3792,2548,3188,3131,2749,4143,5692,3428,1556,2549,2297, 977,2901, # 4944 +2034,4144,1205,3429,5693,1765,3430,3189,2125,1271, 714,1689,4775,3538,5694,2333, # 4960 +3931, 533,4417,3660,2184, 617,5695,2469,3340,3539,2315,5696,5697,3190,5698,5699, # 4976 +3932,1988, 618, 427,2651,3540,3431,5700,5701,1244,1690,5702,2819,4418,4776,5703, # 4992 +3541,4777,5704,2284,1576, 473,3661,4419,3432, 972,5705,3662,5706,3087,5707,5708, # 5008 +4778,4779,5709,3793,4145,4146,5710, 153,4780, 356,5711,1892,2902,4420,2144, 408, # 5024 + 803,2357,5712,3933,5713,4421,1646,2578,2518,4781,4782,3934,5714,3935,4422,5715, # 5040 +2416,3433, 752,5716,5717,1962,3341,2979,5718, 746,3030,2470,4783,4423,3794, 698, # 5056 +4784,1893,4424,3663,2550,4785,3664,3936,5719,3191,3434,5720,1824,1302,4147,2715, # 5072 +3937,1974,4425,5721,4426,3192, 823,1303,1288,1236,2861,3542,4148,3435, 774,3938, # 5088 +5722,1581,4786,1304,2862,3939,4787,5723,2440,2162,1083,3268,4427,4149,4428, 344, # 5104 +1173, 288,2316, 454,1683,5724,5725,1461,4788,4150,2597,5726,5727,4789, 985, 894, # 5120 +5728,3436,3193,5729,1914,2942,3795,1989,5730,2111,1975,5731,4151,5732,2579,1194, # 5136 + 425,5733,4790,3194,1245,3796,4429,5734,5735,2863,5736, 636,4791,1856,3940, 760, # 5152 +1800,5737,4430,2212,1508,4792,4152,1894,1684,2298,5738,5739,4793,4431,4432,2213, # 5168 + 479,5740,5741, 832,5742,4153,2496,5743,2980,2497,3797, 990,3132, 627,1815,2652, # 5184 +4433,1582,4434,2126,2112,3543,4794,5744, 799,4435,3195,5745,4795,2113,1737,3031, # 5200 +1018, 543, 754,4436,3342,1676,4796,4797,4154,4798,1489,5746,3544,5747,2624,2903, # 5216 +4155,5748,5749,2981,5750,5751,5752,5753,3196,4799,4800,2185,1722,5754,3269,3270, # 5232 +1843,3665,1715, 481, 365,1976,1857,5755,5756,1963,2498,4801,5757,2127,3666,3271, # 5248 + 433,1895,2064,2076,5758, 602,2750,5759,5760,5761,5762,5763,3032,1628,3437,5764, # 5264 +3197,4802,4156,2904,4803,2519,5765,2551,2782,5766,5767,5768,3343,4804,2905,5769, # 5280 +4805,5770,2864,4806,4807,1221,2982,4157,2520,5771,5772,5773,1868,1990,5774,5775, # 5296 +5776,1896,5777,5778,4808,1897,4158, 318,5779,2095,4159,4437,5780,5781, 485,5782, # 5312 + 938,3941, 553,2680, 116,5783,3942,3667,5784,3545,2681,2783,3438,3344,2820,5785, # 5328 +3668,2943,4160,1747,2944,2983,5786,5787, 207,5788,4809,5789,4810,2521,5790,3033, # 5344 + 890,3669,3943,5791,1878,3798,3439,5792,2186,2358,3440,1652,5793,5794,5795, 941, # 5360 +2299, 208,3546,4161,2020, 330,4438,3944,2906,2499,3799,4439,4811,5796,5797,5798, # 5376 +) + diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/big5prober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/big5prober.py new file mode 100644 index 0000000000000000000000000000000000000000..98f9970122088c14a5830e091ca8a12fc8e4c563 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/big5prober.py @@ -0,0 +1,47 @@ +######################## 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 ######################### + +from .mbcharsetprober import MultiByteCharSetProber +from .codingstatemachine import CodingStateMachine +from .chardistribution import Big5DistributionAnalysis +from .mbcssm import BIG5_SM_MODEL + + +class Big5Prober(MultiByteCharSetProber): + def __init__(self): + super(Big5Prober, self).__init__() + self.coding_sm = CodingStateMachine(BIG5_SM_MODEL) + self.distribution_analyzer = Big5DistributionAnalysis() + self.reset() + + @property + def charset_name(self): + return "Big5" + + @property + def language(self): + return "Chinese" diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/chardistribution.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/chardistribution.py new file mode 100644 index 0000000000000000000000000000000000000000..c0395f4a45aaa5c4ba1824a81d8ef8f69b46dc60 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/chardistribution.py @@ -0,0 +1,233 @@ +######################## 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 ######################### + +from .euctwfreq import (EUCTW_CHAR_TO_FREQ_ORDER, EUCTW_TABLE_SIZE, + EUCTW_TYPICAL_DISTRIBUTION_RATIO) +from .euckrfreq import (EUCKR_CHAR_TO_FREQ_ORDER, EUCKR_TABLE_SIZE, + EUCKR_TYPICAL_DISTRIBUTION_RATIO) +from .gb2312freq import (GB2312_CHAR_TO_FREQ_ORDER, GB2312_TABLE_SIZE, + GB2312_TYPICAL_DISTRIBUTION_RATIO) +from .big5freq import (BIG5_CHAR_TO_FREQ_ORDER, BIG5_TABLE_SIZE, + BIG5_TYPICAL_DISTRIBUTION_RATIO) +from .jisfreq import (JIS_CHAR_TO_FREQ_ORDER, JIS_TABLE_SIZE, + JIS_TYPICAL_DISTRIBUTION_RATIO) + + +class CharDistributionAnalysis(object): + ENOUGH_DATA_THRESHOLD = 1024 + SURE_YES = 0.99 + SURE_NO = 0.01 + MINIMUM_DATA_THRESHOLD = 3 + + def __init__(self): + # Mapping table to get frequency order from char order (get from + # GetOrder()) + self._char_to_freq_order = None + self._table_size = None # Size of above table + # This is a constant value which varies from language to language, + # used in calculating confidence. See + # http://www.mozilla.org/projects/intl/UniversalCharsetDetection.html + # for further detail. + self.typical_distribution_ratio = None + self._done = None + self._total_chars = None + self._freq_chars = None + self.reset() + + def reset(self): + """reset analyser, clear any state""" + # If this flag is set to True, detection is done and conclusion has + # been made + self._done = False + self._total_chars = 0 # Total characters encountered + # The number of characters whose frequency order is less than 512 + self._freq_chars = 0 + + def feed(self, char, char_len): + """feed a character with known length""" + if char_len == 2: + # we only care about 2-bytes character in our distribution analysis + order = self.get_order(char) + else: + order = -1 + if order >= 0: + self._total_chars += 1 + # order is valid + if order < self._table_size: + if 512 > self._char_to_freq_order[order]: + self._freq_chars += 1 + + def get_confidence(self): + """return confidence based on existing data""" + # if we didn't receive any character in our consideration range, + # return negative answer + if self._total_chars <= 0 or self._freq_chars <= self.MINIMUM_DATA_THRESHOLD: + return self.SURE_NO + + if self._total_chars != self._freq_chars: + r = (self._freq_chars / ((self._total_chars - self._freq_chars) + * self.typical_distribution_ratio)) + if r < self.SURE_YES: + return r + + # normalize confidence (we don't want to be 100% sure) + return self.SURE_YES + + def got_enough_data(self): + # It is not necessary to receive all data to draw conclusion. + # For charset detection, certain amount of data is enough + return self._total_chars > self.ENOUGH_DATA_THRESHOLD + + def get_order(self, byte_str): + # We do not handle characters based on the original encoding string, + # but convert this encoding string to a number, here called order. + # This allows multiple encodings of a language to share one frequency + # table. + return -1 + + +class EUCTWDistributionAnalysis(CharDistributionAnalysis): + def __init__(self): + super(EUCTWDistributionAnalysis, self).__init__() + self._char_to_freq_order = EUCTW_CHAR_TO_FREQ_ORDER + self._table_size = EUCTW_TABLE_SIZE + self.typical_distribution_ratio = EUCTW_TYPICAL_DISTRIBUTION_RATIO + + def get_order(self, byte_str): + # for euc-TW encoding, we are interested + # first byte range: 0xc4 -- 0xfe + # second byte range: 0xa1 -- 0xfe + # no validation needed here. State machine has done that + first_char = byte_str[0] + if first_char >= 0xC4: + return 94 * (first_char - 0xC4) + byte_str[1] - 0xA1 + else: + return -1 + + +class EUCKRDistributionAnalysis(CharDistributionAnalysis): + def __init__(self): + super(EUCKRDistributionAnalysis, self).__init__() + self._char_to_freq_order = EUCKR_CHAR_TO_FREQ_ORDER + self._table_size = EUCKR_TABLE_SIZE + self.typical_distribution_ratio = EUCKR_TYPICAL_DISTRIBUTION_RATIO + + def get_order(self, byte_str): + # for euc-KR encoding, we are interested + # first byte range: 0xb0 -- 0xfe + # second byte range: 0xa1 -- 0xfe + # no validation needed here. State machine has done that + first_char = byte_str[0] + if first_char >= 0xB0: + return 94 * (first_char - 0xB0) + byte_str[1] - 0xA1 + else: + return -1 + + +class GB2312DistributionAnalysis(CharDistributionAnalysis): + def __init__(self): + super(GB2312DistributionAnalysis, self).__init__() + self._char_to_freq_order = GB2312_CHAR_TO_FREQ_ORDER + self._table_size = GB2312_TABLE_SIZE + self.typical_distribution_ratio = GB2312_TYPICAL_DISTRIBUTION_RATIO + + def get_order(self, byte_str): + # for GB2312 encoding, we are interested + # first byte range: 0xb0 -- 0xfe + # second byte range: 0xa1 -- 0xfe + # no validation needed here. State machine has done that + first_char, second_char = byte_str[0], byte_str[1] + if (first_char >= 0xB0) and (second_char >= 0xA1): + return 94 * (first_char - 0xB0) + second_char - 0xA1 + else: + return -1 + + +class Big5DistributionAnalysis(CharDistributionAnalysis): + def __init__(self): + super(Big5DistributionAnalysis, self).__init__() + self._char_to_freq_order = BIG5_CHAR_TO_FREQ_ORDER + self._table_size = BIG5_TABLE_SIZE + self.typical_distribution_ratio = BIG5_TYPICAL_DISTRIBUTION_RATIO + + def get_order(self, byte_str): + # for big5 encoding, we are interested + # first byte range: 0xa4 -- 0xfe + # second byte range: 0x40 -- 0x7e , 0xa1 -- 0xfe + # no validation needed here. State machine has done that + first_char, second_char = byte_str[0], byte_str[1] + if first_char >= 0xA4: + if second_char >= 0xA1: + return 157 * (first_char - 0xA4) + second_char - 0xA1 + 63 + else: + return 157 * (first_char - 0xA4) + second_char - 0x40 + else: + return -1 + + +class SJISDistributionAnalysis(CharDistributionAnalysis): + def __init__(self): + super(SJISDistributionAnalysis, self).__init__() + self._char_to_freq_order = JIS_CHAR_TO_FREQ_ORDER + self._table_size = JIS_TABLE_SIZE + self.typical_distribution_ratio = JIS_TYPICAL_DISTRIBUTION_RATIO + + def get_order(self, byte_str): + # for sjis encoding, we are interested + # first byte range: 0x81 -- 0x9f , 0xe0 -- 0xfe + # second byte range: 0x40 -- 0x7e, 0x81 -- oxfe + # no validation needed here. State machine has done that + first_char, second_char = byte_str[0], byte_str[1] + if (first_char >= 0x81) and (first_char <= 0x9F): + order = 188 * (first_char - 0x81) + elif (first_char >= 0xE0) and (first_char <= 0xEF): + order = 188 * (first_char - 0xE0 + 31) + else: + return -1 + order = order + second_char - 0x40 + if second_char > 0x7F: + order = -1 + return order + + +class EUCJPDistributionAnalysis(CharDistributionAnalysis): + def __init__(self): + super(EUCJPDistributionAnalysis, self).__init__() + self._char_to_freq_order = JIS_CHAR_TO_FREQ_ORDER + self._table_size = JIS_TABLE_SIZE + self.typical_distribution_ratio = JIS_TYPICAL_DISTRIBUTION_RATIO + + def get_order(self, byte_str): + # for euc-JP encoding, we are interested + # first byte range: 0xa0 -- 0xfe + # second byte range: 0xa1 -- 0xfe + # no validation needed here. State machine has done that + char = byte_str[0] + if char >= 0xA0: + return 94 * (char - 0xA1) + byte_str[1] - 0xa1 + else: + return -1 diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/charsetgroupprober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/charsetgroupprober.py new file mode 100644 index 0000000000000000000000000000000000000000..8b3738efd8ea1e42d196d381d2809beae7f4c649 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/charsetgroupprober.py @@ -0,0 +1,106 @@ +######################## 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 ######################### + +from .enums import ProbingState +from .charsetprober import CharSetProber + + +class CharSetGroupProber(CharSetProber): + def __init__(self, lang_filter=None): + super(CharSetGroupProber, self).__init__(lang_filter=lang_filter) + self._active_num = 0 + self.probers = [] + self._best_guess_prober = None + + def reset(self): + super(CharSetGroupProber, self).reset() + self._active_num = 0 + for prober in self.probers: + if prober: + prober.reset() + prober.active = True + self._active_num += 1 + self._best_guess_prober = None + + @property + def charset_name(self): + if not self._best_guess_prober: + self.get_confidence() + if not self._best_guess_prober: + return None + return self._best_guess_prober.charset_name + + @property + def language(self): + if not self._best_guess_prober: + self.get_confidence() + if not self._best_guess_prober: + return None + return self._best_guess_prober.language + + def feed(self, byte_str): + for prober in self.probers: + if not prober: + continue + if not prober.active: + continue + state = prober.feed(byte_str) + if not state: + continue + if state == ProbingState.FOUND_IT: + self._best_guess_prober = prober + return self.state + elif state == ProbingState.NOT_ME: + prober.active = False + self._active_num -= 1 + if self._active_num <= 0: + self._state = ProbingState.NOT_ME + return self.state + return self.state + + def get_confidence(self): + state = self.state + if state == ProbingState.FOUND_IT: + return 0.99 + elif state == ProbingState.NOT_ME: + return 0.01 + best_conf = 0.0 + self._best_guess_prober = None + for prober in self.probers: + if not prober: + continue + if not prober.active: + self.logger.debug('%s not active', prober.charset_name) + continue + conf = prober.get_confidence() + self.logger.debug('%s %s confidence = %s', prober.charset_name, prober.language, conf) + if best_conf < conf: + best_conf = conf + self._best_guess_prober = prober + if not self._best_guess_prober: + return 0.0 + return best_conf diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/charsetprober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/charsetprober.py new file mode 100644 index 0000000000000000000000000000000000000000..eac4e5986578636ad414648e6015e8b7e9f10432 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/charsetprober.py @@ -0,0 +1,145 @@ +######################## BEGIN LICENSE BLOCK ######################## +# The Original Code is Mozilla Universal charset detector code. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 2001 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# Mark Pilgrim - port to Python +# Shy Shalom - original C code +# +# 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 ######################### + +import logging +import re + +from .enums import ProbingState + + +class CharSetProber(object): + + SHORTCUT_THRESHOLD = 0.95 + + def __init__(self, lang_filter=None): + self._state = None + self.lang_filter = lang_filter + self.logger = logging.getLogger(__name__) + + def reset(self): + self._state = ProbingState.DETECTING + + @property + def charset_name(self): + return None + + def feed(self, buf): + pass + + @property + def state(self): + return self._state + + def get_confidence(self): + return 0.0 + + @staticmethod + def filter_high_byte_only(buf): + buf = re.sub(b'([\x00-\x7F])+', b' ', buf) + return buf + + @staticmethod + def filter_international_words(buf): + """ + We define three types of bytes: + alphabet: english alphabets [a-zA-Z] + international: international characters [\x80-\xFF] + marker: everything else [^a-zA-Z\x80-\xFF] + + The input buffer can be thought to contain a series of words delimited + by markers. This function works to filter all words that contain at + least one international character. All contiguous sequences of markers + are replaced by a single space ascii character. + + This filter applies to all scripts which do not use English characters. + """ + filtered = bytearray() + + # This regex expression filters out only words that have at-least one + # international character. The word may include one marker character at + # the end. + words = re.findall(b'[a-zA-Z]*[\x80-\xFF]+[a-zA-Z]*[^a-zA-Z\x80-\xFF]?', + buf) + + for word in words: + filtered.extend(word[:-1]) + + # If the last character in the word is a marker, replace it with a + # space as markers shouldn't affect our analysis (they are used + # similarly across all languages and may thus have similar + # frequencies). + last_char = word[-1:] + if not last_char.isalpha() and last_char < b'\x80': + last_char = b' ' + filtered.extend(last_char) + + return filtered + + @staticmethod + def filter_with_english_letters(buf): + """ + Returns a copy of ``buf`` that retains only the sequences of English + alphabet and high byte characters that are not between <> characters. + Also retains English alphabet and high byte characters immediately + before occurrences of >. + + This filter can be applied to all scripts which contain both English + characters and extended ASCII characters, but is currently only used by + ``Latin1Prober``. + """ + filtered = bytearray() + in_tag = False + prev = 0 + + for curr in range(len(buf)): + # Slice here to get bytes instead of an int with Python 3 + buf_char = buf[curr:curr + 1] + # Check if we're coming out of or entering an HTML tag + if buf_char == b'>': + in_tag = False + elif buf_char == b'<': + in_tag = True + + # If current character is not extended-ASCII and not alphabetic... + if buf_char < b'\x80' and not buf_char.isalpha(): + # ...and we're not in a tag + if curr > prev and not in_tag: + # Keep everything after last non-extended-ASCII, + # non-alphabetic character + filtered.extend(buf[prev:curr]) + # Output a space to delimit stretch we kept + filtered.extend(b' ') + prev = curr + 1 + + # If we're not in a tag... + if not in_tag: + # Keep everything after last non-extended-ASCII, non-alphabetic + # character + filtered.extend(buf[prev:]) + + return filtered diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/codingstatemachine.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/codingstatemachine.py new file mode 100644 index 0000000000000000000000000000000000000000..68fba44f14366c448f13db3cf9cf1665af2e498c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/codingstatemachine.py @@ -0,0 +1,88 @@ +######################## 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 ######################### + +import logging + +from .enums import MachineState + + +class CodingStateMachine(object): + """ + A state machine to verify a byte sequence for a particular encoding. For + each byte the detector receives, it will feed that byte to every active + state machine available, one byte at a time. The state machine changes its + state based on its previous state and the byte it receives. There are 3 + states in a state machine that are of interest to an auto-detector: + + START state: This is the state to start with, or a legal byte sequence + (i.e. a valid code point) for character has been identified. + + ME state: This indicates that the state machine identified a byte sequence + that is specific to the charset it is designed for and that + there is no other possible encoding which can contain this byte + sequence. This will to lead to an immediate positive answer for + the detector. + + ERROR state: This indicates the state machine identified an illegal byte + sequence for that encoding. This will lead to an immediate + negative answer for this encoding. Detector will exclude this + encoding from consideration from here on. + """ + def __init__(self, sm): + self._model = sm + self._curr_byte_pos = 0 + self._curr_char_len = 0 + self._curr_state = None + self.logger = logging.getLogger(__name__) + self.reset() + + def reset(self): + self._curr_state = MachineState.START + + def next_state(self, c): + # for each byte we get its class + # if it is first byte, we also get byte length + byte_class = self._model['class_table'][c] + if self._curr_state == MachineState.START: + self._curr_byte_pos = 0 + self._curr_char_len = self._model['char_len_table'][byte_class] + # from byte's class and state_table, we get its next state + curr_state = (self._curr_state * self._model['class_factor'] + + byte_class) + self._curr_state = self._model['state_table'][curr_state] + self._curr_byte_pos += 1 + return self._curr_state + + def get_current_charlen(self): + return self._curr_char_len + + def get_coding_state_machine(self): + return self._model['name'] + + @property + def language(self): + return self._model['language'] diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/compat.py new file mode 100644 index 0000000000000000000000000000000000000000..ddd74687c02a12ecc296ee803997a345e984bc9d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/compat.py @@ -0,0 +1,34 @@ +######################## BEGIN LICENSE BLOCK ######################## +# Contributor(s): +# Dan Blanchard +# Ian Cordasco +# +# 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 ######################### + +import sys + + +if sys.version_info < (3, 0): + PY2 = True + PY3 = False + base_str = (str, unicode) + text_type = unicode +else: + PY2 = False + PY3 = True + base_str = (bytes, str) + text_type = str diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/cp949prober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/cp949prober.py new file mode 100644 index 0000000000000000000000000000000000000000..efd793abca4bf496001a4e46a67557e5a6f16bba --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/cp949prober.py @@ -0,0 +1,49 @@ +######################## 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 .chardistribution import EUCKRDistributionAnalysis +from .codingstatemachine import CodingStateMachine +from .mbcharsetprober import MultiByteCharSetProber +from .mbcssm import CP949_SM_MODEL + + +class CP949Prober(MultiByteCharSetProber): + def __init__(self): + super(CP949Prober, self).__init__() + self.coding_sm = CodingStateMachine(CP949_SM_MODEL) + # NOTE: CP949 is a superset of EUC-KR, so the distribution should be + # not different. + self.distribution_analyzer = EUCKRDistributionAnalysis() + self.reset() + + @property + def charset_name(self): + return "CP949" + + @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/sbcharsetprober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/sbcharsetprober.py new file mode 100644 index 0000000000000000000000000000000000000000..0adb51de5a210aa36849cd149ed0f4ae424fce42 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/sbcharsetprober.py @@ -0,0 +1,132 @@ +######################## BEGIN LICENSE BLOCK ######################## +# The Original Code is Mozilla Universal charset detector code. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 2001 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# Mark Pilgrim - port to Python +# Shy Shalom - original C code +# +# 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 .enums import CharacterCategory, ProbingState, SequenceLikelihood + + +class SingleByteCharSetProber(CharSetProber): + SAMPLE_SIZE = 64 + SB_ENOUGH_REL_THRESHOLD = 1024 # 0.25 * SAMPLE_SIZE^2 + POSITIVE_SHORTCUT_THRESHOLD = 0.95 + NEGATIVE_SHORTCUT_THRESHOLD = 0.05 + + def __init__(self, model, reversed=False, name_prober=None): + super(SingleByteCharSetProber, self).__init__() + self._model = model + # TRUE if we need to reverse every pair in the model lookup + self._reversed = reversed + # Optional auxiliary prober for name decision + self._name_prober = name_prober + self._last_order = None + self._seq_counters = None + self._total_seqs = None + self._total_char = None + self._freq_char = None + self.reset() + + def reset(self): + super(SingleByteCharSetProber, self).reset() + # char order of last character + self._last_order = 255 + self._seq_counters = [0] * SequenceLikelihood.get_num_categories() + self._total_seqs = 0 + self._total_char = 0 + # characters that fall in our sampling range + self._freq_char = 0 + + @property + def charset_name(self): + if self._name_prober: + return self._name_prober.charset_name + else: + return self._model['charset_name'] + + @property + def language(self): + if self._name_prober: + return self._name_prober.language + else: + return self._model.get('language') + + def feed(self, byte_str): + if not self._model['keep_english_letter']: + byte_str = self.filter_international_words(byte_str) + if not byte_str: + return self.state + char_to_order_map = self._model['char_to_order_map'] + for i, c in enumerate(byte_str): + # XXX: Order is in range 1-64, so one would think we want 0-63 here, + # but that leads to 27 more test failures than before. + order = char_to_order_map[c] + # XXX: This was SYMBOL_CAT_ORDER before, with a value of 250, but + # CharacterCategory.SYMBOL is actually 253, so we use CONTROL + # to make it closer to the original intent. The only difference + # is whether or not we count digits and control characters for + # _total_char purposes. + if order < CharacterCategory.CONTROL: + self._total_char += 1 + if order < self.SAMPLE_SIZE: + self._freq_char += 1 + if self._last_order < self.SAMPLE_SIZE: + self._total_seqs += 1 + if not self._reversed: + i = (self._last_order * self.SAMPLE_SIZE) + order + model = self._model['precedence_matrix'][i] + else: # reverse the order of the letters in the lookup + i = (order * self.SAMPLE_SIZE) + self._last_order + model = self._model['precedence_matrix'][i] + self._seq_counters[model] += 1 + self._last_order = order + + charset_name = self._model['charset_name'] + if self.state == ProbingState.DETECTING: + if self._total_seqs > self.SB_ENOUGH_REL_THRESHOLD: + confidence = self.get_confidence() + if confidence > self.POSITIVE_SHORTCUT_THRESHOLD: + self.logger.debug('%s confidence = %s, we have a winner', + charset_name, confidence) + self._state = ProbingState.FOUND_IT + elif confidence < self.NEGATIVE_SHORTCUT_THRESHOLD: + self.logger.debug('%s confidence = %s, below negative ' + 'shortcut threshhold %s', charset_name, + confidence, + self.NEGATIVE_SHORTCUT_THRESHOLD) + self._state = ProbingState.NOT_ME + + return self.state + + def get_confidence(self): + r = 0.01 + if self._total_seqs > 0: + r = ((1.0 * self._seq_counters[SequenceLikelihood.POSITIVE]) / + self._total_seqs / self._model['typical_positive_ratio']) + r = r * self._freq_char / self._total_char + if r >= 1.0: + r = 0.99 + return r diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/sbcsgroupprober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/sbcsgroupprober.py new file mode 100644 index 0000000000000000000000000000000000000000..98e95dc1a3cbc65e97bc726ab7000955132719dd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/sbcsgroupprober.py @@ -0,0 +1,73 @@ +######################## BEGIN LICENSE BLOCK ######################## +# The Original Code is Mozilla Universal charset detector code. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 2001 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# Mark Pilgrim - port to Python +# Shy Shalom - original C code +# +# 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 .charsetgroupprober import CharSetGroupProber +from .sbcharsetprober import SingleByteCharSetProber +from .langcyrillicmodel import (Win1251CyrillicModel, Koi8rModel, + Latin5CyrillicModel, MacCyrillicModel, + Ibm866Model, Ibm855Model) +from .langgreekmodel import Latin7GreekModel, Win1253GreekModel +from .langbulgarianmodel import Latin5BulgarianModel, Win1251BulgarianModel +# from .langhungarianmodel import Latin2HungarianModel, Win1250HungarianModel +from .langthaimodel import TIS620ThaiModel +from .langhebrewmodel import Win1255HebrewModel +from .hebrewprober import HebrewProber +from .langturkishmodel import Latin5TurkishModel + + +class SBCSGroupProber(CharSetGroupProber): + def __init__(self): + super(SBCSGroupProber, self).__init__() + self.probers = [ + SingleByteCharSetProber(Win1251CyrillicModel), + SingleByteCharSetProber(Koi8rModel), + SingleByteCharSetProber(Latin5CyrillicModel), + SingleByteCharSetProber(MacCyrillicModel), + SingleByteCharSetProber(Ibm866Model), + SingleByteCharSetProber(Ibm855Model), + SingleByteCharSetProber(Latin7GreekModel), + SingleByteCharSetProber(Win1253GreekModel), + SingleByteCharSetProber(Latin5BulgarianModel), + SingleByteCharSetProber(Win1251BulgarianModel), + # TODO: Restore Hungarian encodings (iso-8859-2 and windows-1250) + # after we retrain model. + # SingleByteCharSetProber(Latin2HungarianModel), + # SingleByteCharSetProber(Win1250HungarianModel), + SingleByteCharSetProber(TIS620ThaiModel), + SingleByteCharSetProber(Latin5TurkishModel), + ] + hebrew_prober = HebrewProber() + logical_hebrew_prober = SingleByteCharSetProber(Win1255HebrewModel, + False, hebrew_prober) + visual_hebrew_prober = SingleByteCharSetProber(Win1255HebrewModel, True, + hebrew_prober) + hebrew_prober.set_model_probers(logical_hebrew_prober, visual_hebrew_prober) + self.probers.extend([hebrew_prober, logical_hebrew_prober, + visual_hebrew_prober]) + + self.reset() diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/sjisprober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/sjisprober.py new file mode 100644 index 0000000000000000000000000000000000000000..9e29623bdc54a7c6d11bcc167d71bb44cc9be39d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/sjisprober.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 .mbcharsetprober import MultiByteCharSetProber +from .codingstatemachine import CodingStateMachine +from .chardistribution import SJISDistributionAnalysis +from .jpcntx import SJISContextAnalysis +from .mbcssm import SJIS_SM_MODEL +from .enums import ProbingState, MachineState + + +class SJISProber(MultiByteCharSetProber): + def __init__(self): + super(SJISProber, self).__init__() + self.coding_sm = CodingStateMachine(SJIS_SM_MODEL) + self.distribution_analyzer = SJISDistributionAnalysis() + self.context_analyzer = SJISContextAnalysis() + self.reset() + + def reset(self): + super(SJISProber, self).reset() + self.context_analyzer.reset() + + @property + def charset_name(self): + return self.context_analyzer.charset_name + + @property + def language(self): + return "Japanese" + + def feed(self, byte_str): + for i in range(len(byte_str)): + 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[2 - char_len:], + char_len) + self.distribution_analyzer.feed(self._last_char, char_len) + else: + self.context_analyzer.feed(byte_str[i + 1 - char_len:i + 3 + - char_len], 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/universaldetector.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/universaldetector.py new file mode 100644 index 0000000000000000000000000000000000000000..7b4e92d6158527736e3d14d6f725edada8f94b00 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/universaldetector.py @@ -0,0 +1,286 @@ +######################## BEGIN LICENSE BLOCK ######################## +# The Original Code is Mozilla Universal charset detector code. +# +# The Initial Developer of the Original Code is +# Netscape Communications Corporation. +# Portions created by the Initial Developer are Copyright (C) 2001 +# the Initial Developer. All Rights Reserved. +# +# Contributor(s): +# Mark Pilgrim - port to Python +# Shy Shalom - original C code +# +# 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 ######################### +""" +Module containing the UniversalDetector detector class, which is the primary +class a user of ``chardet`` should use. + +:author: Mark Pilgrim (initial port to Python) +:author: Shy Shalom (original C code) +:author: Dan Blanchard (major refactoring for 3.0) +:author: Ian Cordasco +""" + + +import codecs +import logging +import re + +from .charsetgroupprober import CharSetGroupProber +from .enums import InputState, LanguageFilter, ProbingState +from .escprober import EscCharSetProber +from .latin1prober import Latin1Prober +from .mbcsgroupprober import MBCSGroupProber +from .sbcsgroupprober import SBCSGroupProber + + +class UniversalDetector(object): + """ + The ``UniversalDetector`` class underlies the ``chardet.detect`` function + and coordinates all of the different charset probers. + + To get a ``dict`` containing an encoding and its confidence, you can simply + run: + + .. code:: + + u = UniversalDetector() + u.feed(some_bytes) + u.close() + detected = u.result + + """ + + MINIMUM_THRESHOLD = 0.20 + HIGH_BYTE_DETECTOR = re.compile(b'[\x80-\xFF]') + ESC_DETECTOR = re.compile(b'(\033|~{)') + WIN_BYTE_DETECTOR = re.compile(b'[\x80-\x9F]') + ISO_WIN_MAP = {'iso-8859-1': 'Windows-1252', + 'iso-8859-2': 'Windows-1250', + 'iso-8859-5': 'Windows-1251', + 'iso-8859-6': 'Windows-1256', + 'iso-8859-7': 'Windows-1253', + 'iso-8859-8': 'Windows-1255', + 'iso-8859-9': 'Windows-1254', + 'iso-8859-13': 'Windows-1257'} + + def __init__(self, lang_filter=LanguageFilter.ALL): + self._esc_charset_prober = None + self._charset_probers = [] + self.result = None + self.done = None + self._got_data = None + self._input_state = None + self._last_char = None + self.lang_filter = lang_filter + self.logger = logging.getLogger(__name__) + self._has_win_bytes = None + self.reset() + + def reset(self): + """ + Reset the UniversalDetector and all of its probers back to their + initial states. This is called by ``__init__``, so you only need to + call this directly in between analyses of different documents. + """ + self.result = {'encoding': None, 'confidence': 0.0, 'language': None} + self.done = False + self._got_data = False + self._has_win_bytes = False + self._input_state = InputState.PURE_ASCII + self._last_char = b'' + if self._esc_charset_prober: + self._esc_charset_prober.reset() + for prober in self._charset_probers: + prober.reset() + + def feed(self, byte_str): + """ + Takes a chunk of a document and feeds it through all of the relevant + charset probers. + + After calling ``feed``, you can check the value of the ``done`` + attribute to see if you need to continue feeding the + ``UniversalDetector`` more data, or if it has made a prediction + (in the ``result`` attribute). + + .. note:: + You should always call ``close`` when you're done feeding in your + document if ``done`` is not already ``True``. + """ + if self.done: + return + + if not len(byte_str): + return + + if not isinstance(byte_str, bytearray): + byte_str = bytearray(byte_str) + + # First check for known BOMs, since these are guaranteed to be correct + if not self._got_data: + # If the data starts with BOM, we know it is UTF + if byte_str.startswith(codecs.BOM_UTF8): + # EF BB BF UTF-8 with BOM + self.result = {'encoding': "UTF-8-SIG", + 'confidence': 1.0, + 'language': ''} + elif byte_str.startswith((codecs.BOM_UTF32_LE, + codecs.BOM_UTF32_BE)): + # FF FE 00 00 UTF-32, little-endian BOM + # 00 00 FE FF UTF-32, big-endian BOM + self.result = {'encoding': "UTF-32", + 'confidence': 1.0, + 'language': ''} + elif byte_str.startswith(b'\xFE\xFF\x00\x00'): + # FE FF 00 00 UCS-4, unusual octet order BOM (3412) + self.result = {'encoding': "X-ISO-10646-UCS-4-3412", + 'confidence': 1.0, + 'language': ''} + elif byte_str.startswith(b'\x00\x00\xFF\xFE'): + # 00 00 FF FE UCS-4, unusual octet order BOM (2143) + self.result = {'encoding': "X-ISO-10646-UCS-4-2143", + 'confidence': 1.0, + 'language': ''} + elif byte_str.startswith((codecs.BOM_LE, codecs.BOM_BE)): + # FF FE UTF-16, little endian BOM + # FE FF UTF-16, big endian BOM + self.result = {'encoding': "UTF-16", + 'confidence': 1.0, + 'language': ''} + + self._got_data = True + if self.result['encoding'] is not None: + self.done = True + return + + # If none of those matched and we've only see ASCII so far, check + # for high bytes and escape sequences + if self._input_state == InputState.PURE_ASCII: + if self.HIGH_BYTE_DETECTOR.search(byte_str): + self._input_state = InputState.HIGH_BYTE + elif self._input_state == InputState.PURE_ASCII and \ + self.ESC_DETECTOR.search(self._last_char + byte_str): + self._input_state = InputState.ESC_ASCII + + self._last_char = byte_str[-1:] + + # If we've seen escape sequences, use the EscCharSetProber, which + # uses a simple state machine to check for known escape sequences in + # HZ and ISO-2022 encodings, since those are the only encodings that + # use such sequences. + if self._input_state == InputState.ESC_ASCII: + if not self._esc_charset_prober: + self._esc_charset_prober = EscCharSetProber(self.lang_filter) + if self._esc_charset_prober.feed(byte_str) == ProbingState.FOUND_IT: + self.result = {'encoding': + self._esc_charset_prober.charset_name, + 'confidence': + self._esc_charset_prober.get_confidence(), + 'language': + self._esc_charset_prober.language} + self.done = True + # If we've seen high bytes (i.e., those with values greater than 127), + # we need to do more complicated checks using all our multi-byte and + # single-byte probers that are left. The single-byte probers + # use character bigram distributions to determine the encoding, whereas + # the multi-byte probers use a combination of character unigram and + # bigram distributions. + elif self._input_state == InputState.HIGH_BYTE: + if not self._charset_probers: + self._charset_probers = [MBCSGroupProber(self.lang_filter)] + # If we're checking non-CJK encodings, use single-byte prober + if self.lang_filter & LanguageFilter.NON_CJK: + self._charset_probers.append(SBCSGroupProber()) + self._charset_probers.append(Latin1Prober()) + for prober in self._charset_probers: + if prober.feed(byte_str) == ProbingState.FOUND_IT: + self.result = {'encoding': prober.charset_name, + 'confidence': prober.get_confidence(), + 'language': prober.language} + self.done = True + break + if self.WIN_BYTE_DETECTOR.search(byte_str): + self._has_win_bytes = True + + def close(self): + """ + Stop analyzing the current document and come up with a final + prediction. + + :returns: The ``result`` attribute, a ``dict`` with the keys + `encoding`, `confidence`, and `language`. + """ + # Don't bother with checks if we're already done + if self.done: + return self.result + self.done = True + + if not self._got_data: + self.logger.debug('no data received!') + + # Default to ASCII if it is all we've seen so far + elif self._input_state == InputState.PURE_ASCII: + self.result = {'encoding': 'ascii', + 'confidence': 1.0, + 'language': ''} + + # If we have seen non-ASCII, return the best that met MINIMUM_THRESHOLD + elif self._input_state == InputState.HIGH_BYTE: + prober_confidence = None + max_prober_confidence = 0.0 + max_prober = None + for prober in self._charset_probers: + if not prober: + continue + prober_confidence = prober.get_confidence() + if prober_confidence > max_prober_confidence: + max_prober_confidence = prober_confidence + max_prober = prober + if max_prober and (max_prober_confidence > self.MINIMUM_THRESHOLD): + charset_name = max_prober.charset_name + lower_charset_name = max_prober.charset_name.lower() + confidence = max_prober.get_confidence() + # Use Windows encoding name instead of ISO-8859 if we saw any + # extra Windows-specific bytes + if lower_charset_name.startswith('iso-8859'): + if self._has_win_bytes: + charset_name = self.ISO_WIN_MAP.get(lower_charset_name, + charset_name) + self.result = {'encoding': charset_name, + 'confidence': confidence, + 'language': max_prober.language} + + # Log all prober confidences if none met MINIMUM_THRESHOLD + if self.logger.getEffectiveLevel() == logging.DEBUG: + if self.result['encoding'] is None: + self.logger.debug('no probers hit minimum threshold') + for group_prober in self._charset_probers: + if not group_prober: + continue + if isinstance(group_prober, CharSetGroupProber): + for prober in group_prober.probers: + self.logger.debug('%s %s confidence = %s', + prober.charset_name, + prober.language, + prober.get_confidence()) + else: + self.logger.debug('%s %s confidence = %s', + prober.charset_name, + prober.language, + prober.get_confidence()) + return self.result diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/utf8prober.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/utf8prober.py new file mode 100644 index 0000000000000000000000000000000000000000..6c3196cc2d7e46e6756580267f5643c6f7b448dd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/utf8prober.py @@ -0,0 +1,82 @@ +######################## 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 .enums import ProbingState, MachineState +from .codingstatemachine import CodingStateMachine +from .mbcssm import UTF8_SM_MODEL + + + +class UTF8Prober(CharSetProber): + ONE_CHAR_PROB = 0.5 + + def __init__(self): + super(UTF8Prober, self).__init__() + self.coding_sm = CodingStateMachine(UTF8_SM_MODEL) + self._num_mb_chars = None + self.reset() + + def reset(self): + super(UTF8Prober, self).reset() + self.coding_sm.reset() + self._num_mb_chars = 0 + + @property + def charset_name(self): + return "utf-8" + + @property + def language(self): + return "" + + def feed(self, byte_str): + for c in byte_str: + coding_state = self.coding_sm.next_state(c) + if coding_state == MachineState.ERROR: + self._state = ProbingState.NOT_ME + break + elif coding_state == MachineState.ITS_ME: + self._state = ProbingState.FOUND_IT + break + elif coding_state == MachineState.START: + if self.coding_sm.get_current_charlen() >= 2: + self._num_mb_chars += 1 + + if self.state == ProbingState.DETECTING: + if self.get_confidence() > self.SHORTCUT_THRESHOLD: + self._state = ProbingState.FOUND_IT + + return self.state + + def get_confidence(self): + unlike = 0.99 + if self._num_mb_chars < 6: + unlike *= self.ONE_CHAR_PROB ** self._num_mb_chars + return 1.0 - unlike + else: + return unlike diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/version.py new file mode 100644 index 0000000000000000000000000000000000000000..bb2a34a70ea760ad1f58979acfc8fa466e30c511 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/chardet/version.py @@ -0,0 +1,9 @@ +""" +This module exists only to simplify retrieving the version number of chardet +from within setup.py and from chardet subpackages. + +:author: Dan Blanchard (dan.blanchard@gmail.com) +""" + +__version__ = "3.0.4" +VERSION = __version__.split('.') diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..2a3bf471423bbf789f13755d3dcb03826f7aff36 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/__init__.py @@ -0,0 +1,6 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +from .initialise import init, deinit, reinit, colorama_text +from .ansi import Fore, Back, Style, Cursor +from .ansitowin32 import AnsiToWin32 + +__version__ = '0.4.1' diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/ansi.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/ansi.py new file mode 100644 index 0000000000000000000000000000000000000000..78776588db9410924d8e4af0922fbc3960a37624 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/ansi.py @@ -0,0 +1,102 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +''' +This module generates ANSI character codes to printing colors to terminals. +See: http://en.wikipedia.org/wiki/ANSI_escape_code +''' + +CSI = '\033[' +OSC = '\033]' +BEL = '\007' + + +def code_to_chars(code): + return CSI + str(code) + 'm' + +def set_title(title): + return OSC + '2;' + title + BEL + +def clear_screen(mode=2): + return CSI + str(mode) + 'J' + +def clear_line(mode=2): + return CSI + str(mode) + 'K' + + +class AnsiCodes(object): + def __init__(self): + # the subclasses declare class attributes which are numbers. + # Upon instantiation we define instance attributes, which are the same + # as the class attributes but wrapped with the ANSI escape sequence + for name in dir(self): + if not name.startswith('_'): + value = getattr(self, name) + setattr(self, name, code_to_chars(value)) + + +class AnsiCursor(object): + def UP(self, n=1): + return CSI + str(n) + 'A' + def DOWN(self, n=1): + return CSI + str(n) + 'B' + def FORWARD(self, n=1): + return CSI + str(n) + 'C' + def BACK(self, n=1): + return CSI + str(n) + 'D' + def POS(self, x=1, y=1): + return CSI + str(y) + ';' + str(x) + 'H' + + +class AnsiFore(AnsiCodes): + BLACK = 30 + RED = 31 + GREEN = 32 + YELLOW = 33 + BLUE = 34 + MAGENTA = 35 + CYAN = 36 + WHITE = 37 + RESET = 39 + + # These are fairly well supported, but not part of the standard. + LIGHTBLACK_EX = 90 + LIGHTRED_EX = 91 + LIGHTGREEN_EX = 92 + LIGHTYELLOW_EX = 93 + LIGHTBLUE_EX = 94 + LIGHTMAGENTA_EX = 95 + LIGHTCYAN_EX = 96 + LIGHTWHITE_EX = 97 + + +class AnsiBack(AnsiCodes): + BLACK = 40 + RED = 41 + GREEN = 42 + YELLOW = 43 + BLUE = 44 + MAGENTA = 45 + CYAN = 46 + WHITE = 47 + RESET = 49 + + # These are fairly well supported, but not part of the standard. + LIGHTBLACK_EX = 100 + LIGHTRED_EX = 101 + LIGHTGREEN_EX = 102 + LIGHTYELLOW_EX = 103 + LIGHTBLUE_EX = 104 + LIGHTMAGENTA_EX = 105 + LIGHTCYAN_EX = 106 + LIGHTWHITE_EX = 107 + + +class AnsiStyle(AnsiCodes): + BRIGHT = 1 + DIM = 2 + NORMAL = 22 + RESET_ALL = 0 + +Fore = AnsiFore() +Back = AnsiBack() +Style = AnsiStyle() +Cursor = AnsiCursor() diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/ansitowin32.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/ansitowin32.py new file mode 100644 index 0000000000000000000000000000000000000000..359c92be50ee3c97aafbc8d31c16e5fbf2e6d022 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/ansitowin32.py @@ -0,0 +1,257 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +import re +import sys +import os + +from .ansi import AnsiFore, AnsiBack, AnsiStyle, Style +from .winterm import WinTerm, WinColor, WinStyle +from .win32 import windll, winapi_test + + +winterm = None +if windll is not None: + winterm = WinTerm() + + +class StreamWrapper(object): + ''' + Wraps a stream (such as stdout), acting as a transparent proxy for all + attribute access apart from method 'write()', which is delegated to our + Converter instance. + ''' + def __init__(self, wrapped, converter): + # double-underscore everything to prevent clashes with names of + # attributes on the wrapped stream object. + self.__wrapped = wrapped + self.__convertor = converter + + def __getattr__(self, name): + return getattr(self.__wrapped, name) + + def __enter__(self, *args, **kwargs): + # special method lookup bypasses __getattr__/__getattribute__, see + # https://stackoverflow.com/questions/12632894/why-doesnt-getattr-work-with-exit + # thus, contextlib magic methods are not proxied via __getattr__ + return self.__wrapped.__enter__(*args, **kwargs) + + def __exit__(self, *args, **kwargs): + return self.__wrapped.__exit__(*args, **kwargs) + + def write(self, text): + self.__convertor.write(text) + + def isatty(self): + stream = self.__wrapped + if 'PYCHARM_HOSTED' in os.environ: + if stream is not None and (stream is sys.__stdout__ or stream is sys.__stderr__): + return True + try: + stream_isatty = stream.isatty + except AttributeError: + return False + else: + return stream_isatty() + + @property + def closed(self): + stream = self.__wrapped + try: + return stream.closed + except AttributeError: + return True + + +class AnsiToWin32(object): + ''' + Implements a 'write()' method which, on Windows, will strip ANSI character + sequences from the text, and if outputting to a tty, will convert them into + win32 function calls. + ''' + ANSI_CSI_RE = re.compile('\001?\033\\[((?:\\d|;)*)([a-zA-Z])\002?') # Control Sequence Introducer + ANSI_OSC_RE = re.compile('\001?\033\\]((?:.|;)*?)(\x07)\002?') # Operating System Command + + def __init__(self, wrapped, convert=None, strip=None, autoreset=False): + # The wrapped stream (normally sys.stdout or sys.stderr) + self.wrapped = wrapped + + # should we reset colors to defaults after every .write() + self.autoreset = autoreset + + # create the proxy wrapping our output stream + self.stream = StreamWrapper(wrapped, self) + + on_windows = os.name == 'nt' + # We test if the WinAPI works, because even if we are on Windows + # we may be using a terminal that doesn't support the WinAPI + # (e.g. Cygwin Terminal). In this case it's up to the terminal + # to support the ANSI codes. + conversion_supported = on_windows and winapi_test() + + # should we strip ANSI sequences from our output? + if strip is None: + strip = conversion_supported or (not self.stream.closed and not self.stream.isatty()) + self.strip = strip + + # should we should convert ANSI sequences into win32 calls? + if convert is None: + convert = conversion_supported and not self.stream.closed and self.stream.isatty() + self.convert = convert + + # dict of ansi codes to win32 functions and parameters + self.win32_calls = self.get_win32_calls() + + # are we wrapping stderr? + self.on_stderr = self.wrapped is sys.stderr + + def should_wrap(self): + ''' + True if this class is actually needed. If false, then the output + stream will not be affected, nor will win32 calls be issued, so + wrapping stdout is not actually required. This will generally be + False on non-Windows platforms, unless optional functionality like + autoreset has been requested using kwargs to init() + ''' + return self.convert or self.strip or self.autoreset + + def get_win32_calls(self): + if self.convert and winterm: + return { + AnsiStyle.RESET_ALL: (winterm.reset_all, ), + AnsiStyle.BRIGHT: (winterm.style, WinStyle.BRIGHT), + AnsiStyle.DIM: (winterm.style, WinStyle.NORMAL), + AnsiStyle.NORMAL: (winterm.style, WinStyle.NORMAL), + AnsiFore.BLACK: (winterm.fore, WinColor.BLACK), + AnsiFore.RED: (winterm.fore, WinColor.RED), + AnsiFore.GREEN: (winterm.fore, WinColor.GREEN), + AnsiFore.YELLOW: (winterm.fore, WinColor.YELLOW), + AnsiFore.BLUE: (winterm.fore, WinColor.BLUE), + AnsiFore.MAGENTA: (winterm.fore, WinColor.MAGENTA), + AnsiFore.CYAN: (winterm.fore, WinColor.CYAN), + AnsiFore.WHITE: (winterm.fore, WinColor.GREY), + AnsiFore.RESET: (winterm.fore, ), + AnsiFore.LIGHTBLACK_EX: (winterm.fore, WinColor.BLACK, True), + AnsiFore.LIGHTRED_EX: (winterm.fore, WinColor.RED, True), + AnsiFore.LIGHTGREEN_EX: (winterm.fore, WinColor.GREEN, True), + AnsiFore.LIGHTYELLOW_EX: (winterm.fore, WinColor.YELLOW, True), + AnsiFore.LIGHTBLUE_EX: (winterm.fore, WinColor.BLUE, True), + AnsiFore.LIGHTMAGENTA_EX: (winterm.fore, WinColor.MAGENTA, True), + AnsiFore.LIGHTCYAN_EX: (winterm.fore, WinColor.CYAN, True), + AnsiFore.LIGHTWHITE_EX: (winterm.fore, WinColor.GREY, True), + AnsiBack.BLACK: (winterm.back, WinColor.BLACK), + AnsiBack.RED: (winterm.back, WinColor.RED), + AnsiBack.GREEN: (winterm.back, WinColor.GREEN), + AnsiBack.YELLOW: (winterm.back, WinColor.YELLOW), + AnsiBack.BLUE: (winterm.back, WinColor.BLUE), + AnsiBack.MAGENTA: (winterm.back, WinColor.MAGENTA), + AnsiBack.CYAN: (winterm.back, WinColor.CYAN), + AnsiBack.WHITE: (winterm.back, WinColor.GREY), + AnsiBack.RESET: (winterm.back, ), + AnsiBack.LIGHTBLACK_EX: (winterm.back, WinColor.BLACK, True), + AnsiBack.LIGHTRED_EX: (winterm.back, WinColor.RED, True), + AnsiBack.LIGHTGREEN_EX: (winterm.back, WinColor.GREEN, True), + AnsiBack.LIGHTYELLOW_EX: (winterm.back, WinColor.YELLOW, True), + AnsiBack.LIGHTBLUE_EX: (winterm.back, WinColor.BLUE, True), + AnsiBack.LIGHTMAGENTA_EX: (winterm.back, WinColor.MAGENTA, True), + AnsiBack.LIGHTCYAN_EX: (winterm.back, WinColor.CYAN, True), + AnsiBack.LIGHTWHITE_EX: (winterm.back, WinColor.GREY, True), + } + return dict() + + def write(self, text): + if self.strip or self.convert: + self.write_and_convert(text) + else: + self.wrapped.write(text) + self.wrapped.flush() + if self.autoreset: + self.reset_all() + + + def reset_all(self): + if self.convert: + self.call_win32('m', (0,)) + elif not self.strip and not self.stream.closed: + self.wrapped.write(Style.RESET_ALL) + + + def write_and_convert(self, text): + ''' + Write the given text to our wrapped stream, stripping any ANSI + sequences from the text, and optionally converting them into win32 + calls. + ''' + cursor = 0 + text = self.convert_osc(text) + for match in self.ANSI_CSI_RE.finditer(text): + start, end = match.span() + self.write_plain_text(text, cursor, start) + self.convert_ansi(*match.groups()) + cursor = end + self.write_plain_text(text, cursor, len(text)) + + + def write_plain_text(self, text, start, end): + if start < end: + self.wrapped.write(text[start:end]) + self.wrapped.flush() + + + def convert_ansi(self, paramstring, command): + if self.convert: + params = self.extract_params(command, paramstring) + self.call_win32(command, params) + + + def extract_params(self, command, paramstring): + if command in 'Hf': + params = tuple(int(p) if len(p) != 0 else 1 for p in paramstring.split(';')) + while len(params) < 2: + # defaults: + params = params + (1,) + else: + params = tuple(int(p) for p in paramstring.split(';') if len(p) != 0) + if len(params) == 0: + # defaults: + if command in 'JKm': + params = (0,) + elif command in 'ABCD': + params = (1,) + + return params + + + def call_win32(self, command, params): + if command == 'm': + for param in params: + if param in self.win32_calls: + func_args = self.win32_calls[param] + func = func_args[0] + args = func_args[1:] + kwargs = dict(on_stderr=self.on_stderr) + func(*args, **kwargs) + elif command in 'J': + winterm.erase_screen(params[0], on_stderr=self.on_stderr) + elif command in 'K': + winterm.erase_line(params[0], on_stderr=self.on_stderr) + elif command in 'Hf': # cursor position - absolute + winterm.set_cursor_position(params, on_stderr=self.on_stderr) + elif command in 'ABCD': # cursor position - relative + n = params[0] + # A - up, B - down, C - forward, D - back + x, y = {'A': (0, -n), 'B': (0, n), 'C': (n, 0), 'D': (-n, 0)}[command] + winterm.cursor_adjust(x, y, on_stderr=self.on_stderr) + + + def convert_osc(self, text): + for match in self.ANSI_OSC_RE.finditer(text): + start, end = match.span() + text = text[:start] + text[end:] + paramstring, command = match.groups() + if command in '\x07': # \x07 = BEL + params = paramstring.split(";") + # 0 - change title and icon (we will only change title) + # 1 - change icon (we don't support this) + # 2 - change title + if params[0] in '02': + winterm.set_title(params[1]) + return text diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/initialise.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/initialise.py new file mode 100644 index 0000000000000000000000000000000000000000..430d0668727cd0521270a52c962867907d743b34 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/initialise.py @@ -0,0 +1,80 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +import atexit +import contextlib +import sys + +from .ansitowin32 import AnsiToWin32 + + +orig_stdout = None +orig_stderr = None + +wrapped_stdout = None +wrapped_stderr = None + +atexit_done = False + + +def reset_all(): + if AnsiToWin32 is not None: # Issue #74: objects might become None at exit + AnsiToWin32(orig_stdout).reset_all() + + +def init(autoreset=False, convert=None, strip=None, wrap=True): + + if not wrap and any([autoreset, convert, strip]): + raise ValueError('wrap=False conflicts with any other arg=True') + + global wrapped_stdout, wrapped_stderr + global orig_stdout, orig_stderr + + orig_stdout = sys.stdout + orig_stderr = sys.stderr + + if sys.stdout is None: + wrapped_stdout = None + else: + sys.stdout = wrapped_stdout = \ + wrap_stream(orig_stdout, convert, strip, autoreset, wrap) + if sys.stderr is None: + wrapped_stderr = None + else: + sys.stderr = wrapped_stderr = \ + wrap_stream(orig_stderr, convert, strip, autoreset, wrap) + + global atexit_done + if not atexit_done: + atexit.register(reset_all) + atexit_done = True + + +def deinit(): + if orig_stdout is not None: + sys.stdout = orig_stdout + if orig_stderr is not None: + sys.stderr = orig_stderr + + +@contextlib.contextmanager +def colorama_text(*args, **kwargs): + init(*args, **kwargs) + try: + yield + finally: + deinit() + + +def reinit(): + if wrapped_stdout is not None: + sys.stdout = wrapped_stdout + if wrapped_stderr is not None: + sys.stderr = wrapped_stderr + + +def wrap_stream(stream, convert, strip, autoreset, wrap): + if wrap: + wrapper = AnsiToWin32(stream, + convert=convert, strip=strip, autoreset=autoreset) + if wrapper.should_wrap(): + stream = wrapper.stream + return stream diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/win32.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/win32.py new file mode 100644 index 0000000000000000000000000000000000000000..c2d836033673993e00a02d5a3802b61cd051cf08 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/win32.py @@ -0,0 +1,152 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. + +# from winbase.h +STDOUT = -11 +STDERR = -12 + +try: + import ctypes + from ctypes import LibraryLoader + windll = LibraryLoader(ctypes.WinDLL) + from ctypes import wintypes +except (AttributeError, ImportError): + windll = None + SetConsoleTextAttribute = lambda *_: None + winapi_test = lambda *_: None +else: + from ctypes import byref, Structure, c_char, POINTER + + COORD = wintypes._COORD + + class CONSOLE_SCREEN_BUFFER_INFO(Structure): + """struct in wincon.h.""" + _fields_ = [ + ("dwSize", COORD), + ("dwCursorPosition", COORD), + ("wAttributes", wintypes.WORD), + ("srWindow", wintypes.SMALL_RECT), + ("dwMaximumWindowSize", COORD), + ] + def __str__(self): + return '(%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)' % ( + self.dwSize.Y, self.dwSize.X + , self.dwCursorPosition.Y, self.dwCursorPosition.X + , self.wAttributes + , self.srWindow.Top, self.srWindow.Left, self.srWindow.Bottom, self.srWindow.Right + , self.dwMaximumWindowSize.Y, self.dwMaximumWindowSize.X + ) + + _GetStdHandle = windll.kernel32.GetStdHandle + _GetStdHandle.argtypes = [ + wintypes.DWORD, + ] + _GetStdHandle.restype = wintypes.HANDLE + + _GetConsoleScreenBufferInfo = windll.kernel32.GetConsoleScreenBufferInfo + _GetConsoleScreenBufferInfo.argtypes = [ + wintypes.HANDLE, + POINTER(CONSOLE_SCREEN_BUFFER_INFO), + ] + _GetConsoleScreenBufferInfo.restype = wintypes.BOOL + + _SetConsoleTextAttribute = windll.kernel32.SetConsoleTextAttribute + _SetConsoleTextAttribute.argtypes = [ + wintypes.HANDLE, + wintypes.WORD, + ] + _SetConsoleTextAttribute.restype = wintypes.BOOL + + _SetConsoleCursorPosition = windll.kernel32.SetConsoleCursorPosition + _SetConsoleCursorPosition.argtypes = [ + wintypes.HANDLE, + COORD, + ] + _SetConsoleCursorPosition.restype = wintypes.BOOL + + _FillConsoleOutputCharacterA = windll.kernel32.FillConsoleOutputCharacterA + _FillConsoleOutputCharacterA.argtypes = [ + wintypes.HANDLE, + c_char, + wintypes.DWORD, + COORD, + POINTER(wintypes.DWORD), + ] + _FillConsoleOutputCharacterA.restype = wintypes.BOOL + + _FillConsoleOutputAttribute = windll.kernel32.FillConsoleOutputAttribute + _FillConsoleOutputAttribute.argtypes = [ + wintypes.HANDLE, + wintypes.WORD, + wintypes.DWORD, + COORD, + POINTER(wintypes.DWORD), + ] + _FillConsoleOutputAttribute.restype = wintypes.BOOL + + _SetConsoleTitleW = windll.kernel32.SetConsoleTitleW + _SetConsoleTitleW.argtypes = [ + wintypes.LPCWSTR + ] + _SetConsoleTitleW.restype = wintypes.BOOL + + def _winapi_test(handle): + csbi = CONSOLE_SCREEN_BUFFER_INFO() + success = _GetConsoleScreenBufferInfo( + handle, byref(csbi)) + return bool(success) + + def winapi_test(): + return any(_winapi_test(h) for h in + (_GetStdHandle(STDOUT), _GetStdHandle(STDERR))) + + def GetConsoleScreenBufferInfo(stream_id=STDOUT): + handle = _GetStdHandle(stream_id) + csbi = CONSOLE_SCREEN_BUFFER_INFO() + success = _GetConsoleScreenBufferInfo( + handle, byref(csbi)) + return csbi + + def SetConsoleTextAttribute(stream_id, attrs): + handle = _GetStdHandle(stream_id) + return _SetConsoleTextAttribute(handle, attrs) + + def SetConsoleCursorPosition(stream_id, position, adjust=True): + position = COORD(*position) + # If the position is out of range, do nothing. + if position.Y <= 0 or position.X <= 0: + return + # Adjust for Windows' SetConsoleCursorPosition: + # 1. being 0-based, while ANSI is 1-based. + # 2. expecting (x,y), while ANSI uses (y,x). + adjusted_position = COORD(position.Y - 1, position.X - 1) + if adjust: + # Adjust for viewport's scroll position + sr = GetConsoleScreenBufferInfo(STDOUT).srWindow + adjusted_position.Y += sr.Top + adjusted_position.X += sr.Left + # Resume normal processing + handle = _GetStdHandle(stream_id) + return _SetConsoleCursorPosition(handle, adjusted_position) + + def FillConsoleOutputCharacter(stream_id, char, length, start): + handle = _GetStdHandle(stream_id) + char = c_char(char.encode()) + length = wintypes.DWORD(length) + num_written = wintypes.DWORD(0) + # Note that this is hard-coded for ANSI (vs wide) bytes. + success = _FillConsoleOutputCharacterA( + handle, char, length, start, byref(num_written)) + return num_written.value + + def FillConsoleOutputAttribute(stream_id, attr, length, start): + ''' FillConsoleOutputAttribute( hConsole, csbi.wAttributes, dwConSize, coordScreen, &cCharsWritten )''' + handle = _GetStdHandle(stream_id) + attribute = wintypes.WORD(attr) + length = wintypes.DWORD(length) + num_written = wintypes.DWORD(0) + # Note that this is hard-coded for ANSI (vs wide) bytes. + return _FillConsoleOutputAttribute( + handle, attribute, length, start, byref(num_written)) + + def SetConsoleTitle(title): + return _SetConsoleTitleW(title) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/winterm.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/winterm.py new file mode 100644 index 0000000000000000000000000000000000000000..0fdb4ec4e91090876dc3fbf207049b521fa0dd73 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/colorama/winterm.py @@ -0,0 +1,169 @@ +# Copyright Jonathan Hartley 2013. BSD 3-Clause license, see LICENSE file. +from . import win32 + + +# from wincon.h +class WinColor(object): + BLACK = 0 + BLUE = 1 + GREEN = 2 + CYAN = 3 + RED = 4 + MAGENTA = 5 + YELLOW = 6 + GREY = 7 + +# from wincon.h +class WinStyle(object): + NORMAL = 0x00 # dim text, dim background + BRIGHT = 0x08 # bright text, dim background + BRIGHT_BACKGROUND = 0x80 # dim text, bright background + +class WinTerm(object): + + def __init__(self): + self._default = win32.GetConsoleScreenBufferInfo(win32.STDOUT).wAttributes + self.set_attrs(self._default) + self._default_fore = self._fore + self._default_back = self._back + self._default_style = self._style + # In order to emulate LIGHT_EX in windows, we borrow the BRIGHT style. + # So that LIGHT_EX colors and BRIGHT style do not clobber each other, + # we track them separately, since LIGHT_EX is overwritten by Fore/Back + # and BRIGHT is overwritten by Style codes. + self._light = 0 + + def get_attrs(self): + return self._fore + self._back * 16 + (self._style | self._light) + + def set_attrs(self, value): + self._fore = value & 7 + self._back = (value >> 4) & 7 + self._style = value & (WinStyle.BRIGHT | WinStyle.BRIGHT_BACKGROUND) + + def reset_all(self, on_stderr=None): + self.set_attrs(self._default) + self.set_console(attrs=self._default) + self._light = 0 + + def fore(self, fore=None, light=False, on_stderr=False): + if fore is None: + fore = self._default_fore + self._fore = fore + # Emulate LIGHT_EX with BRIGHT Style + if light: + self._light |= WinStyle.BRIGHT + else: + self._light &= ~WinStyle.BRIGHT + self.set_console(on_stderr=on_stderr) + + def back(self, back=None, light=False, on_stderr=False): + if back is None: + back = self._default_back + self._back = back + # Emulate LIGHT_EX with BRIGHT_BACKGROUND Style + if light: + self._light |= WinStyle.BRIGHT_BACKGROUND + else: + self._light &= ~WinStyle.BRIGHT_BACKGROUND + self.set_console(on_stderr=on_stderr) + + def style(self, style=None, on_stderr=False): + if style is None: + style = self._default_style + self._style = style + self.set_console(on_stderr=on_stderr) + + def set_console(self, attrs=None, on_stderr=False): + if attrs is None: + attrs = self.get_attrs() + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + win32.SetConsoleTextAttribute(handle, attrs) + + def get_position(self, handle): + position = win32.GetConsoleScreenBufferInfo(handle).dwCursorPosition + # Because Windows coordinates are 0-based, + # and win32.SetConsoleCursorPosition expects 1-based. + position.X += 1 + position.Y += 1 + return position + + def set_cursor_position(self, position=None, on_stderr=False): + if position is None: + # I'm not currently tracking the position, so there is no default. + # position = self.get_position() + return + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + win32.SetConsoleCursorPosition(handle, position) + + def cursor_adjust(self, x, y, on_stderr=False): + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + position = self.get_position(handle) + adjusted_position = (position.Y + y, position.X + x) + win32.SetConsoleCursorPosition(handle, adjusted_position, adjust=False) + + def erase_screen(self, mode=0, on_stderr=False): + # 0 should clear from the cursor to the end of the screen. + # 1 should clear from the cursor to the beginning of the screen. + # 2 should clear the entire screen, and move cursor to (1,1) + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + csbi = win32.GetConsoleScreenBufferInfo(handle) + # get the number of character cells in the current buffer + cells_in_screen = csbi.dwSize.X * csbi.dwSize.Y + # get number of character cells before current cursor position + cells_before_cursor = csbi.dwSize.X * csbi.dwCursorPosition.Y + csbi.dwCursorPosition.X + if mode == 0: + from_coord = csbi.dwCursorPosition + cells_to_erase = cells_in_screen - cells_before_cursor + elif mode == 1: + from_coord = win32.COORD(0, 0) + cells_to_erase = cells_before_cursor + elif mode == 2: + from_coord = win32.COORD(0, 0) + cells_to_erase = cells_in_screen + else: + # invalid mode + return + # fill the entire screen with blanks + win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord) + # now set the buffer's attributes accordingly + win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord) + if mode == 2: + # put the cursor where needed + win32.SetConsoleCursorPosition(handle, (1, 1)) + + def erase_line(self, mode=0, on_stderr=False): + # 0 should clear from the cursor to the end of the line. + # 1 should clear from the cursor to the beginning of the line. + # 2 should clear the entire line. + handle = win32.STDOUT + if on_stderr: + handle = win32.STDERR + csbi = win32.GetConsoleScreenBufferInfo(handle) + if mode == 0: + from_coord = csbi.dwCursorPosition + cells_to_erase = csbi.dwSize.X - csbi.dwCursorPosition.X + elif mode == 1: + from_coord = win32.COORD(0, csbi.dwCursorPosition.Y) + cells_to_erase = csbi.dwCursorPosition.X + elif mode == 2: + from_coord = win32.COORD(0, csbi.dwCursorPosition.Y) + cells_to_erase = csbi.dwSize.X + else: + # invalid mode + return + # fill the entire screen with blanks + win32.FillConsoleOutputCharacter(handle, ' ', cells_to_erase, from_coord) + # now set the buffer's attributes accordingly + win32.FillConsoleOutputAttribute(handle, self.get_attrs(), cells_to_erase, from_coord) + + def set_title(self, title): + win32.SetConsoleTitle(title) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/compat.py new file mode 100644 index 0000000000000000000000000000000000000000..ff328c8ee491f9f3c943cf637dc7ea17ea33ee3b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/compat.py @@ -0,0 +1,1120 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2013-2017 Vinay Sajip. +# Licensed to the Python Software Foundation under a contributor agreement. +# See LICENSE.txt and CONTRIBUTORS.txt. +# +from __future__ import absolute_import + +import os +import re +import sys + +try: + import ssl +except ImportError: # pragma: no cover + ssl = None + +if sys.version_info[0] < 3: # pragma: no cover + from StringIO import StringIO + string_types = basestring, + text_type = unicode + from types import FileType as file_type + import __builtin__ as builtins + import ConfigParser as configparser + from ._backport import shutil + from urlparse import urlparse, urlunparse, urljoin, urlsplit, urlunsplit + from urllib import (urlretrieve, quote as _quote, unquote, url2pathname, + pathname2url, ContentTooShortError, splittype) + + def quote(s): + if isinstance(s, unicode): + s = s.encode('utf-8') + return _quote(s) + + import urllib2 + from urllib2 import (Request, urlopen, URLError, HTTPError, + HTTPBasicAuthHandler, HTTPPasswordMgr, + HTTPHandler, HTTPRedirectHandler, + build_opener) + if ssl: + from urllib2 import HTTPSHandler + import httplib + import xmlrpclib + import Queue as queue + from HTMLParser import HTMLParser + import htmlentitydefs + raw_input = raw_input + from itertools import ifilter as filter + from itertools import ifilterfalse as filterfalse + + _userprog = None + def splituser(host): + """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'.""" + global _userprog + if _userprog is None: + import re + _userprog = re.compile('^(.*)@(.*)$') + + match = _userprog.match(host) + if match: return match.group(1, 2) + return None, host + +else: # pragma: no cover + from io import StringIO + string_types = str, + text_type = str + from io import TextIOWrapper as file_type + import builtins + import configparser + import shutil + from urllib.parse import (urlparse, urlunparse, urljoin, splituser, quote, + unquote, urlsplit, urlunsplit, splittype) + from urllib.request import (urlopen, urlretrieve, Request, url2pathname, + pathname2url, + HTTPBasicAuthHandler, HTTPPasswordMgr, + HTTPHandler, HTTPRedirectHandler, + build_opener) + if ssl: + from urllib.request import HTTPSHandler + from urllib.error import HTTPError, URLError, ContentTooShortError + import http.client as httplib + import urllib.request as urllib2 + import xmlrpc.client as xmlrpclib + import queue + from html.parser import HTMLParser + import html.entities as htmlentitydefs + raw_input = input + from itertools import filterfalse + filter = filter + +try: + from ssl import match_hostname, CertificateError +except ImportError: # pragma: no cover + 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 + + parts = dn.split('.') + leftmost, remainder = parts[0], 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 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") + dnsnames = [] + san = cert.get('subjectAltName', ()) + for key, value in san: + if key == 'DNS': + if _dnsname_match(value, hostname): + 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") + + +try: + from types import SimpleNamespace as Container +except ImportError: # pragma: no cover + class Container(object): + """ + A generic container for when multiple values need to be returned + """ + def __init__(self, **kwargs): + self.__dict__.update(kwargs) + + +try: + from shutil import which +except ImportError: # pragma: no cover + # Implementation from Python 3.3 + def which(cmd, mode=os.F_OK | os.X_OK, path=None): + """Given a command, mode, and a PATH string, return the path which + conforms to the given mode on the PATH, or None if there is no such + file. + + `mode` defaults to os.F_OK | os.X_OK. `path` defaults to the result + of os.environ.get("PATH"), or can be overridden with a custom search + path. + + """ + # Check that a given file can be accessed with the correct mode. + # Additionally check that `file` is not a directory, as on Windows + # directories pass the os.access check. + def _access_check(fn, mode): + return (os.path.exists(fn) and os.access(fn, mode) + and not os.path.isdir(fn)) + + # If we're given a path with a directory part, look it up directly rather + # than referring to PATH directories. This includes checking relative to the + # current directory, e.g. ./script + if os.path.dirname(cmd): + if _access_check(cmd, mode): + return cmd + return None + + if path is None: + path = os.environ.get("PATH", os.defpath) + if not path: + return None + path = path.split(os.pathsep) + + if sys.platform == "win32": + # The current directory takes precedence on Windows. + if not os.curdir in path: + path.insert(0, os.curdir) + + # PATHEXT is necessary to check on Windows. + pathext = os.environ.get("PATHEXT", "").split(os.pathsep) + # See if the given file matches any of the expected path extensions. + # This will allow us to short circuit when given "python.exe". + # If it does match, only test that one, otherwise we have to try + # others. + if any(cmd.lower().endswith(ext.lower()) for ext in pathext): + files = [cmd] + else: + files = [cmd + ext for ext in pathext] + else: + # On other platforms you don't have things like PATHEXT to tell you + # what file suffixes are executable, so just pass on cmd as-is. + files = [cmd] + + seen = set() + for dir in path: + normdir = os.path.normcase(dir) + if not normdir in seen: + seen.add(normdir) + for thefile in files: + name = os.path.join(dir, thefile) + if _access_check(name, mode): + return name + return None + + +# ZipFile is a context manager in 2.7, but not in 2.6 + +from zipfile import ZipFile as BaseZipFile + +if hasattr(BaseZipFile, '__enter__'): # pragma: no cover + ZipFile = BaseZipFile +else: # pragma: no cover + from zipfile import ZipExtFile as BaseZipExtFile + + class ZipExtFile(BaseZipExtFile): + def __init__(self, base): + self.__dict__.update(base.__dict__) + + def __enter__(self): + return self + + def __exit__(self, *exc_info): + self.close() + # return None, so if an exception occurred, it will propagate + + class ZipFile(BaseZipFile): + def __enter__(self): + return self + + def __exit__(self, *exc_info): + self.close() + # return None, so if an exception occurred, it will propagate + + def open(self, *args, **kwargs): + base = BaseZipFile.open(self, *args, **kwargs) + return ZipExtFile(base) + +try: + from platform import python_implementation +except ImportError: # pragma: no cover + def python_implementation(): + """Return a string identifying the Python implementation.""" + if 'PyPy' in sys.version: + return 'PyPy' + if os.name == 'java': + return 'Jython' + if sys.version.startswith('IronPython'): + return 'IronPython' + return 'CPython' + +try: + import sysconfig +except ImportError: # pragma: no cover + from ._backport import sysconfig + +try: + callable = callable +except NameError: # pragma: no cover + from collections import Callable + + def callable(obj): + return isinstance(obj, Callable) + + +try: + fsencode = os.fsencode + fsdecode = os.fsdecode +except AttributeError: # pragma: no cover + # Issue #99: on some systems (e.g. containerised), + # sys.getfilesystemencoding() returns None, and we need a real value, + # so fall back to utf-8. From the CPython 2.7 docs relating to Unix and + # sys.getfilesystemencoding(): the return value is "the user’s preference + # according to the result of nl_langinfo(CODESET), or None if the + # nl_langinfo(CODESET) failed." + _fsencoding = sys.getfilesystemencoding() or 'utf-8' + if _fsencoding == 'mbcs': + _fserrors = 'strict' + else: + _fserrors = 'surrogateescape' + + def fsencode(filename): + if isinstance(filename, bytes): + return filename + elif isinstance(filename, text_type): + return filename.encode(_fsencoding, _fserrors) + else: + raise TypeError("expect bytes or str, not %s" % + type(filename).__name__) + + def fsdecode(filename): + if isinstance(filename, text_type): + return filename + elif isinstance(filename, bytes): + return filename.decode(_fsencoding, _fserrors) + else: + raise TypeError("expect bytes or str, not %s" % + type(filename).__name__) + +try: + from tokenize import detect_encoding +except ImportError: # pragma: no cover + from codecs import BOM_UTF8, lookup + import re + + cookie_re = re.compile(r"coding[:=]\s*([-\w.]+)") + + def _get_normal_name(orig_enc): + """Imitates get_normal_name in tokenizer.c.""" + # Only care about the first 12 characters. + enc = orig_enc[:12].lower().replace("_", "-") + if enc == "utf-8" or enc.startswith("utf-8-"): + return "utf-8" + if enc in ("latin-1", "iso-8859-1", "iso-latin-1") or \ + enc.startswith(("latin-1-", "iso-8859-1-", "iso-latin-1-")): + return "iso-8859-1" + return orig_enc + + def detect_encoding(readline): + """ + The detect_encoding() function is used to detect the encoding that should + be used to decode a Python source file. It requires one argument, readline, + in the same way as the tokenize() generator. + + It will call readline a maximum of twice, and return the encoding used + (as a string) and a list of any lines (left as bytes) it has read in. + + It detects the encoding from the presence of a utf-8 bom or an encoding + cookie as specified in pep-0263. If both a bom and a cookie are present, + but disagree, a SyntaxError will be raised. If the encoding cookie is an + invalid charset, raise a SyntaxError. Note that if a utf-8 bom is found, + 'utf-8-sig' is returned. + + If no encoding is specified, then the default of 'utf-8' will be returned. + """ + try: + filename = readline.__self__.name + except AttributeError: + filename = None + bom_found = False + encoding = None + default = 'utf-8' + def read_or_stop(): + try: + return readline() + except StopIteration: + return b'' + + def find_cookie(line): + try: + # Decode as UTF-8. Either the line is an encoding declaration, + # in which case it should be pure ASCII, or it must be UTF-8 + # per default encoding. + line_string = line.decode('utf-8') + except UnicodeDecodeError: + msg = "invalid or missing encoding declaration" + if filename is not None: + msg = '{} for {!r}'.format(msg, filename) + raise SyntaxError(msg) + + matches = cookie_re.findall(line_string) + if not matches: + return None + encoding = _get_normal_name(matches[0]) + try: + codec = lookup(encoding) + except LookupError: + # This behaviour mimics the Python interpreter + if filename is None: + msg = "unknown encoding: " + encoding + else: + msg = "unknown encoding for {!r}: {}".format(filename, + encoding) + raise SyntaxError(msg) + + if bom_found: + if codec.name != 'utf-8': + # This behaviour mimics the Python interpreter + if filename is None: + msg = 'encoding problem: utf-8' + else: + msg = 'encoding problem for {!r}: utf-8'.format(filename) + raise SyntaxError(msg) + encoding += '-sig' + return encoding + + first = read_or_stop() + if first.startswith(BOM_UTF8): + bom_found = True + first = first[3:] + default = 'utf-8-sig' + if not first: + return default, [] + + encoding = find_cookie(first) + if encoding: + return encoding, [first] + + second = read_or_stop() + if not second: + return default, [first] + + encoding = find_cookie(second) + if encoding: + return encoding, [first, second] + + return default, [first, second] + +# For converting & <-> & etc. +try: + from html import escape +except ImportError: + from cgi import escape +if sys.version_info[:2] < (3, 4): + unescape = HTMLParser().unescape +else: + from html import unescape + +try: + from collections import ChainMap +except ImportError: # pragma: no cover + from collections import MutableMapping + + try: + from reprlib import recursive_repr as _recursive_repr + except ImportError: + def _recursive_repr(fillvalue='...'): + ''' + Decorator to make a repr function return fillvalue for a recursive + call + ''' + + def decorating_function(user_function): + repr_running = set() + + def wrapper(self): + key = id(self), get_ident() + if key in repr_running: + return fillvalue + repr_running.add(key) + try: + result = user_function(self) + finally: + repr_running.discard(key) + return result + + # Can't use functools.wraps() here because of bootstrap issues + wrapper.__module__ = getattr(user_function, '__module__') + wrapper.__doc__ = getattr(user_function, '__doc__') + wrapper.__name__ = getattr(user_function, '__name__') + wrapper.__annotations__ = getattr(user_function, '__annotations__', {}) + return wrapper + + return decorating_function + + class ChainMap(MutableMapping): + ''' A ChainMap groups multiple dicts (or other mappings) together + to create a single, updateable view. + + The underlying mappings are stored in a list. That list is public and can + accessed or updated using the *maps* attribute. There is no other state. + + Lookups search the underlying mappings successively until a key is found. + In contrast, writes, updates, and deletions only operate on the first + mapping. + + ''' + + def __init__(self, *maps): + '''Initialize a ChainMap by setting *maps* to the given mappings. + If no mappings are provided, a single empty dictionary is used. + + ''' + self.maps = list(maps) or [{}] # always at least one map + + def __missing__(self, key): + raise KeyError(key) + + def __getitem__(self, key): + for mapping in self.maps: + try: + return mapping[key] # can't use 'key in mapping' with defaultdict + except KeyError: + pass + return self.__missing__(key) # support subclasses that define __missing__ + + def get(self, key, default=None): + return self[key] if key in self else default + + def __len__(self): + return len(set().union(*self.maps)) # reuses stored hash values if possible + + def __iter__(self): + return iter(set().union(*self.maps)) + + def __contains__(self, key): + return any(key in m for m in self.maps) + + def __bool__(self): + return any(self.maps) + + @_recursive_repr() + def __repr__(self): + return '{0.__class__.__name__}({1})'.format( + self, ', '.join(map(repr, self.maps))) + + @classmethod + def fromkeys(cls, iterable, *args): + 'Create a ChainMap with a single dict created from the iterable.' + return cls(dict.fromkeys(iterable, *args)) + + def copy(self): + 'New ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]' + return self.__class__(self.maps[0].copy(), *self.maps[1:]) + + __copy__ = copy + + def new_child(self): # like Django's Context.push() + 'New ChainMap with a new dict followed by all previous maps.' + return self.__class__({}, *self.maps) + + @property + def parents(self): # like Django's Context.pop() + 'New ChainMap from maps[1:].' + return self.__class__(*self.maps[1:]) + + def __setitem__(self, key, value): + self.maps[0][key] = value + + def __delitem__(self, key): + try: + del self.maps[0][key] + except KeyError: + raise KeyError('Key not found in the first mapping: {!r}'.format(key)) + + def popitem(self): + 'Remove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.' + try: + return self.maps[0].popitem() + except KeyError: + raise KeyError('No keys found in the first mapping.') + + def pop(self, key, *args): + 'Remove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].' + try: + return self.maps[0].pop(key, *args) + except KeyError: + raise KeyError('Key not found in the first mapping: {!r}'.format(key)) + + def clear(self): + 'Clear maps[0], leaving maps[1:] intact.' + self.maps[0].clear() + +try: + from importlib.util import cache_from_source # Python >= 3.4 +except ImportError: # pragma: no cover + try: + from imp import cache_from_source + except ImportError: # pragma: no cover + def cache_from_source(path, debug_override=None): + assert path.endswith('.py') + if debug_override is None: + debug_override = __debug__ + if debug_override: + suffix = 'c' + else: + suffix = 'o' + return path + suffix + +try: + from collections import OrderedDict +except ImportError: # pragma: no cover +## {{{ http://code.activestate.com/recipes/576693/ (r9) +# Backport of OrderedDict() class that runs on Python 2.4, 2.5, 2.6, 2.7 and pypy. +# Passes Python2.7's test suite and incorporates all the latest updates. + try: + from thread import get_ident as _get_ident + except ImportError: + from dummy_thread import get_ident as _get_ident + + try: + from _abcoll import KeysView, ValuesView, ItemsView + except ImportError: + pass + + + class OrderedDict(dict): + 'Dictionary that remembers insertion order' + # An inherited dict maps keys to values. + # The inherited dict provides __getitem__, __len__, __contains__, and get. + # The remaining methods are order-aware. + # Big-O running times for all methods are the same as for regular dictionaries. + + # The internal self.__map dictionary maps keys to links in a doubly linked list. + # The circular doubly linked list starts and ends with a sentinel element. + # The sentinel element never gets deleted (this simplifies the algorithm). + # Each link is stored as a list of length three: [PREV, NEXT, KEY]. + + def __init__(self, *args, **kwds): + '''Initialize an ordered dictionary. Signature is the same as for + regular dictionaries, but keyword arguments are not recommended + because their insertion order is arbitrary. + + ''' + if len(args) > 1: + raise TypeError('expected at most 1 arguments, got %d' % len(args)) + try: + self.__root + except AttributeError: + self.__root = root = [] # sentinel node + root[:] = [root, root, None] + self.__map = {} + self.__update(*args, **kwds) + + def __setitem__(self, key, value, dict_setitem=dict.__setitem__): + 'od.__setitem__(i, y) <==> od[i]=y' + # Setting a new item creates a new link which goes at the end of the linked + # list, and the inherited dictionary is updated with the new key/value pair. + if key not in self: + root = self.__root + last = root[0] + last[1] = root[0] = self.__map[key] = [last, root, key] + dict_setitem(self, key, value) + + def __delitem__(self, key, dict_delitem=dict.__delitem__): + 'od.__delitem__(y) <==> del od[y]' + # Deleting an existing item uses self.__map to find the link which is + # then removed by updating the links in the predecessor and successor nodes. + dict_delitem(self, key) + link_prev, link_next, key = self.__map.pop(key) + link_prev[1] = link_next + link_next[0] = link_prev + + def __iter__(self): + 'od.__iter__() <==> iter(od)' + root = self.__root + curr = root[1] + while curr is not root: + yield curr[2] + curr = curr[1] + + def __reversed__(self): + 'od.__reversed__() <==> reversed(od)' + root = self.__root + curr = root[0] + while curr is not root: + yield curr[2] + curr = curr[0] + + def clear(self): + 'od.clear() -> None. Remove all items from od.' + try: + for node in self.__map.itervalues(): + del node[:] + root = self.__root + root[:] = [root, root, None] + self.__map.clear() + except AttributeError: + pass + dict.clear(self) + + def popitem(self, last=True): + '''od.popitem() -> (k, v), return and remove a (key, value) pair. + Pairs are returned in LIFO order if last is true or FIFO order if false. + + ''' + if not self: + raise KeyError('dictionary is empty') + root = self.__root + if last: + link = root[0] + link_prev = link[0] + link_prev[1] = root + root[0] = link_prev + else: + link = root[1] + link_next = link[1] + root[1] = link_next + link_next[0] = root + key = link[2] + del self.__map[key] + value = dict.pop(self, key) + return key, value + + # -- the following methods do not depend on the internal structure -- + + def keys(self): + 'od.keys() -> list of keys in od' + return list(self) + + def values(self): + 'od.values() -> list of values in od' + return [self[key] for key in self] + + def items(self): + 'od.items() -> list of (key, value) pairs in od' + return [(key, self[key]) for key in self] + + def iterkeys(self): + 'od.iterkeys() -> an iterator over the keys in od' + return iter(self) + + def itervalues(self): + 'od.itervalues -> an iterator over the values in od' + for k in self: + yield self[k] + + def iteritems(self): + 'od.iteritems -> an iterator over the (key, value) items in od' + for k in self: + yield (k, self[k]) + + def update(*args, **kwds): + '''od.update(E, **F) -> None. Update od from dict/iterable E and F. + + If E is a dict instance, does: for k in E: od[k] = E[k] + If E has a .keys() method, does: for k in E.keys(): od[k] = E[k] + Or if E is an iterable of items, does: for k, v in E: od[k] = v + In either case, this is followed by: for k, v in F.items(): od[k] = v + + ''' + if len(args) > 2: + raise TypeError('update() takes at most 2 positional ' + 'arguments (%d given)' % (len(args),)) + elif not args: + raise TypeError('update() takes at least 1 argument (0 given)') + self = args[0] + # Make progressively weaker assumptions about "other" + other = () + if len(args) == 2: + other = args[1] + if isinstance(other, dict): + for key in other: + self[key] = other[key] + elif hasattr(other, 'keys'): + for key in other.keys(): + self[key] = other[key] + else: + for key, value in other: + self[key] = value + for key, value in kwds.items(): + self[key] = value + + __update = update # let subclasses override update without breaking __init__ + + __marker = object() + + def pop(self, key, default=__marker): + '''od.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. + + ''' + if key in self: + result = self[key] + del self[key] + return result + if default is self.__marker: + raise KeyError(key) + return default + + def setdefault(self, key, default=None): + 'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od' + if key in self: + return self[key] + self[key] = default + return default + + def __repr__(self, _repr_running=None): + 'od.__repr__() <==> repr(od)' + if not _repr_running: _repr_running = {} + call_key = id(self), _get_ident() + if call_key in _repr_running: + return '...' + _repr_running[call_key] = 1 + try: + if not self: + return '%s()' % (self.__class__.__name__,) + return '%s(%r)' % (self.__class__.__name__, self.items()) + finally: + del _repr_running[call_key] + + def __reduce__(self): + 'Return state information for pickling' + items = [[k, self[k]] for k in self] + inst_dict = vars(self).copy() + for k in vars(OrderedDict()): + inst_dict.pop(k, None) + if inst_dict: + return (self.__class__, (items,), inst_dict) + return self.__class__, (items,) + + def copy(self): + 'od.copy() -> a shallow copy of od' + return self.__class__(self) + + @classmethod + def fromkeys(cls, iterable, value=None): + '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S + and values equal to v (which defaults to None). + + ''' + d = cls() + for key in iterable: + d[key] = value + return d + + def __eq__(self, other): + '''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive + while comparison to a regular mapping is order-insensitive. + + ''' + if isinstance(other, OrderedDict): + return len(self)==len(other) and self.items() == other.items() + return dict.__eq__(self, other) + + def __ne__(self, other): + return not self == other + + # -- the following methods are only used in Python 2.7 -- + + def viewkeys(self): + "od.viewkeys() -> a set-like object providing a view on od's keys" + return KeysView(self) + + def viewvalues(self): + "od.viewvalues() -> an object providing a view on od's values" + return ValuesView(self) + + def viewitems(self): + "od.viewitems() -> a set-like object providing a view on od's items" + return ItemsView(self) + +try: + from logging.config import BaseConfigurator, valid_ident +except ImportError: # pragma: no cover + IDENTIFIER = re.compile('^[a-z_][a-z0-9_]*$', re.I) + + + def valid_ident(s): + m = IDENTIFIER.match(s) + if not m: + raise ValueError('Not a valid Python identifier: %r' % s) + return True + + + # The ConvertingXXX classes are wrappers around standard Python containers, + # and they serve to convert any suitable values in the container. The + # conversion converts base dicts, lists and tuples to their wrapped + # equivalents, whereas strings which match a conversion format are converted + # appropriately. + # + # Each wrapper should have a configurator attribute holding the actual + # configurator to use for conversion. + + class ConvertingDict(dict): + """A converting dictionary wrapper.""" + + def __getitem__(self, key): + value = dict.__getitem__(self, key) + result = self.configurator.convert(value) + #If the converted value is different, save for next time + if value is not result: + self[key] = result + if type(result) in (ConvertingDict, ConvertingList, + ConvertingTuple): + result.parent = self + result.key = key + return result + + def get(self, key, default=None): + value = dict.get(self, key, default) + result = self.configurator.convert(value) + #If the converted value is different, save for next time + if value is not result: + self[key] = result + if type(result) in (ConvertingDict, ConvertingList, + ConvertingTuple): + result.parent = self + result.key = key + return result + + def pop(self, key, default=None): + value = dict.pop(self, key, default) + result = self.configurator.convert(value) + if value is not result: + if type(result) in (ConvertingDict, ConvertingList, + ConvertingTuple): + result.parent = self + result.key = key + return result + + class ConvertingList(list): + """A converting list wrapper.""" + def __getitem__(self, key): + value = list.__getitem__(self, key) + result = self.configurator.convert(value) + #If the converted value is different, save for next time + if value is not result: + self[key] = result + if type(result) in (ConvertingDict, ConvertingList, + ConvertingTuple): + result.parent = self + result.key = key + return result + + def pop(self, idx=-1): + value = list.pop(self, idx) + result = self.configurator.convert(value) + if value is not result: + if type(result) in (ConvertingDict, ConvertingList, + ConvertingTuple): + result.parent = self + return result + + class ConvertingTuple(tuple): + """A converting tuple wrapper.""" + def __getitem__(self, key): + value = tuple.__getitem__(self, key) + result = self.configurator.convert(value) + if value is not result: + if type(result) in (ConvertingDict, ConvertingList, + ConvertingTuple): + result.parent = self + result.key = key + return result + + class BaseConfigurator(object): + """ + The configurator base class which defines some useful defaults. + """ + + CONVERT_PATTERN = re.compile(r'^(?P[a-z]+)://(?P.*)$') + + WORD_PATTERN = re.compile(r'^\s*(\w+)\s*') + DOT_PATTERN = re.compile(r'^\.\s*(\w+)\s*') + INDEX_PATTERN = re.compile(r'^\[\s*(\w+)\s*\]\s*') + DIGIT_PATTERN = re.compile(r'^\d+$') + + value_converters = { + 'ext' : 'ext_convert', + 'cfg' : 'cfg_convert', + } + + # We might want to use a different one, e.g. importlib + importer = staticmethod(__import__) + + def __init__(self, config): + self.config = ConvertingDict(config) + self.config.configurator = self + + def resolve(self, s): + """ + Resolve strings to objects using standard import and attribute + syntax. + """ + name = s.split('.') + used = name.pop(0) + try: + found = self.importer(used) + for frag in name: + used += '.' + frag + try: + found = getattr(found, frag) + except AttributeError: + self.importer(used) + found = getattr(found, frag) + return found + except ImportError: + e, tb = sys.exc_info()[1:] + v = ValueError('Cannot resolve %r: %s' % (s, e)) + v.__cause__, v.__traceback__ = e, tb + raise v + + def ext_convert(self, value): + """Default converter for the ext:// protocol.""" + return self.resolve(value) + + def cfg_convert(self, value): + """Default converter for the cfg:// protocol.""" + rest = value + m = self.WORD_PATTERN.match(rest) + if m is None: + raise ValueError("Unable to convert %r" % value) + else: + rest = rest[m.end():] + d = self.config[m.groups()[0]] + #print d, rest + while rest: + m = self.DOT_PATTERN.match(rest) + if m: + d = d[m.groups()[0]] + else: + m = self.INDEX_PATTERN.match(rest) + if m: + idx = m.groups()[0] + if not self.DIGIT_PATTERN.match(idx): + d = d[idx] + else: + try: + n = int(idx) # try as number first (most likely) + d = d[n] + except TypeError: + d = d[idx] + if m: + rest = rest[m.end():] + else: + raise ValueError('Unable to convert ' + '%r at %r' % (value, rest)) + #rest should be empty + return d + + def convert(self, value): + """ + Convert values to an appropriate type. dicts, lists and tuples are + replaced by their converting alternatives. Strings are checked to + see if they have a conversion format and are converted if they do. + """ + if not isinstance(value, ConvertingDict) and isinstance(value, dict): + value = ConvertingDict(value) + value.configurator = self + elif not isinstance(value, ConvertingList) and isinstance(value, list): + value = ConvertingList(value) + value.configurator = self + elif not isinstance(value, ConvertingTuple) and\ + isinstance(value, tuple): + value = ConvertingTuple(value) + value.configurator = self + elif isinstance(value, string_types): + m = self.CONVERT_PATTERN.match(value) + if m: + d = m.groupdict() + prefix = d['prefix'] + converter = self.value_converters.get(prefix, None) + if converter: + suffix = d['suffix'] + converter = getattr(self, converter) + value = converter(suffix) + return value + + def configure_custom(self, config): + """Configure an object with a user-supplied factory.""" + c = config.pop('()') + if not callable(c): + c = self.resolve(c) + props = config.pop('.', None) + # Check for valid identifiers + kwargs = dict([(k, config[k]) for k in config if valid_ident(k)]) + result = c(**kwargs) + if props: + for name, value in props.items(): + setattr(result, name, value) + return result + + def as_tuple(self, value): + """Utility function which converts lists to tuples.""" + if isinstance(value, list): + value = tuple(value) + return value diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/database.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/database.py new file mode 100644 index 0000000000000000000000000000000000000000..b13cdac92b230b0048bf7705dc92e15cefc58c05 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/database.py @@ -0,0 +1,1339 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2017 The Python Software Foundation. +# See LICENSE.txt and CONTRIBUTORS.txt. +# +"""PEP 376 implementation.""" + +from __future__ import unicode_literals + +import base64 +import codecs +import contextlib +import hashlib +import logging +import os +import posixpath +import sys +import zipimport + +from . import DistlibException, resources +from .compat import StringIO +from .version import get_scheme, UnsupportedVersionError +from .metadata import (Metadata, METADATA_FILENAME, WHEEL_METADATA_FILENAME, + LEGACY_METADATA_FILENAME) +from .util import (parse_requirement, cached_property, parse_name_and_version, + read_exports, write_exports, CSVReader, CSVWriter) + + +__all__ = ['Distribution', 'BaseInstalledDistribution', + 'InstalledDistribution', 'EggInfoDistribution', + 'DistributionPath'] + + +logger = logging.getLogger(__name__) + +EXPORTS_FILENAME = 'pydist-exports.json' +COMMANDS_FILENAME = 'pydist-commands.json' + +DIST_FILES = ('INSTALLER', METADATA_FILENAME, 'RECORD', 'REQUESTED', + 'RESOURCES', EXPORTS_FILENAME, 'SHARED') + +DISTINFO_EXT = '.dist-info' + + +class _Cache(object): + """ + A simple cache mapping names and .dist-info paths to distributions + """ + def __init__(self): + """ + Initialise an instance. There is normally one for each DistributionPath. + """ + self.name = {} + self.path = {} + self.generated = False + + def clear(self): + """ + Clear the cache, setting it to its initial state. + """ + self.name.clear() + self.path.clear() + self.generated = False + + def add(self, dist): + """ + Add a distribution to the cache. + :param dist: The distribution to add. + """ + if dist.path not in self.path: + self.path[dist.path] = dist + self.name.setdefault(dist.key, []).append(dist) + + +class DistributionPath(object): + """ + Represents a set of distributions installed on a path (typically sys.path). + """ + def __init__(self, path=None, include_egg=False): + """ + Create an instance from a path, optionally including legacy (distutils/ + setuptools/distribute) distributions. + :param path: The path to use, as a list of directories. If not specified, + sys.path is used. + :param include_egg: If True, this instance will look for and return legacy + distributions as well as those based on PEP 376. + """ + if path is None: + path = sys.path + self.path = path + self._include_dist = True + self._include_egg = include_egg + + self._cache = _Cache() + self._cache_egg = _Cache() + self._cache_enabled = True + self._scheme = get_scheme('default') + + def _get_cache_enabled(self): + return self._cache_enabled + + def _set_cache_enabled(self, value): + self._cache_enabled = value + + cache_enabled = property(_get_cache_enabled, _set_cache_enabled) + + def clear_cache(self): + """ + Clears the internal cache. + """ + self._cache.clear() + self._cache_egg.clear() + + + def _yield_distributions(self): + """ + Yield .dist-info and/or .egg(-info) distributions. + """ + # We need to check if we've seen some resources already, because on + # some Linux systems (e.g. some Debian/Ubuntu variants) there are + # symlinks which alias other files in the environment. + seen = set() + for path in self.path: + finder = resources.finder_for_path(path) + if finder is None: + continue + r = finder.find('') + if not r or not r.is_container: + continue + rset = sorted(r.resources) + for entry in rset: + r = finder.find(entry) + if not r or r.path in seen: + continue + if self._include_dist and entry.endswith(DISTINFO_EXT): + possible_filenames = [METADATA_FILENAME, + WHEEL_METADATA_FILENAME, + LEGACY_METADATA_FILENAME] + for metadata_filename in possible_filenames: + metadata_path = posixpath.join(entry, metadata_filename) + pydist = finder.find(metadata_path) + if pydist: + break + else: + continue + + with contextlib.closing(pydist.as_stream()) as stream: + metadata = Metadata(fileobj=stream, scheme='legacy') + logger.debug('Found %s', r.path) + seen.add(r.path) + yield new_dist_class(r.path, metadata=metadata, + env=self) + elif self._include_egg and entry.endswith(('.egg-info', + '.egg')): + logger.debug('Found %s', r.path) + seen.add(r.path) + yield old_dist_class(r.path, self) + + def _generate_cache(self): + """ + Scan the path for distributions and populate the cache with + those that are found. + """ + gen_dist = not self._cache.generated + gen_egg = self._include_egg and not self._cache_egg.generated + if gen_dist or gen_egg: + for dist in self._yield_distributions(): + if isinstance(dist, InstalledDistribution): + self._cache.add(dist) + else: + self._cache_egg.add(dist) + + if gen_dist: + self._cache.generated = True + if gen_egg: + self._cache_egg.generated = True + + @classmethod + def distinfo_dirname(cls, name, version): + """ + The *name* and *version* parameters are converted into their + filename-escaped form, i.e. any ``'-'`` characters are replaced + with ``'_'`` other than the one in ``'dist-info'`` and the one + separating the name from the version number. + + :parameter name: is converted to a standard distribution name by replacing + any runs of non- alphanumeric characters with a single + ``'-'``. + :type name: string + :parameter version: is converted to a standard version string. Spaces + become dots, and all other non-alphanumeric characters + (except dots) become dashes, with runs of multiple + dashes condensed to a single dash. + :type version: string + :returns: directory name + :rtype: string""" + name = name.replace('-', '_') + return '-'.join([name, version]) + DISTINFO_EXT + + def get_distributions(self): + """ + Provides an iterator that looks for distributions and returns + :class:`InstalledDistribution` or + :class:`EggInfoDistribution` instances for each one of them. + + :rtype: iterator of :class:`InstalledDistribution` and + :class:`EggInfoDistribution` instances + """ + if not self._cache_enabled: + for dist in self._yield_distributions(): + yield dist + else: + self._generate_cache() + + for dist in self._cache.path.values(): + yield dist + + if self._include_egg: + for dist in self._cache_egg.path.values(): + yield dist + + def get_distribution(self, name): + """ + Looks for a named distribution on the path. + + This function only returns the first result found, as no more than one + value is expected. If nothing is found, ``None`` is returned. + + :rtype: :class:`InstalledDistribution`, :class:`EggInfoDistribution` + or ``None`` + """ + result = None + name = name.lower() + if not self._cache_enabled: + for dist in self._yield_distributions(): + if dist.key == name: + result = dist + break + else: + self._generate_cache() + + if name in self._cache.name: + result = self._cache.name[name][0] + elif self._include_egg and name in self._cache_egg.name: + result = self._cache_egg.name[name][0] + return result + + def provides_distribution(self, name, version=None): + """ + Iterates over all distributions to find which distributions provide *name*. + If a *version* is provided, it will be used to filter the results. + + This function only returns the first result found, since no more than + one values are expected. If the directory is not found, returns ``None``. + + :parameter version: a version specifier that indicates the version + required, conforming to the format in ``PEP-345`` + + :type name: string + :type version: string + """ + matcher = None + if version is not None: + try: + matcher = self._scheme.matcher('%s (%s)' % (name, version)) + except ValueError: + raise DistlibException('invalid name or version: %r, %r' % + (name, version)) + + for dist in self.get_distributions(): + # We hit a problem on Travis where enum34 was installed and doesn't + # have a provides attribute ... + if not hasattr(dist, 'provides'): + logger.debug('No "provides": %s', dist) + else: + provided = dist.provides + + for p in provided: + p_name, p_ver = parse_name_and_version(p) + if matcher is None: + if p_name == name: + yield dist + break + else: + if p_name == name and matcher.match(p_ver): + yield dist + break + + def get_file_path(self, name, relative_path): + """ + Return the path to a resource file. + """ + dist = self.get_distribution(name) + if dist is None: + raise LookupError('no distribution named %r found' % name) + return dist.get_resource_path(relative_path) + + def get_exported_entries(self, category, name=None): + """ + Return all of the exported entries in a particular category. + + :param category: The category to search for entries. + :param name: If specified, only entries with that name are returned. + """ + for dist in self.get_distributions(): + r = dist.exports + if category in r: + d = r[category] + if name is not None: + if name in d: + yield d[name] + else: + for v in d.values(): + yield v + + +class Distribution(object): + """ + A base class for distributions, whether installed or from indexes. + Either way, it must have some metadata, so that's all that's needed + for construction. + """ + + build_time_dependency = False + """ + Set to True if it's known to be only a build-time dependency (i.e. + not needed after installation). + """ + + requested = False + """A boolean that indicates whether the ``REQUESTED`` metadata file is + present (in other words, whether the package was installed by user + request or it was installed as a dependency).""" + + def __init__(self, metadata): + """ + Initialise an instance. + :param metadata: The instance of :class:`Metadata` describing this + distribution. + """ + self.metadata = metadata + self.name = metadata.name + self.key = self.name.lower() # for case-insensitive comparisons + self.version = metadata.version + self.locator = None + self.digest = None + self.extras = None # additional features requested + self.context = None # environment marker overrides + self.download_urls = set() + self.digests = {} + + @property + def source_url(self): + """ + The source archive download URL for this distribution. + """ + return self.metadata.source_url + + download_url = source_url # Backward compatibility + + @property + def name_and_version(self): + """ + A utility property which displays the name and version in parentheses. + """ + return '%s (%s)' % (self.name, self.version) + + @property + def provides(self): + """ + A set of distribution names and versions provided by this distribution. + :return: A set of "name (version)" strings. + """ + plist = self.metadata.provides + s = '%s (%s)' % (self.name, self.version) + if s not in plist: + plist.append(s) + return plist + + def _get_requirements(self, req_attr): + md = self.metadata + logger.debug('Getting requirements from metadata %r', md.todict()) + reqts = getattr(md, req_attr) + return set(md.get_requirements(reqts, extras=self.extras, + env=self.context)) + + @property + def run_requires(self): + return self._get_requirements('run_requires') + + @property + def meta_requires(self): + return self._get_requirements('meta_requires') + + @property + def build_requires(self): + return self._get_requirements('build_requires') + + @property + def test_requires(self): + return self._get_requirements('test_requires') + + @property + def dev_requires(self): + return self._get_requirements('dev_requires') + + def matches_requirement(self, req): + """ + Say if this instance matches (fulfills) a requirement. + :param req: The requirement to match. + :rtype req: str + :return: True if it matches, else False. + """ + # Requirement may contain extras - parse to lose those + # from what's passed to the matcher + r = parse_requirement(req) + scheme = get_scheme(self.metadata.scheme) + try: + matcher = scheme.matcher(r.requirement) + except UnsupportedVersionError: + # XXX compat-mode if cannot read the version + logger.warning('could not read version %r - using name only', + req) + name = req.split()[0] + matcher = scheme.matcher(name) + + name = matcher.key # case-insensitive + + result = False + for p in self.provides: + p_name, p_ver = parse_name_and_version(p) + if p_name != name: + continue + try: + result = matcher.match(p_ver) + break + except UnsupportedVersionError: + pass + return result + + def __repr__(self): + """ + Return a textual representation of this instance, + """ + if self.source_url: + suffix = ' [%s]' % self.source_url + else: + suffix = '' + return '' % (self.name, self.version, suffix) + + def __eq__(self, other): + """ + See if this distribution is the same as another. + :param other: The distribution to compare with. To be equal to one + another. distributions must have the same type, name, + version and source_url. + :return: True if it is the same, else False. + """ + if type(other) is not type(self): + result = False + else: + result = (self.name == other.name and + self.version == other.version and + self.source_url == other.source_url) + return result + + def __hash__(self): + """ + Compute hash in a way which matches the equality test. + """ + return hash(self.name) + hash(self.version) + hash(self.source_url) + + +class BaseInstalledDistribution(Distribution): + """ + This is the base class for installed distributions (whether PEP 376 or + legacy). + """ + + hasher = None + + def __init__(self, metadata, path, env=None): + """ + Initialise an instance. + :param metadata: An instance of :class:`Metadata` which describes the + distribution. This will normally have been initialised + from a metadata file in the ``path``. + :param path: The path of the ``.dist-info`` or ``.egg-info`` + directory for the distribution. + :param env: This is normally the :class:`DistributionPath` + instance where this distribution was found. + """ + super(BaseInstalledDistribution, self).__init__(metadata) + self.path = path + self.dist_path = env + + def get_hash(self, data, hasher=None): + """ + Get the hash of some data, using a particular hash algorithm, if + specified. + + :param data: The data to be hashed. + :type data: bytes + :param hasher: The name of a hash implementation, supported by hashlib, + or ``None``. Examples of valid values are ``'sha1'``, + ``'sha224'``, ``'sha384'``, '``sha256'``, ``'md5'`` and + ``'sha512'``. If no hasher is specified, the ``hasher`` + attribute of the :class:`InstalledDistribution` instance + is used. If the hasher is determined to be ``None``, MD5 + is used as the hashing algorithm. + :returns: The hash of the data. If a hasher was explicitly specified, + the returned hash will be prefixed with the specified hasher + followed by '='. + :rtype: str + """ + if hasher is None: + hasher = self.hasher + if hasher is None: + hasher = hashlib.md5 + prefix = '' + else: + hasher = getattr(hashlib, hasher) + prefix = '%s=' % self.hasher + digest = hasher(data).digest() + digest = base64.urlsafe_b64encode(digest).rstrip(b'=').decode('ascii') + return '%s%s' % (prefix, digest) + + +class InstalledDistribution(BaseInstalledDistribution): + """ + Created with the *path* of the ``.dist-info`` directory provided to the + constructor. It reads the metadata contained in ``pydist.json`` when it is + instantiated., or uses a passed in Metadata instance (useful for when + dry-run mode is being used). + """ + + hasher = 'sha256' + + def __init__(self, path, metadata=None, env=None): + self.modules = [] + self.finder = finder = resources.finder_for_path(path) + if finder is None: + raise ValueError('finder unavailable for %s' % path) + if env and env._cache_enabled and path in env._cache.path: + metadata = env._cache.path[path].metadata + elif metadata is None: + r = finder.find(METADATA_FILENAME) + # Temporary - for Wheel 0.23 support + if r is None: + r = finder.find(WHEEL_METADATA_FILENAME) + # Temporary - for legacy support + if r is None: + r = finder.find('METADATA') + if r is None: + raise ValueError('no %s found in %s' % (METADATA_FILENAME, + path)) + with contextlib.closing(r.as_stream()) as stream: + metadata = Metadata(fileobj=stream, scheme='legacy') + + super(InstalledDistribution, self).__init__(metadata, path, env) + + if env and env._cache_enabled: + env._cache.add(self) + + r = finder.find('REQUESTED') + self.requested = r is not None + p = os.path.join(path, 'top_level.txt') + if os.path.exists(p): + with open(p, 'rb') as f: + data = f.read() + self.modules = data.splitlines() + + def __repr__(self): + return '' % ( + self.name, self.version, self.path) + + def __str__(self): + return "%s %s" % (self.name, self.version) + + def _get_records(self): + """ + Get the list of installed files for the distribution + :return: A list of tuples of path, hash and size. Note that hash and + size might be ``None`` for some entries. The path is exactly + as stored in the file (which is as in PEP 376). + """ + results = [] + r = self.get_distinfo_resource('RECORD') + with contextlib.closing(r.as_stream()) as stream: + with CSVReader(stream=stream) as record_reader: + # Base location is parent dir of .dist-info dir + #base_location = os.path.dirname(self.path) + #base_location = os.path.abspath(base_location) + for row in record_reader: + missing = [None for i in range(len(row), 3)] + path, checksum, size = row + missing + #if not os.path.isabs(path): + # path = path.replace('/', os.sep) + # path = os.path.join(base_location, path) + results.append((path, checksum, size)) + return results + + @cached_property + def exports(self): + """ + Return the information exported by this distribution. + :return: A dictionary of exports, mapping an export category to a dict + of :class:`ExportEntry` instances describing the individual + export entries, and keyed by name. + """ + result = {} + r = self.get_distinfo_resource(EXPORTS_FILENAME) + if r: + result = self.read_exports() + return result + + def read_exports(self): + """ + Read exports data from a file in .ini format. + + :return: A dictionary of exports, mapping an export category to a list + of :class:`ExportEntry` instances describing the individual + export entries. + """ + result = {} + r = self.get_distinfo_resource(EXPORTS_FILENAME) + if r: + with contextlib.closing(r.as_stream()) as stream: + result = read_exports(stream) + return result + + def write_exports(self, exports): + """ + Write a dictionary of exports to a file in .ini format. + :param exports: A dictionary of exports, mapping an export category to + a list of :class:`ExportEntry` instances describing the + individual export entries. + """ + rf = self.get_distinfo_file(EXPORTS_FILENAME) + with open(rf, 'w') as f: + write_exports(exports, f) + + def get_resource_path(self, relative_path): + """ + NOTE: This API may change in the future. + + Return the absolute path to a resource file with the given relative + path. + + :param relative_path: The path, relative to .dist-info, of the resource + of interest. + :return: The absolute path where the resource is to be found. + """ + r = self.get_distinfo_resource('RESOURCES') + with contextlib.closing(r.as_stream()) as stream: + with CSVReader(stream=stream) as resources_reader: + for relative, destination in resources_reader: + if relative == relative_path: + return destination + raise KeyError('no resource file with relative path %r ' + 'is installed' % relative_path) + + def list_installed_files(self): + """ + Iterates over the ``RECORD`` entries and returns a tuple + ``(path, hash, size)`` for each line. + + :returns: iterator of (path, hash, size) + """ + for result in self._get_records(): + yield result + + def write_installed_files(self, paths, prefix, dry_run=False): + """ + Writes the ``RECORD`` file, using the ``paths`` iterable passed in. Any + existing ``RECORD`` file is silently overwritten. + + prefix is used to determine when to write absolute paths. + """ + prefix = os.path.join(prefix, '') + base = os.path.dirname(self.path) + base_under_prefix = base.startswith(prefix) + base = os.path.join(base, '') + record_path = self.get_distinfo_file('RECORD') + logger.info('creating %s', record_path) + if dry_run: + return None + with CSVWriter(record_path) as writer: + for path in paths: + if os.path.isdir(path) or path.endswith(('.pyc', '.pyo')): + # do not put size and hash, as in PEP-376 + hash_value = size = '' + else: + size = '%d' % os.path.getsize(path) + with open(path, 'rb') as fp: + hash_value = self.get_hash(fp.read()) + if path.startswith(base) or (base_under_prefix and + path.startswith(prefix)): + path = os.path.relpath(path, base) + writer.writerow((path, hash_value, size)) + + # add the RECORD file itself + if record_path.startswith(base): + record_path = os.path.relpath(record_path, base) + writer.writerow((record_path, '', '')) + return record_path + + def check_installed_files(self): + """ + Checks that the hashes and sizes of the files in ``RECORD`` are + matched by the files themselves. Returns a (possibly empty) list of + mismatches. Each entry in the mismatch list will be a tuple consisting + of the path, 'exists', 'size' or 'hash' according to what didn't match + (existence is checked first, then size, then hash), the expected + value and the actual value. + """ + mismatches = [] + base = os.path.dirname(self.path) + record_path = self.get_distinfo_file('RECORD') + for path, hash_value, size in self.list_installed_files(): + if not os.path.isabs(path): + path = os.path.join(base, path) + if path == record_path: + continue + if not os.path.exists(path): + mismatches.append((path, 'exists', True, False)) + elif os.path.isfile(path): + actual_size = str(os.path.getsize(path)) + if size and actual_size != size: + mismatches.append((path, 'size', size, actual_size)) + elif hash_value: + if '=' in hash_value: + hasher = hash_value.split('=', 1)[0] + else: + hasher = None + + with open(path, 'rb') as f: + actual_hash = self.get_hash(f.read(), hasher) + if actual_hash != hash_value: + mismatches.append((path, 'hash', hash_value, actual_hash)) + return mismatches + + @cached_property + def shared_locations(self): + """ + A dictionary of shared locations whose keys are in the set 'prefix', + 'purelib', 'platlib', 'scripts', 'headers', 'data' and 'namespace'. + The corresponding value is the absolute path of that category for + this distribution, and takes into account any paths selected by the + user at installation time (e.g. via command-line arguments). In the + case of the 'namespace' key, this would be a list of absolute paths + for the roots of namespace packages in this distribution. + + The first time this property is accessed, the relevant information is + read from the SHARED file in the .dist-info directory. + """ + result = {} + shared_path = os.path.join(self.path, 'SHARED') + if os.path.isfile(shared_path): + with codecs.open(shared_path, 'r', encoding='utf-8') as f: + lines = f.read().splitlines() + for line in lines: + key, value = line.split('=', 1) + if key == 'namespace': + result.setdefault(key, []).append(value) + else: + result[key] = value + return result + + def write_shared_locations(self, paths, dry_run=False): + """ + Write shared location information to the SHARED file in .dist-info. + :param paths: A dictionary as described in the documentation for + :meth:`shared_locations`. + :param dry_run: If True, the action is logged but no file is actually + written. + :return: The path of the file written to. + """ + shared_path = os.path.join(self.path, 'SHARED') + logger.info('creating %s', shared_path) + if dry_run: + return None + lines = [] + for key in ('prefix', 'lib', 'headers', 'scripts', 'data'): + path = paths[key] + if os.path.isdir(paths[key]): + lines.append('%s=%s' % (key, path)) + for ns in paths.get('namespace', ()): + lines.append('namespace=%s' % ns) + + with codecs.open(shared_path, 'w', encoding='utf-8') as f: + f.write('\n'.join(lines)) + return shared_path + + def get_distinfo_resource(self, path): + if path not in DIST_FILES: + raise DistlibException('invalid path for a dist-info file: ' + '%r at %r' % (path, self.path)) + finder = resources.finder_for_path(self.path) + if finder is None: + raise DistlibException('Unable to get a finder for %s' % self.path) + return finder.find(path) + + def get_distinfo_file(self, path): + """ + Returns a path located under the ``.dist-info`` directory. Returns a + string representing the path. + + :parameter path: a ``'/'``-separated path relative to the + ``.dist-info`` directory or an absolute path; + If *path* is an absolute path and doesn't start + with the ``.dist-info`` directory path, + a :class:`DistlibException` is raised + :type path: str + :rtype: str + """ + # Check if it is an absolute path # XXX use relpath, add tests + if path.find(os.sep) >= 0: + # it's an absolute path? + distinfo_dirname, path = path.split(os.sep)[-2:] + if distinfo_dirname != self.path.split(os.sep)[-1]: + raise DistlibException( + 'dist-info file %r does not belong to the %r %s ' + 'distribution' % (path, self.name, self.version)) + + # The file must be relative + if path not in DIST_FILES: + raise DistlibException('invalid path for a dist-info file: ' + '%r at %r' % (path, self.path)) + + return os.path.join(self.path, path) + + def list_distinfo_files(self): + """ + Iterates over the ``RECORD`` entries and returns paths for each line if + the path is pointing to a file located in the ``.dist-info`` directory + or one of its subdirectories. + + :returns: iterator of paths + """ + base = os.path.dirname(self.path) + for path, checksum, size in self._get_records(): + # XXX add separator or use real relpath algo + if not os.path.isabs(path): + path = os.path.join(base, path) + if path.startswith(self.path): + yield path + + def __eq__(self, other): + return (isinstance(other, InstalledDistribution) and + self.path == other.path) + + # See http://docs.python.org/reference/datamodel#object.__hash__ + __hash__ = object.__hash__ + + +class EggInfoDistribution(BaseInstalledDistribution): + """Created with the *path* of the ``.egg-info`` directory or file provided + to the constructor. It reads the metadata contained in the file itself, or + if the given path happens to be a directory, the metadata is read from the + file ``PKG-INFO`` under that directory.""" + + requested = True # as we have no way of knowing, assume it was + shared_locations = {} + + def __init__(self, path, env=None): + def set_name_and_version(s, n, v): + s.name = n + s.key = n.lower() # for case-insensitive comparisons + s.version = v + + self.path = path + self.dist_path = env + if env and env._cache_enabled and path in env._cache_egg.path: + metadata = env._cache_egg.path[path].metadata + set_name_and_version(self, metadata.name, metadata.version) + else: + metadata = self._get_metadata(path) + + # Need to be set before caching + set_name_and_version(self, metadata.name, metadata.version) + + if env and env._cache_enabled: + env._cache_egg.add(self) + super(EggInfoDistribution, self).__init__(metadata, path, env) + + def _get_metadata(self, path): + requires = None + + def parse_requires_data(data): + """Create a list of dependencies from a requires.txt file. + + *data*: the contents of a setuptools-produced requires.txt file. + """ + reqs = [] + lines = data.splitlines() + for line in lines: + line = line.strip() + if line.startswith('['): + logger.warning('Unexpected line: quitting requirement scan: %r', + line) + break + r = parse_requirement(line) + if not r: + logger.warning('Not recognised as a requirement: %r', line) + continue + if r.extras: + logger.warning('extra requirements in requires.txt are ' + 'not supported') + if not r.constraints: + reqs.append(r.name) + else: + cons = ', '.join('%s%s' % c for c in r.constraints) + reqs.append('%s (%s)' % (r.name, cons)) + return reqs + + def parse_requires_path(req_path): + """Create a list of dependencies from a requires.txt file. + + *req_path*: the path to a setuptools-produced requires.txt file. + """ + + reqs = [] + try: + with codecs.open(req_path, 'r', 'utf-8') as fp: + reqs = parse_requires_data(fp.read()) + except IOError: + pass + return reqs + + tl_path = tl_data = None + if path.endswith('.egg'): + if os.path.isdir(path): + p = os.path.join(path, 'EGG-INFO') + meta_path = os.path.join(p, 'PKG-INFO') + metadata = Metadata(path=meta_path, scheme='legacy') + req_path = os.path.join(p, 'requires.txt') + tl_path = os.path.join(p, 'top_level.txt') + requires = parse_requires_path(req_path) + else: + # FIXME handle the case where zipfile is not available + zipf = zipimport.zipimporter(path) + fileobj = StringIO( + zipf.get_data('EGG-INFO/PKG-INFO').decode('utf8')) + metadata = Metadata(fileobj=fileobj, scheme='legacy') + try: + data = zipf.get_data('EGG-INFO/requires.txt') + tl_data = zipf.get_data('EGG-INFO/top_level.txt').decode('utf-8') + requires = parse_requires_data(data.decode('utf-8')) + except IOError: + requires = None + elif path.endswith('.egg-info'): + if os.path.isdir(path): + req_path = os.path.join(path, 'requires.txt') + requires = parse_requires_path(req_path) + path = os.path.join(path, 'PKG-INFO') + tl_path = os.path.join(path, 'top_level.txt') + metadata = Metadata(path=path, scheme='legacy') + else: + raise DistlibException('path must end with .egg-info or .egg, ' + 'got %r' % path) + + if requires: + metadata.add_requirements(requires) + # look for top-level modules in top_level.txt, if present + if tl_data is None: + if tl_path is not None and os.path.exists(tl_path): + with open(tl_path, 'rb') as f: + tl_data = f.read().decode('utf-8') + if not tl_data: + tl_data = [] + else: + tl_data = tl_data.splitlines() + self.modules = tl_data + return metadata + + def __repr__(self): + return '' % ( + self.name, self.version, self.path) + + def __str__(self): + return "%s %s" % (self.name, self.version) + + def check_installed_files(self): + """ + Checks that the hashes and sizes of the files in ``RECORD`` are + matched by the files themselves. Returns a (possibly empty) list of + mismatches. Each entry in the mismatch list will be a tuple consisting + of the path, 'exists', 'size' or 'hash' according to what didn't match + (existence is checked first, then size, then hash), the expected + value and the actual value. + """ + mismatches = [] + record_path = os.path.join(self.path, 'installed-files.txt') + if os.path.exists(record_path): + for path, _, _ in self.list_installed_files(): + if path == record_path: + continue + if not os.path.exists(path): + mismatches.append((path, 'exists', True, False)) + return mismatches + + def list_installed_files(self): + """ + Iterates over the ``installed-files.txt`` entries and returns a tuple + ``(path, hash, size)`` for each line. + + :returns: a list of (path, hash, size) + """ + + def _md5(path): + f = open(path, 'rb') + try: + content = f.read() + finally: + f.close() + return hashlib.md5(content).hexdigest() + + def _size(path): + return os.stat(path).st_size + + record_path = os.path.join(self.path, 'installed-files.txt') + result = [] + if os.path.exists(record_path): + with codecs.open(record_path, 'r', encoding='utf-8') as f: + for line in f: + line = line.strip() + p = os.path.normpath(os.path.join(self.path, line)) + # "./" is present as a marker between installed files + # and installation metadata files + if not os.path.exists(p): + logger.warning('Non-existent file: %s', p) + if p.endswith(('.pyc', '.pyo')): + continue + #otherwise fall through and fail + if not os.path.isdir(p): + result.append((p, _md5(p), _size(p))) + result.append((record_path, None, None)) + return result + + def list_distinfo_files(self, absolute=False): + """ + Iterates over the ``installed-files.txt`` entries and returns paths for + each line if the path is pointing to a file located in the + ``.egg-info`` directory or one of its subdirectories. + + :parameter absolute: If *absolute* is ``True``, each returned path is + transformed into a local absolute path. Otherwise the + raw value from ``installed-files.txt`` is returned. + :type absolute: boolean + :returns: iterator of paths + """ + record_path = os.path.join(self.path, 'installed-files.txt') + if os.path.exists(record_path): + skip = True + with codecs.open(record_path, 'r', encoding='utf-8') as f: + for line in f: + line = line.strip() + if line == './': + skip = False + continue + if not skip: + p = os.path.normpath(os.path.join(self.path, line)) + if p.startswith(self.path): + if absolute: + yield p + else: + yield line + + def __eq__(self, other): + return (isinstance(other, EggInfoDistribution) and + self.path == other.path) + + # See http://docs.python.org/reference/datamodel#object.__hash__ + __hash__ = object.__hash__ + +new_dist_class = InstalledDistribution +old_dist_class = EggInfoDistribution + + +class DependencyGraph(object): + """ + Represents a dependency graph between distributions. + + The dependency relationships are stored in an ``adjacency_list`` that maps + distributions to a list of ``(other, label)`` tuples where ``other`` + is a distribution and the edge is labeled with ``label`` (i.e. the version + specifier, if such was provided). Also, for more efficient traversal, for + every distribution ``x``, a list of predecessors is kept in + ``reverse_list[x]``. An edge from distribution ``a`` to + distribution ``b`` means that ``a`` depends on ``b``. If any missing + dependencies are found, they are stored in ``missing``, which is a + dictionary that maps distributions to a list of requirements that were not + provided by any other distributions. + """ + + def __init__(self): + self.adjacency_list = {} + self.reverse_list = {} + self.missing = {} + + def add_distribution(self, distribution): + """Add the *distribution* to the graph. + + :type distribution: :class:`distutils2.database.InstalledDistribution` + or :class:`distutils2.database.EggInfoDistribution` + """ + self.adjacency_list[distribution] = [] + self.reverse_list[distribution] = [] + #self.missing[distribution] = [] + + def add_edge(self, x, y, label=None): + """Add an edge from distribution *x* to distribution *y* with the given + *label*. + + :type x: :class:`distutils2.database.InstalledDistribution` or + :class:`distutils2.database.EggInfoDistribution` + :type y: :class:`distutils2.database.InstalledDistribution` or + :class:`distutils2.database.EggInfoDistribution` + :type label: ``str`` or ``None`` + """ + self.adjacency_list[x].append((y, label)) + # multiple edges are allowed, so be careful + if x not in self.reverse_list[y]: + self.reverse_list[y].append(x) + + def add_missing(self, distribution, requirement): + """ + Add a missing *requirement* for the given *distribution*. + + :type distribution: :class:`distutils2.database.InstalledDistribution` + or :class:`distutils2.database.EggInfoDistribution` + :type requirement: ``str`` + """ + logger.debug('%s missing %r', distribution, requirement) + self.missing.setdefault(distribution, []).append(requirement) + + def _repr_dist(self, dist): + return '%s %s' % (dist.name, dist.version) + + def repr_node(self, dist, level=1): + """Prints only a subgraph""" + output = [self._repr_dist(dist)] + for other, label in self.adjacency_list[dist]: + dist = self._repr_dist(other) + if label is not None: + dist = '%s [%s]' % (dist, label) + output.append(' ' * level + str(dist)) + suboutput = self.repr_node(other, level + 1) + subs = suboutput.split('\n') + output.extend(subs[1:]) + return '\n'.join(output) + + def to_dot(self, f, skip_disconnected=True): + """Writes a DOT output for the graph to the provided file *f*. + + If *skip_disconnected* is set to ``True``, then all distributions + that are not dependent on any other distribution are skipped. + + :type f: has to support ``file``-like operations + :type skip_disconnected: ``bool`` + """ + disconnected = [] + + f.write("digraph dependencies {\n") + for dist, adjs in self.adjacency_list.items(): + if len(adjs) == 0 and not skip_disconnected: + disconnected.append(dist) + for other, label in adjs: + if not label is None: + f.write('"%s" -> "%s" [label="%s"]\n' % + (dist.name, other.name, label)) + else: + f.write('"%s" -> "%s"\n' % (dist.name, other.name)) + if not skip_disconnected and len(disconnected) > 0: + f.write('subgraph disconnected {\n') + f.write('label = "Disconnected"\n') + f.write('bgcolor = red\n') + + for dist in disconnected: + f.write('"%s"' % dist.name) + f.write('\n') + f.write('}\n') + f.write('}\n') + + def topological_sort(self): + """ + Perform a topological sort of the graph. + :return: A tuple, the first element of which is a topologically sorted + list of distributions, and the second element of which is a + list of distributions that cannot be sorted because they have + circular dependencies and so form a cycle. + """ + result = [] + # Make a shallow copy of the adjacency list + alist = {} + for k, v in self.adjacency_list.items(): + alist[k] = v[:] + while True: + # See what we can remove in this run + to_remove = [] + for k, v in list(alist.items())[:]: + if not v: + to_remove.append(k) + del alist[k] + if not to_remove: + # What's left in alist (if anything) is a cycle. + break + # Remove from the adjacency list of others + for k, v in alist.items(): + alist[k] = [(d, r) for d, r in v if d not in to_remove] + logger.debug('Moving to result: %s', + ['%s (%s)' % (d.name, d.version) for d in to_remove]) + result.extend(to_remove) + return result, list(alist.keys()) + + def __repr__(self): + """Representation of the graph""" + output = [] + for dist, adjs in self.adjacency_list.items(): + output.append(self.repr_node(dist)) + return '\n'.join(output) + + +def make_graph(dists, scheme='default'): + """Makes a dependency graph from the given distributions. + + :parameter dists: a list of distributions + :type dists: list of :class:`distutils2.database.InstalledDistribution` and + :class:`distutils2.database.EggInfoDistribution` instances + :rtype: a :class:`DependencyGraph` instance + """ + scheme = get_scheme(scheme) + graph = DependencyGraph() + provided = {} # maps names to lists of (version, dist) tuples + + # first, build the graph and find out what's provided + for dist in dists: + graph.add_distribution(dist) + + for p in dist.provides: + name, version = parse_name_and_version(p) + logger.debug('Add to provided: %s, %s, %s', name, version, dist) + provided.setdefault(name, []).append((version, dist)) + + # now make the edges + for dist in dists: + requires = (dist.run_requires | dist.meta_requires | + dist.build_requires | dist.dev_requires) + for req in requires: + try: + matcher = scheme.matcher(req) + except UnsupportedVersionError: + # XXX compat-mode if cannot read the version + logger.warning('could not read version %r - using name only', + req) + name = req.split()[0] + matcher = scheme.matcher(name) + + name = matcher.key # case-insensitive + + matched = False + if name in provided: + for version, provider in provided[name]: + try: + match = matcher.match(version) + except UnsupportedVersionError: + match = False + + if match: + graph.add_edge(dist, provider, req) + matched = True + break + if not matched: + graph.add_missing(dist, req) + return graph + + +def get_dependent_dists(dists, dist): + """Recursively generate a list of distributions from *dists* that are + dependent on *dist*. + + :param dists: a list of distributions + :param dist: a distribution, member of *dists* for which we are interested + """ + if dist not in dists: + raise DistlibException('given distribution %r is not a member ' + 'of the list' % dist.name) + graph = make_graph(dists) + + dep = [dist] # dependent distributions + todo = graph.reverse_list[dist] # list of nodes we should inspect + + while todo: + d = todo.pop() + dep.append(d) + for succ in graph.reverse_list[d]: + if succ not in dep: + todo.append(succ) + + dep.pop(0) # remove dist from dep, was there to prevent infinite loops + return dep + + +def get_required_dists(dists, dist): + """Recursively generate a list of distributions from *dists* that are + required by *dist*. + + :param dists: a list of distributions + :param dist: a distribution, member of *dists* for which we are interested + """ + if dist not in dists: + raise DistlibException('given distribution %r is not a member ' + 'of the list' % dist.name) + graph = make_graph(dists) + + req = [] # required distributions + todo = graph.adjacency_list[dist] # list of nodes we should inspect + + while todo: + d = todo.pop()[0] + req.append(d) + for pred in graph.adjacency_list[d]: + if pred not in req: + todo.append(pred) + + return req + + +def make_dist(name, version, **kwargs): + """ + A convenience method for making a dist given just a name and version. + """ + summary = kwargs.pop('summary', 'Placeholder for summary') + md = Metadata(**kwargs) + md.name = name + md.version = version + md.summary = summary or 'Placeholder for summary' + return Distribution(md) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/index.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/index.py new file mode 100644 index 0000000000000000000000000000000000000000..7a87cdcf7a19987ad0344b8c5d161027b345e212 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/index.py @@ -0,0 +1,516 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2013 Vinay Sajip. +# Licensed to the Python Software Foundation under a contributor agreement. +# See LICENSE.txt and CONTRIBUTORS.txt. +# +import hashlib +import logging +import os +import shutil +import subprocess +import tempfile +try: + from threading import Thread +except ImportError: + from dummy_threading import Thread + +from . import DistlibException +from .compat import (HTTPBasicAuthHandler, Request, HTTPPasswordMgr, + urlparse, build_opener, string_types) +from .util import cached_property, zip_dir, ServerProxy + +logger = logging.getLogger(__name__) + +DEFAULT_INDEX = 'https://pypi.org/pypi' +DEFAULT_REALM = 'pypi' + +class PackageIndex(object): + """ + This class represents a package index compatible with PyPI, the Python + Package Index. + """ + + boundary = b'----------ThIs_Is_tHe_distlib_index_bouNdaRY_$' + + def __init__(self, url=None): + """ + Initialise an instance. + + :param url: The URL of the index. If not specified, the URL for PyPI is + used. + """ + self.url = url or DEFAULT_INDEX + self.read_configuration() + scheme, netloc, path, params, query, frag = urlparse(self.url) + if params or query or frag or scheme not in ('http', 'https'): + raise DistlibException('invalid repository: %s' % self.url) + self.password_handler = None + self.ssl_verifier = None + self.gpg = None + self.gpg_home = None + with open(os.devnull, 'w') as sink: + # Use gpg by default rather than gpg2, as gpg2 insists on + # prompting for passwords + for s in ('gpg', 'gpg2'): + try: + rc = subprocess.check_call([s, '--version'], stdout=sink, + stderr=sink) + if rc == 0: + self.gpg = s + break + except OSError: + pass + + def _get_pypirc_command(self): + """ + Get the distutils command for interacting with PyPI configurations. + :return: the command. + """ + from distutils.core import Distribution + from distutils.config import PyPIRCCommand + d = Distribution() + return PyPIRCCommand(d) + + def read_configuration(self): + """ + Read the PyPI access configuration as supported by distutils, getting + PyPI to do the actual work. This populates ``username``, ``password``, + ``realm`` and ``url`` attributes from the configuration. + """ + # get distutils to do the work + c = self._get_pypirc_command() + c.repository = self.url + cfg = c._read_pypirc() + self.username = cfg.get('username') + self.password = cfg.get('password') + self.realm = cfg.get('realm', 'pypi') + self.url = cfg.get('repository', self.url) + + def save_configuration(self): + """ + Save the PyPI access configuration. You must have set ``username`` and + ``password`` attributes before calling this method. + + Again, distutils is used to do the actual work. + """ + self.check_credentials() + # get distutils to do the work + c = self._get_pypirc_command() + c._store_pypirc(self.username, self.password) + + def check_credentials(self): + """ + Check that ``username`` and ``password`` have been set, and raise an + exception if not. + """ + if self.username is None or self.password is None: + raise DistlibException('username and password must be set') + pm = HTTPPasswordMgr() + _, netloc, _, _, _, _ = urlparse(self.url) + pm.add_password(self.realm, netloc, self.username, self.password) + self.password_handler = HTTPBasicAuthHandler(pm) + + def register(self, metadata): + """ + Register a distribution on PyPI, using the provided metadata. + + :param metadata: A :class:`Metadata` instance defining at least a name + and version number for the distribution to be + registered. + :return: The HTTP response received from PyPI upon submission of the + request. + """ + self.check_credentials() + metadata.validate() + d = metadata.todict() + d[':action'] = 'verify' + request = self.encode_request(d.items(), []) + response = self.send_request(request) + d[':action'] = 'submit' + request = self.encode_request(d.items(), []) + return self.send_request(request) + + def _reader(self, name, stream, outbuf): + """ + Thread runner for reading lines of from a subprocess into a buffer. + + :param name: The logical name of the stream (used for logging only). + :param stream: The stream to read from. This will typically a pipe + connected to the output stream of a subprocess. + :param outbuf: The list to append the read lines to. + """ + while True: + s = stream.readline() + if not s: + break + s = s.decode('utf-8').rstrip() + outbuf.append(s) + logger.debug('%s: %s' % (name, s)) + stream.close() + + def get_sign_command(self, filename, signer, sign_password, + keystore=None): + """ + Return a suitable command for signing a file. + + :param filename: The pathname to the file to be signed. + :param signer: The identifier of the signer of the file. + :param sign_password: The passphrase for the signer's + private key used for signing. + :param keystore: The path to a directory which contains the keys + used in verification. If not specified, the + instance's ``gpg_home`` attribute is used instead. + :return: The signing command as a list suitable to be + passed to :class:`subprocess.Popen`. + """ + cmd = [self.gpg, '--status-fd', '2', '--no-tty'] + if keystore is None: + keystore = self.gpg_home + if keystore: + cmd.extend(['--homedir', keystore]) + if sign_password is not None: + cmd.extend(['--batch', '--passphrase-fd', '0']) + td = tempfile.mkdtemp() + sf = os.path.join(td, os.path.basename(filename) + '.asc') + cmd.extend(['--detach-sign', '--armor', '--local-user', + signer, '--output', sf, filename]) + logger.debug('invoking: %s', ' '.join(cmd)) + return cmd, sf + + def run_command(self, cmd, input_data=None): + """ + Run a command in a child process , passing it any input data specified. + + :param cmd: The command to run. + :param input_data: If specified, this must be a byte string containing + data to be sent to the child process. + :return: A tuple consisting of the subprocess' exit code, a list of + lines read from the subprocess' ``stdout``, and a list of + lines read from the subprocess' ``stderr``. + """ + kwargs = { + 'stdout': subprocess.PIPE, + 'stderr': subprocess.PIPE, + } + if input_data is not None: + kwargs['stdin'] = subprocess.PIPE + stdout = [] + stderr = [] + p = subprocess.Popen(cmd, **kwargs) + # We don't use communicate() here because we may need to + # get clever with interacting with the command + t1 = Thread(target=self._reader, args=('stdout', p.stdout, stdout)) + t1.start() + t2 = Thread(target=self._reader, args=('stderr', p.stderr, stderr)) + t2.start() + if input_data is not None: + p.stdin.write(input_data) + p.stdin.close() + + p.wait() + t1.join() + t2.join() + return p.returncode, stdout, stderr + + def sign_file(self, filename, signer, sign_password, keystore=None): + """ + Sign a file. + + :param filename: The pathname to the file to be signed. + :param signer: The identifier of the signer of the file. + :param sign_password: The passphrase for the signer's + private key used for signing. + :param keystore: The path to a directory which contains the keys + used in signing. If not specified, the instance's + ``gpg_home`` attribute is used instead. + :return: The absolute pathname of the file where the signature is + stored. + """ + cmd, sig_file = self.get_sign_command(filename, signer, sign_password, + keystore) + rc, stdout, stderr = self.run_command(cmd, + sign_password.encode('utf-8')) + if rc != 0: + raise DistlibException('sign command failed with error ' + 'code %s' % rc) + return sig_file + + def upload_file(self, metadata, filename, signer=None, sign_password=None, + filetype='sdist', pyversion='source', keystore=None): + """ + Upload a release file to the index. + + :param metadata: A :class:`Metadata` instance defining at least a name + and version number for the file to be uploaded. + :param filename: The pathname of the file to be uploaded. + :param signer: The identifier of the signer of the file. + :param sign_password: The passphrase for the signer's + private key used for signing. + :param filetype: The type of the file being uploaded. This is the + distutils command which produced that file, e.g. + ``sdist`` or ``bdist_wheel``. + :param pyversion: The version of Python which the release relates + to. For code compatible with any Python, this would + be ``source``, otherwise it would be e.g. ``3.2``. + :param keystore: The path to a directory which contains the keys + used in signing. If not specified, the instance's + ``gpg_home`` attribute is used instead. + :return: The HTTP response received from PyPI upon submission of the + request. + """ + self.check_credentials() + if not os.path.exists(filename): + raise DistlibException('not found: %s' % filename) + metadata.validate() + d = metadata.todict() + sig_file = None + if signer: + if not self.gpg: + logger.warning('no signing program available - not signed') + else: + sig_file = self.sign_file(filename, signer, sign_password, + keystore) + with open(filename, 'rb') as f: + file_data = f.read() + md5_digest = hashlib.md5(file_data).hexdigest() + sha256_digest = hashlib.sha256(file_data).hexdigest() + d.update({ + ':action': 'file_upload', + 'protocol_version': '1', + 'filetype': filetype, + 'pyversion': pyversion, + 'md5_digest': md5_digest, + 'sha256_digest': sha256_digest, + }) + files = [('content', os.path.basename(filename), file_data)] + if sig_file: + with open(sig_file, 'rb') as f: + sig_data = f.read() + files.append(('gpg_signature', os.path.basename(sig_file), + sig_data)) + shutil.rmtree(os.path.dirname(sig_file)) + request = self.encode_request(d.items(), files) + return self.send_request(request) + + def upload_documentation(self, metadata, doc_dir): + """ + Upload documentation to the index. + + :param metadata: A :class:`Metadata` instance defining at least a name + and version number for the documentation to be + uploaded. + :param doc_dir: The pathname of the directory which contains the + documentation. This should be the directory that + contains the ``index.html`` for the documentation. + :return: The HTTP response received from PyPI upon submission of the + request. + """ + self.check_credentials() + if not os.path.isdir(doc_dir): + raise DistlibException('not a directory: %r' % doc_dir) + fn = os.path.join(doc_dir, 'index.html') + if not os.path.exists(fn): + raise DistlibException('not found: %r' % fn) + metadata.validate() + name, version = metadata.name, metadata.version + zip_data = zip_dir(doc_dir).getvalue() + fields = [(':action', 'doc_upload'), + ('name', name), ('version', version)] + files = [('content', name, zip_data)] + request = self.encode_request(fields, files) + return self.send_request(request) + + def get_verify_command(self, signature_filename, data_filename, + keystore=None): + """ + Return a suitable command for verifying a file. + + :param signature_filename: The pathname to the file containing the + signature. + :param data_filename: The pathname to the file containing the + signed data. + :param keystore: The path to a directory which contains the keys + used in verification. If not specified, the + instance's ``gpg_home`` attribute is used instead. + :return: The verifying command as a list suitable to be + passed to :class:`subprocess.Popen`. + """ + cmd = [self.gpg, '--status-fd', '2', '--no-tty'] + if keystore is None: + keystore = self.gpg_home + if keystore: + cmd.extend(['--homedir', keystore]) + cmd.extend(['--verify', signature_filename, data_filename]) + logger.debug('invoking: %s', ' '.join(cmd)) + return cmd + + def verify_signature(self, signature_filename, data_filename, + keystore=None): + """ + Verify a signature for a file. + + :param signature_filename: The pathname to the file containing the + signature. + :param data_filename: The pathname to the file containing the + signed data. + :param keystore: The path to a directory which contains the keys + used in verification. If not specified, the + instance's ``gpg_home`` attribute is used instead. + :return: True if the signature was verified, else False. + """ + if not self.gpg: + raise DistlibException('verification unavailable because gpg ' + 'unavailable') + cmd = self.get_verify_command(signature_filename, data_filename, + keystore) + rc, stdout, stderr = self.run_command(cmd) + if rc not in (0, 1): + raise DistlibException('verify command failed with error ' + 'code %s' % rc) + return rc == 0 + + def download_file(self, url, destfile, digest=None, reporthook=None): + """ + This is a convenience method for downloading a file from an URL. + Normally, this will be a file from the index, though currently + no check is made for this (i.e. a file can be downloaded from + anywhere). + + The method is just like the :func:`urlretrieve` function in the + standard library, except that it allows digest computation to be + done during download and checking that the downloaded data + matched any expected value. + + :param url: The URL of the file to be downloaded (assumed to be + available via an HTTP GET request). + :param destfile: The pathname where the downloaded file is to be + saved. + :param digest: If specified, this must be a (hasher, value) + tuple, where hasher is the algorithm used (e.g. + ``'md5'``) and ``value`` is the expected value. + :param reporthook: The same as for :func:`urlretrieve` in the + standard library. + """ + if digest is None: + digester = None + logger.debug('No digest specified') + else: + if isinstance(digest, (list, tuple)): + hasher, digest = digest + else: + hasher = 'md5' + digester = getattr(hashlib, hasher)() + logger.debug('Digest specified: %s' % digest) + # The following code is equivalent to urlretrieve. + # We need to do it this way so that we can compute the + # digest of the file as we go. + with open(destfile, 'wb') as dfp: + # addinfourl is not a context manager on 2.x + # so we have to use try/finally + sfp = self.send_request(Request(url)) + try: + headers = sfp.info() + blocksize = 8192 + size = -1 + read = 0 + blocknum = 0 + if "content-length" in headers: + size = int(headers["Content-Length"]) + if reporthook: + reporthook(blocknum, blocksize, size) + while True: + block = sfp.read(blocksize) + if not block: + break + read += len(block) + dfp.write(block) + if digester: + digester.update(block) + blocknum += 1 + if reporthook: + reporthook(blocknum, blocksize, size) + finally: + sfp.close() + + # check that we got the whole file, if we can + if size >= 0 and read < size: + raise DistlibException( + 'retrieval incomplete: got only %d out of %d bytes' + % (read, size)) + # if we have a digest, it must match. + if digester: + actual = digester.hexdigest() + if digest != actual: + raise DistlibException('%s digest mismatch for %s: expected ' + '%s, got %s' % (hasher, destfile, + digest, actual)) + logger.debug('Digest verified: %s', digest) + + def send_request(self, req): + """ + Send a standard library :class:`Request` to PyPI and return its + response. + + :param req: The request to send. + :return: The HTTP response from PyPI (a standard library HTTPResponse). + """ + handlers = [] + if self.password_handler: + handlers.append(self.password_handler) + if self.ssl_verifier: + handlers.append(self.ssl_verifier) + opener = build_opener(*handlers) + return opener.open(req) + + def encode_request(self, fields, files): + """ + Encode fields and files for posting to an HTTP server. + + :param fields: The fields to send as a list of (fieldname, value) + tuples. + :param files: The files to send as a list of (fieldname, filename, + file_bytes) tuple. + """ + # Adapted from packaging, which in turn was adapted from + # http://code.activestate.com/recipes/146306 + + parts = [] + boundary = self.boundary + for k, values in fields: + if not isinstance(values, (list, tuple)): + values = [values] + + for v in values: + parts.extend(( + b'--' + boundary, + ('Content-Disposition: form-data; name="%s"' % + k).encode('utf-8'), + b'', + v.encode('utf-8'))) + for key, filename, value in files: + parts.extend(( + b'--' + boundary, + ('Content-Disposition: form-data; name="%s"; filename="%s"' % + (key, filename)).encode('utf-8'), + b'', + value)) + + parts.extend((b'--' + boundary + b'--', b'')) + + body = b'\r\n'.join(parts) + ct = b'multipart/form-data; boundary=' + boundary + headers = { + 'Content-type': ct, + 'Content-length': str(len(body)) + } + return Request(self.url, body, headers) + + def search(self, terms, operator=None): + if isinstance(terms, string_types): + terms = {'name': terms} + rpc_proxy = ServerProxy(self.url, timeout=3.0) + try: + return rpc_proxy.search(terms, operator or 'and') + finally: + rpc_proxy('close')() diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/locators.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/locators.py new file mode 100644 index 0000000000000000000000000000000000000000..a7ed9469d8e24d256d170d85450176a949110f88 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/locators.py @@ -0,0 +1,1295 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2015 Vinay Sajip. +# Licensed to the Python Software Foundation under a contributor agreement. +# See LICENSE.txt and CONTRIBUTORS.txt. +# + +import gzip +from io import BytesIO +import json +import logging +import os +import posixpath +import re +try: + import threading +except ImportError: # pragma: no cover + import dummy_threading as threading +import zlib + +from . import DistlibException +from .compat import (urljoin, urlparse, urlunparse, url2pathname, pathname2url, + queue, quote, unescape, string_types, build_opener, + HTTPRedirectHandler as BaseRedirectHandler, text_type, + Request, HTTPError, URLError) +from .database import Distribution, DistributionPath, make_dist +from .metadata import Metadata, MetadataInvalidError +from .util import (cached_property, parse_credentials, ensure_slash, + split_filename, get_project_data, parse_requirement, + parse_name_and_version, ServerProxy, normalize_name) +from .version import get_scheme, UnsupportedVersionError +from .wheel import Wheel, is_compatible + +logger = logging.getLogger(__name__) + +HASHER_HASH = re.compile(r'^(\w+)=([a-f0-9]+)') +CHARSET = re.compile(r';\s*charset\s*=\s*(.*)\s*$', re.I) +HTML_CONTENT_TYPE = re.compile('text/html|application/x(ht)?ml') +DEFAULT_INDEX = 'https://pypi.org/pypi' + +def get_all_distribution_names(url=None): + """ + Return all distribution names known by an index. + :param url: The URL of the index. + :return: A list of all known distribution names. + """ + if url is None: + url = DEFAULT_INDEX + client = ServerProxy(url, timeout=3.0) + try: + return client.list_packages() + finally: + client('close')() + +class RedirectHandler(BaseRedirectHandler): + """ + A class to work around a bug in some Python 3.2.x releases. + """ + # There's a bug in the base version for some 3.2.x + # (e.g. 3.2.2 on Ubuntu Oneiric). If a Location header + # returns e.g. /abc, it bails because it says the scheme '' + # is bogus, when actually it should use the request's + # URL for the scheme. See Python issue #13696. + def http_error_302(self, req, fp, code, msg, headers): + # Some servers (incorrectly) return multiple Location headers + # (so probably same goes for URI). Use first header. + newurl = None + for key in ('location', 'uri'): + if key in headers: + newurl = headers[key] + break + if newurl is None: # pragma: no cover + return + urlparts = urlparse(newurl) + if urlparts.scheme == '': + newurl = urljoin(req.get_full_url(), newurl) + if hasattr(headers, 'replace_header'): + headers.replace_header(key, newurl) + else: + headers[key] = newurl + return BaseRedirectHandler.http_error_302(self, req, fp, code, msg, + headers) + + http_error_301 = http_error_303 = http_error_307 = http_error_302 + +class Locator(object): + """ + A base class for locators - things that locate distributions. + """ + source_extensions = ('.tar.gz', '.tar.bz2', '.tar', '.zip', '.tgz', '.tbz') + binary_extensions = ('.egg', '.exe', '.whl') + excluded_extensions = ('.pdf',) + + # A list of tags indicating which wheels you want to match. The default + # value of None matches against the tags compatible with the running + # Python. If you want to match other values, set wheel_tags on a locator + # instance to a list of tuples (pyver, abi, arch) which you want to match. + wheel_tags = None + + downloadable_extensions = source_extensions + ('.whl',) + + def __init__(self, scheme='default'): + """ + Initialise an instance. + :param scheme: Because locators look for most recent versions, they + need to know the version scheme to use. This specifies + the current PEP-recommended scheme - use ``'legacy'`` + if you need to support existing distributions on PyPI. + """ + self._cache = {} + self.scheme = scheme + # Because of bugs in some of the handlers on some of the platforms, + # we use our own opener rather than just using urlopen. + self.opener = build_opener(RedirectHandler()) + # If get_project() is called from locate(), the matcher instance + # is set from the requirement passed to locate(). See issue #18 for + # why this can be useful to know. + self.matcher = None + self.errors = queue.Queue() + + def get_errors(self): + """ + Return any errors which have occurred. + """ + result = [] + while not self.errors.empty(): # pragma: no cover + try: + e = self.errors.get(False) + result.append(e) + except self.errors.Empty: + continue + self.errors.task_done() + return result + + def clear_errors(self): + """ + Clear any errors which may have been logged. + """ + # Just get the errors and throw them away + self.get_errors() + + def clear_cache(self): + self._cache.clear() + + def _get_scheme(self): + return self._scheme + + def _set_scheme(self, value): + self._scheme = value + + scheme = property(_get_scheme, _set_scheme) + + def _get_project(self, name): + """ + For a given project, get a dictionary mapping available versions to Distribution + instances. + + This should be implemented in subclasses. + + If called from a locate() request, self.matcher will be set to a + matcher for the requirement to satisfy, otherwise it will be None. + """ + raise NotImplementedError('Please implement in the subclass') + + def get_distribution_names(self): + """ + Return all the distribution names known to this locator. + """ + raise NotImplementedError('Please implement in the subclass') + + def get_project(self, name): + """ + For a given project, get a dictionary mapping available versions to Distribution + instances. + + This calls _get_project to do all the work, and just implements a caching layer on top. + """ + if self._cache is None: # pragma: no cover + result = self._get_project(name) + elif name in self._cache: + result = self._cache[name] + else: + self.clear_errors() + result = self._get_project(name) + self._cache[name] = result + return result + + def score_url(self, url): + """ + Give an url a score which can be used to choose preferred URLs + for a given project release. + """ + t = urlparse(url) + basename = posixpath.basename(t.path) + compatible = True + is_wheel = basename.endswith('.whl') + is_downloadable = basename.endswith(self.downloadable_extensions) + if is_wheel: + compatible = is_compatible(Wheel(basename), self.wheel_tags) + return (t.scheme == 'https', 'pypi.org' in t.netloc, + is_downloadable, is_wheel, compatible, basename) + + def prefer_url(self, url1, url2): + """ + Choose one of two URLs where both are candidates for distribution + archives for the same version of a distribution (for example, + .tar.gz vs. zip). + + The current implementation favours https:// URLs over http://, archives + from PyPI over those from other locations, wheel compatibility (if a + wheel) and then the archive name. + """ + result = url2 + if url1: + s1 = self.score_url(url1) + s2 = self.score_url(url2) + if s1 > s2: + result = url1 + if result != url2: + logger.debug('Not replacing %r with %r', url1, url2) + else: + logger.debug('Replacing %r with %r', url1, url2) + return result + + def split_filename(self, filename, project_name): + """ + Attempt to split a filename in project name, version and Python version. + """ + return split_filename(filename, project_name) + + def convert_url_to_download_info(self, url, project_name): + """ + See if a URL is a candidate for a download URL for a project (the URL + has typically been scraped from an HTML page). + + If it is, a dictionary is returned with keys "name", "version", + "filename" and "url"; otherwise, None is returned. + """ + def same_project(name1, name2): + return normalize_name(name1) == normalize_name(name2) + + result = None + scheme, netloc, path, params, query, frag = urlparse(url) + if frag.lower().startswith('egg='): # pragma: no cover + logger.debug('%s: version hint in fragment: %r', + project_name, frag) + m = HASHER_HASH.match(frag) + if m: + algo, digest = m.groups() + else: + algo, digest = None, None + origpath = path + if path and path[-1] == '/': # pragma: no cover + path = path[:-1] + if path.endswith('.whl'): + try: + wheel = Wheel(path) + if not is_compatible(wheel, self.wheel_tags): + logger.debug('Wheel not compatible: %s', path) + else: + if project_name is None: + include = True + else: + include = same_project(wheel.name, project_name) + if include: + result = { + 'name': wheel.name, + 'version': wheel.version, + 'filename': wheel.filename, + 'url': urlunparse((scheme, netloc, origpath, + params, query, '')), + 'python-version': ', '.join( + ['.'.join(list(v[2:])) for v in wheel.pyver]), + } + except Exception as e: # pragma: no cover + logger.warning('invalid path for wheel: %s', path) + elif not path.endswith(self.downloadable_extensions): # pragma: no cover + logger.debug('Not downloadable: %s', path) + else: # downloadable extension + path = filename = posixpath.basename(path) + for ext in self.downloadable_extensions: + if path.endswith(ext): + path = path[:-len(ext)] + t = self.split_filename(path, project_name) + if not t: # pragma: no cover + logger.debug('No match for project/version: %s', path) + else: + name, version, pyver = t + if not project_name or same_project(project_name, name): + result = { + 'name': name, + 'version': version, + 'filename': filename, + 'url': urlunparse((scheme, netloc, origpath, + params, query, '')), + #'packagetype': 'sdist', + } + if pyver: # pragma: no cover + result['python-version'] = pyver + break + if result and algo: + result['%s_digest' % algo] = digest + return result + + def _get_digest(self, info): + """ + Get a digest from a dictionary by looking at keys of the form + 'algo_digest'. + + Returns a 2-tuple (algo, digest) if found, else None. Currently + looks only for SHA256, then MD5. + """ + result = None + for algo in ('sha256', 'md5'): + key = '%s_digest' % algo + if key in info: + result = (algo, info[key]) + break + return result + + def _update_version_data(self, result, info): + """ + Update a result dictionary (the final result from _get_project) with a + dictionary for a specific version, which typically holds information + gleaned from a filename or URL for an archive for the distribution. + """ + name = info.pop('name') + version = info.pop('version') + if version in result: + dist = result[version] + md = dist.metadata + else: + dist = make_dist(name, version, scheme=self.scheme) + md = dist.metadata + dist.digest = digest = self._get_digest(info) + url = info['url'] + result['digests'][url] = digest + if md.source_url != info['url']: + md.source_url = self.prefer_url(md.source_url, url) + result['urls'].setdefault(version, set()).add(url) + dist.locator = self + result[version] = dist + + def locate(self, requirement, prereleases=False): + """ + Find the most recent distribution which matches the given + requirement. + + :param requirement: A requirement of the form 'foo (1.0)' or perhaps + 'foo (>= 1.0, < 2.0, != 1.3)' + :param prereleases: If ``True``, allow pre-release versions + to be located. Otherwise, pre-release versions + are not returned. + :return: A :class:`Distribution` instance, or ``None`` if no such + distribution could be located. + """ + result = None + r = parse_requirement(requirement) + if r is None: # pragma: no cover + raise DistlibException('Not a valid requirement: %r' % requirement) + scheme = get_scheme(self.scheme) + self.matcher = matcher = scheme.matcher(r.requirement) + logger.debug('matcher: %s (%s)', matcher, type(matcher).__name__) + versions = self.get_project(r.name) + if len(versions) > 2: # urls and digests keys are present + # sometimes, versions are invalid + slist = [] + vcls = matcher.version_class + for k in versions: + if k in ('urls', 'digests'): + continue + try: + if not matcher.match(k): + logger.debug('%s did not match %r', matcher, k) + else: + if prereleases or not vcls(k).is_prerelease: + slist.append(k) + else: + logger.debug('skipping pre-release ' + 'version %s of %s', k, matcher.name) + except Exception: # pragma: no cover + logger.warning('error matching %s with %r', matcher, k) + pass # slist.append(k) + if len(slist) > 1: + slist = sorted(slist, key=scheme.key) + if slist: + logger.debug('sorted list: %s', slist) + version = slist[-1] + result = versions[version] + if result: + if r.extras: + result.extras = r.extras + result.download_urls = versions.get('urls', {}).get(version, set()) + d = {} + sd = versions.get('digests', {}) + for url in result.download_urls: + if url in sd: # pragma: no cover + d[url] = sd[url] + result.digests = d + self.matcher = None + return result + + +class PyPIRPCLocator(Locator): + """ + This locator uses XML-RPC to locate distributions. It therefore + cannot be used with simple mirrors (that only mirror file content). + """ + def __init__(self, url, **kwargs): + """ + Initialise an instance. + + :param url: The URL to use for XML-RPC. + :param kwargs: Passed to the superclass constructor. + """ + super(PyPIRPCLocator, self).__init__(**kwargs) + self.base_url = url + self.client = ServerProxy(url, timeout=3.0) + + def get_distribution_names(self): + """ + Return all the distribution names known to this locator. + """ + return set(self.client.list_packages()) + + def _get_project(self, name): + result = {'urls': {}, 'digests': {}} + versions = self.client.package_releases(name, True) + for v in versions: + urls = self.client.release_urls(name, v) + data = self.client.release_data(name, v) + metadata = Metadata(scheme=self.scheme) + metadata.name = data['name'] + metadata.version = data['version'] + metadata.license = data.get('license') + metadata.keywords = data.get('keywords', []) + metadata.summary = data.get('summary') + dist = Distribution(metadata) + if urls: + info = urls[0] + metadata.source_url = info['url'] + dist.digest = self._get_digest(info) + dist.locator = self + result[v] = dist + for info in urls: + url = info['url'] + digest = self._get_digest(info) + result['urls'].setdefault(v, set()).add(url) + result['digests'][url] = digest + return result + +class PyPIJSONLocator(Locator): + """ + This locator uses PyPI's JSON interface. It's very limited in functionality + and probably not worth using. + """ + def __init__(self, url, **kwargs): + super(PyPIJSONLocator, self).__init__(**kwargs) + self.base_url = ensure_slash(url) + + def get_distribution_names(self): + """ + Return all the distribution names known to this locator. + """ + raise NotImplementedError('Not available from this locator') + + def _get_project(self, name): + result = {'urls': {}, 'digests': {}} + url = urljoin(self.base_url, '%s/json' % quote(name)) + try: + resp = self.opener.open(url) + data = resp.read().decode() # for now + d = json.loads(data) + md = Metadata(scheme=self.scheme) + data = d['info'] + md.name = data['name'] + md.version = data['version'] + md.license = data.get('license') + md.keywords = data.get('keywords', []) + md.summary = data.get('summary') + dist = Distribution(md) + dist.locator = self + urls = d['urls'] + result[md.version] = dist + for info in d['urls']: + url = info['url'] + dist.download_urls.add(url) + dist.digests[url] = self._get_digest(info) + result['urls'].setdefault(md.version, set()).add(url) + result['digests'][url] = self._get_digest(info) + # Now get other releases + for version, infos in d['releases'].items(): + if version == md.version: + continue # already done + omd = Metadata(scheme=self.scheme) + omd.name = md.name + omd.version = version + odist = Distribution(omd) + odist.locator = self + result[version] = odist + for info in infos: + url = info['url'] + odist.download_urls.add(url) + odist.digests[url] = self._get_digest(info) + result['urls'].setdefault(version, set()).add(url) + result['digests'][url] = self._get_digest(info) +# for info in urls: +# md.source_url = info['url'] +# dist.digest = self._get_digest(info) +# dist.locator = self +# for info in urls: +# url = info['url'] +# result['urls'].setdefault(md.version, set()).add(url) +# result['digests'][url] = self._get_digest(info) + except Exception as e: + self.errors.put(text_type(e)) + logger.exception('JSON fetch failed: %s', e) + return result + + +class Page(object): + """ + This class represents a scraped HTML page. + """ + # The following slightly hairy-looking regex just looks for the contents of + # an anchor link, which has an attribute "href" either immediately preceded + # or immediately followed by a "rel" attribute. The attribute values can be + # declared with double quotes, single quotes or no quotes - which leads to + # the length of the expression. + _href = re.compile(""" +(rel\\s*=\\s*(?:"(?P[^"]*)"|'(?P[^']*)'|(?P[^>\\s\n]*))\\s+)? +href\\s*=\\s*(?:"(?P[^"]*)"|'(?P[^']*)'|(?P[^>\\s\n]*)) +(\\s+rel\\s*=\\s*(?:"(?P[^"]*)"|'(?P[^']*)'|(?P[^>\\s\n]*)))? +""", re.I | re.S | re.X) + _base = re.compile(r"""]+)""", re.I | re.S) + + def __init__(self, data, url): + """ + Initialise an instance with the Unicode page contents and the URL they + came from. + """ + self.data = data + self.base_url = self.url = url + m = self._base.search(self.data) + if m: + self.base_url = m.group(1) + + _clean_re = re.compile(r'[^a-z0-9$&+,/:;=?@.#%_\\|-]', re.I) + + @cached_property + def links(self): + """ + Return the URLs of all the links on a page together with information + about their "rel" attribute, for determining which ones to treat as + downloads and which ones to queue for further scraping. + """ + def clean(url): + "Tidy up an URL." + scheme, netloc, path, params, query, frag = urlparse(url) + return urlunparse((scheme, netloc, quote(path), + params, query, frag)) + + result = set() + for match in self._href.finditer(self.data): + d = match.groupdict('') + rel = (d['rel1'] or d['rel2'] or d['rel3'] or + d['rel4'] or d['rel5'] or d['rel6']) + url = d['url1'] or d['url2'] or d['url3'] + url = urljoin(self.base_url, url) + url = unescape(url) + url = self._clean_re.sub(lambda m: '%%%2x' % ord(m.group(0)), url) + result.add((url, rel)) + # We sort the result, hoping to bring the most recent versions + # to the front + result = sorted(result, key=lambda t: t[0], reverse=True) + return result + + +class SimpleScrapingLocator(Locator): + """ + A locator which scrapes HTML pages to locate downloads for a distribution. + This runs multiple threads to do the I/O; performance is at least as good + as pip's PackageFinder, which works in an analogous fashion. + """ + + # These are used to deal with various Content-Encoding schemes. + decoders = { + 'deflate': zlib.decompress, + 'gzip': lambda b: gzip.GzipFile(fileobj=BytesIO(d)).read(), + 'none': lambda b: b, + } + + def __init__(self, url, timeout=None, num_workers=10, **kwargs): + """ + Initialise an instance. + :param url: The root URL to use for scraping. + :param timeout: The timeout, in seconds, to be applied to requests. + This defaults to ``None`` (no timeout specified). + :param num_workers: The number of worker threads you want to do I/O, + This defaults to 10. + :param kwargs: Passed to the superclass. + """ + super(SimpleScrapingLocator, self).__init__(**kwargs) + self.base_url = ensure_slash(url) + self.timeout = timeout + self._page_cache = {} + self._seen = set() + self._to_fetch = queue.Queue() + self._bad_hosts = set() + self.skip_externals = False + self.num_workers = num_workers + self._lock = threading.RLock() + # See issue #45: we need to be resilient when the locator is used + # in a thread, e.g. with concurrent.futures. We can't use self._lock + # as it is for coordinating our internal threads - the ones created + # in _prepare_threads. + self._gplock = threading.RLock() + self.platform_check = False # See issue #112 + + def _prepare_threads(self): + """ + Threads are created only when get_project is called, and terminate + before it returns. They are there primarily to parallelise I/O (i.e. + fetching web pages). + """ + self._threads = [] + for i in range(self.num_workers): + t = threading.Thread(target=self._fetch) + t.setDaemon(True) + t.start() + self._threads.append(t) + + def _wait_threads(self): + """ + Tell all the threads to terminate (by sending a sentinel value) and + wait for them to do so. + """ + # Note that you need two loops, since you can't say which + # thread will get each sentinel + for t in self._threads: + self._to_fetch.put(None) # sentinel + for t in self._threads: + t.join() + self._threads = [] + + def _get_project(self, name): + result = {'urls': {}, 'digests': {}} + with self._gplock: + self.result = result + self.project_name = name + url = urljoin(self.base_url, '%s/' % quote(name)) + self._seen.clear() + self._page_cache.clear() + self._prepare_threads() + try: + logger.debug('Queueing %s', url) + self._to_fetch.put(url) + self._to_fetch.join() + finally: + self._wait_threads() + del self.result + return result + + platform_dependent = re.compile(r'\b(linux_(i\d86|x86_64|arm\w+)|' + r'win(32|_amd64)|macosx_?\d+)\b', re.I) + + def _is_platform_dependent(self, url): + """ + Does an URL refer to a platform-specific download? + """ + return self.platform_dependent.search(url) + + def _process_download(self, url): + """ + See if an URL is a suitable download for a project. + + If it is, register information in the result dictionary (for + _get_project) about the specific version it's for. + + Note that the return value isn't actually used other than as a boolean + value. + """ + if self.platform_check and self._is_platform_dependent(url): + info = None + else: + info = self.convert_url_to_download_info(url, self.project_name) + logger.debug('process_download: %s -> %s', url, info) + if info: + with self._lock: # needed because self.result is shared + self._update_version_data(self.result, info) + return info + + def _should_queue(self, link, referrer, rel): + """ + Determine whether a link URL from a referring page and with a + particular "rel" attribute should be queued for scraping. + """ + scheme, netloc, path, _, _, _ = urlparse(link) + if path.endswith(self.source_extensions + self.binary_extensions + + self.excluded_extensions): + result = False + elif self.skip_externals and not link.startswith(self.base_url): + result = False + elif not referrer.startswith(self.base_url): + result = False + elif rel not in ('homepage', 'download'): + result = False + elif scheme not in ('http', 'https', 'ftp'): + result = False + elif self._is_platform_dependent(link): + result = False + else: + host = netloc.split(':', 1)[0] + if host.lower() == 'localhost': + result = False + else: + result = True + logger.debug('should_queue: %s (%s) from %s -> %s', link, rel, + referrer, result) + return result + + def _fetch(self): + """ + Get a URL to fetch from the work queue, get the HTML page, examine its + links for download candidates and candidates for further scraping. + + This is a handy method to run in a thread. + """ + while True: + url = self._to_fetch.get() + try: + if url: + page = self.get_page(url) + if page is None: # e.g. after an error + continue + for link, rel in page.links: + if link not in self._seen: + try: + self._seen.add(link) + if (not self._process_download(link) and + self._should_queue(link, url, rel)): + logger.debug('Queueing %s from %s', link, url) + self._to_fetch.put(link) + except MetadataInvalidError: # e.g. invalid versions + pass + except Exception as e: # pragma: no cover + self.errors.put(text_type(e)) + finally: + # always do this, to avoid hangs :-) + self._to_fetch.task_done() + if not url: + #logger.debug('Sentinel seen, quitting.') + break + + def get_page(self, url): + """ + Get the HTML for an URL, possibly from an in-memory cache. + + XXX TODO Note: this cache is never actually cleared. It's assumed that + the data won't get stale over the lifetime of a locator instance (not + necessarily true for the default_locator). + """ + # http://peak.telecommunity.com/DevCenter/EasyInstall#package-index-api + scheme, netloc, path, _, _, _ = urlparse(url) + if scheme == 'file' and os.path.isdir(url2pathname(path)): + url = urljoin(ensure_slash(url), 'index.html') + + if url in self._page_cache: + result = self._page_cache[url] + logger.debug('Returning %s from cache: %s', url, result) + else: + host = netloc.split(':', 1)[0] + result = None + if host in self._bad_hosts: + logger.debug('Skipping %s due to bad host %s', url, host) + else: + req = Request(url, headers={'Accept-encoding': 'identity'}) + try: + logger.debug('Fetching %s', url) + resp = self.opener.open(req, timeout=self.timeout) + logger.debug('Fetched %s', url) + headers = resp.info() + content_type = headers.get('Content-Type', '') + if HTML_CONTENT_TYPE.match(content_type): + final_url = resp.geturl() + data = resp.read() + encoding = headers.get('Content-Encoding') + if encoding: + decoder = self.decoders[encoding] # fail if not found + data = decoder(data) + encoding = 'utf-8' + m = CHARSET.search(content_type) + if m: + encoding = m.group(1) + try: + data = data.decode(encoding) + except UnicodeError: # pragma: no cover + data = data.decode('latin-1') # fallback + result = Page(data, final_url) + self._page_cache[final_url] = result + except HTTPError as e: + if e.code != 404: + logger.exception('Fetch failed: %s: %s', url, e) + except URLError as e: # pragma: no cover + logger.exception('Fetch failed: %s: %s', url, e) + with self._lock: + self._bad_hosts.add(host) + except Exception as e: # pragma: no cover + logger.exception('Fetch failed: %s: %s', url, e) + finally: + self._page_cache[url] = result # even if None (failure) + return result + + _distname_re = re.compile(']*>([^<]+)<') + + def get_distribution_names(self): + """ + Return all the distribution names known to this locator. + """ + result = set() + page = self.get_page(self.base_url) + if not page: + raise DistlibException('Unable to get %s' % self.base_url) + for match in self._distname_re.finditer(page.data): + result.add(match.group(1)) + return result + +class DirectoryLocator(Locator): + """ + This class locates distributions in a directory tree. + """ + + def __init__(self, path, **kwargs): + """ + Initialise an instance. + :param path: The root of the directory tree to search. + :param kwargs: Passed to the superclass constructor, + except for: + * recursive - if True (the default), subdirectories are + recursed into. If False, only the top-level directory + is searched, + """ + self.recursive = kwargs.pop('recursive', True) + super(DirectoryLocator, self).__init__(**kwargs) + path = os.path.abspath(path) + if not os.path.isdir(path): # pragma: no cover + raise DistlibException('Not a directory: %r' % path) + self.base_dir = path + + def should_include(self, filename, parent): + """ + Should a filename be considered as a candidate for a distribution + archive? As well as the filename, the directory which contains it + is provided, though not used by the current implementation. + """ + return filename.endswith(self.downloadable_extensions) + + def _get_project(self, name): + result = {'urls': {}, 'digests': {}} + for root, dirs, files in os.walk(self.base_dir): + for fn in files: + if self.should_include(fn, root): + fn = os.path.join(root, fn) + url = urlunparse(('file', '', + pathname2url(os.path.abspath(fn)), + '', '', '')) + info = self.convert_url_to_download_info(url, name) + if info: + self._update_version_data(result, info) + if not self.recursive: + break + return result + + def get_distribution_names(self): + """ + Return all the distribution names known to this locator. + """ + result = set() + for root, dirs, files in os.walk(self.base_dir): + for fn in files: + if self.should_include(fn, root): + fn = os.path.join(root, fn) + url = urlunparse(('file', '', + pathname2url(os.path.abspath(fn)), + '', '', '')) + info = self.convert_url_to_download_info(url, None) + if info: + result.add(info['name']) + if not self.recursive: + break + return result + +class JSONLocator(Locator): + """ + This locator uses special extended metadata (not available on PyPI) and is + the basis of performant dependency resolution in distlib. Other locators + require archive downloads before dependencies can be determined! As you + might imagine, that can be slow. + """ + def get_distribution_names(self): + """ + Return all the distribution names known to this locator. + """ + raise NotImplementedError('Not available from this locator') + + def _get_project(self, name): + result = {'urls': {}, 'digests': {}} + data = get_project_data(name) + if data: + for info in data.get('files', []): + if info['ptype'] != 'sdist' or info['pyversion'] != 'source': + continue + # We don't store summary in project metadata as it makes + # the data bigger for no benefit during dependency + # resolution + dist = make_dist(data['name'], info['version'], + summary=data.get('summary', + 'Placeholder for summary'), + scheme=self.scheme) + md = dist.metadata + md.source_url = info['url'] + # TODO SHA256 digest + if 'digest' in info and info['digest']: + dist.digest = ('md5', info['digest']) + md.dependencies = info.get('requirements', {}) + dist.exports = info.get('exports', {}) + result[dist.version] = dist + result['urls'].setdefault(dist.version, set()).add(info['url']) + return result + +class DistPathLocator(Locator): + """ + This locator finds installed distributions in a path. It can be useful for + adding to an :class:`AggregatingLocator`. + """ + def __init__(self, distpath, **kwargs): + """ + Initialise an instance. + + :param distpath: A :class:`DistributionPath` instance to search. + """ + super(DistPathLocator, self).__init__(**kwargs) + assert isinstance(distpath, DistributionPath) + self.distpath = distpath + + def _get_project(self, name): + dist = self.distpath.get_distribution(name) + if dist is None: + result = {'urls': {}, 'digests': {}} + else: + result = { + dist.version: dist, + 'urls': {dist.version: set([dist.source_url])}, + 'digests': {dist.version: set([None])} + } + return result + + +class AggregatingLocator(Locator): + """ + This class allows you to chain and/or merge a list of locators. + """ + def __init__(self, *locators, **kwargs): + """ + Initialise an instance. + + :param locators: The list of locators to search. + :param kwargs: Passed to the superclass constructor, + except for: + * merge - if False (the default), the first successful + search from any of the locators is returned. If True, + the results from all locators are merged (this can be + slow). + """ + self.merge = kwargs.pop('merge', False) + self.locators = locators + super(AggregatingLocator, self).__init__(**kwargs) + + def clear_cache(self): + super(AggregatingLocator, self).clear_cache() + for locator in self.locators: + locator.clear_cache() + + def _set_scheme(self, value): + self._scheme = value + for locator in self.locators: + locator.scheme = value + + scheme = property(Locator.scheme.fget, _set_scheme) + + def _get_project(self, name): + result = {} + for locator in self.locators: + d = locator.get_project(name) + if d: + if self.merge: + files = result.get('urls', {}) + digests = result.get('digests', {}) + # next line could overwrite result['urls'], result['digests'] + result.update(d) + df = result.get('urls') + if files and df: + for k, v in files.items(): + if k in df: + df[k] |= v + else: + df[k] = v + dd = result.get('digests') + if digests and dd: + dd.update(digests) + else: + # See issue #18. If any dists are found and we're looking + # for specific constraints, we only return something if + # a match is found. For example, if a DirectoryLocator + # returns just foo (1.0) while we're looking for + # foo (>= 2.0), we'll pretend there was nothing there so + # that subsequent locators can be queried. Otherwise we + # would just return foo (1.0) which would then lead to a + # failure to find foo (>= 2.0), because other locators + # weren't searched. Note that this only matters when + # merge=False. + if self.matcher is None: + found = True + else: + found = False + for k in d: + if self.matcher.match(k): + found = True + break + if found: + result = d + break + return result + + def get_distribution_names(self): + """ + Return all the distribution names known to this locator. + """ + result = set() + for locator in self.locators: + try: + result |= locator.get_distribution_names() + except NotImplementedError: + pass + return result + + +# We use a legacy scheme simply because most of the dists on PyPI use legacy +# versions which don't conform to PEP 426 / PEP 440. +default_locator = AggregatingLocator( + JSONLocator(), + SimpleScrapingLocator('https://pypi.org/simple/', + timeout=3.0), + scheme='legacy') + +locate = default_locator.locate + +NAME_VERSION_RE = re.compile(r'(?P[\w-]+)\s*' + r'\(\s*(==\s*)?(?P[^)]+)\)$') + +class DependencyFinder(object): + """ + Locate dependencies for distributions. + """ + + def __init__(self, locator=None): + """ + Initialise an instance, using the specified locator + to locate distributions. + """ + self.locator = locator or default_locator + self.scheme = get_scheme(self.locator.scheme) + + def add_distribution(self, dist): + """ + Add a distribution to the finder. This will update internal information + about who provides what. + :param dist: The distribution to add. + """ + logger.debug('adding distribution %s', dist) + name = dist.key + self.dists_by_name[name] = dist + self.dists[(name, dist.version)] = dist + for p in dist.provides: + name, version = parse_name_and_version(p) + logger.debug('Add to provided: %s, %s, %s', name, version, dist) + self.provided.setdefault(name, set()).add((version, dist)) + + def remove_distribution(self, dist): + """ + Remove a distribution from the finder. This will update internal + information about who provides what. + :param dist: The distribution to remove. + """ + logger.debug('removing distribution %s', dist) + name = dist.key + del self.dists_by_name[name] + del self.dists[(name, dist.version)] + for p in dist.provides: + name, version = parse_name_and_version(p) + logger.debug('Remove from provided: %s, %s, %s', name, version, dist) + s = self.provided[name] + s.remove((version, dist)) + if not s: + del self.provided[name] + + def get_matcher(self, reqt): + """ + Get a version matcher for a requirement. + :param reqt: The requirement + :type reqt: str + :return: A version matcher (an instance of + :class:`distlib.version.Matcher`). + """ + try: + matcher = self.scheme.matcher(reqt) + except UnsupportedVersionError: # pragma: no cover + # XXX compat-mode if cannot read the version + name = reqt.split()[0] + matcher = self.scheme.matcher(name) + return matcher + + def find_providers(self, reqt): + """ + Find the distributions which can fulfill a requirement. + + :param reqt: The requirement. + :type reqt: str + :return: A set of distribution which can fulfill the requirement. + """ + matcher = self.get_matcher(reqt) + name = matcher.key # case-insensitive + result = set() + provided = self.provided + if name in provided: + for version, provider in provided[name]: + try: + match = matcher.match(version) + except UnsupportedVersionError: + match = False + + if match: + result.add(provider) + break + return result + + def try_to_replace(self, provider, other, problems): + """ + Attempt to replace one provider with another. This is typically used + when resolving dependencies from multiple sources, e.g. A requires + (B >= 1.0) while C requires (B >= 1.1). + + For successful replacement, ``provider`` must meet all the requirements + which ``other`` fulfills. + + :param provider: The provider we are trying to replace with. + :param other: The provider we're trying to replace. + :param problems: If False is returned, this will contain what + problems prevented replacement. This is currently + a tuple of the literal string 'cantreplace', + ``provider``, ``other`` and the set of requirements + that ``provider`` couldn't fulfill. + :return: True if we can replace ``other`` with ``provider``, else + False. + """ + rlist = self.reqts[other] + unmatched = set() + for s in rlist: + matcher = self.get_matcher(s) + if not matcher.match(provider.version): + unmatched.add(s) + if unmatched: + # can't replace other with provider + problems.add(('cantreplace', provider, other, + frozenset(unmatched))) + result = False + else: + # can replace other with provider + self.remove_distribution(other) + del self.reqts[other] + for s in rlist: + self.reqts.setdefault(provider, set()).add(s) + self.add_distribution(provider) + result = True + return result + + def find(self, requirement, meta_extras=None, prereleases=False): + """ + Find a distribution and all distributions it depends on. + + :param requirement: The requirement specifying the distribution to + find, or a Distribution instance. + :param meta_extras: A list of meta extras such as :test:, :build: and + so on. + :param prereleases: If ``True``, allow pre-release versions to be + returned - otherwise, don't return prereleases + unless they're all that's available. + + Return a set of :class:`Distribution` instances and a set of + problems. + + The distributions returned should be such that they have the + :attr:`required` attribute set to ``True`` if they were + from the ``requirement`` passed to ``find()``, and they have the + :attr:`build_time_dependency` attribute set to ``True`` unless they + are post-installation dependencies of the ``requirement``. + + The problems should be a tuple consisting of the string + ``'unsatisfied'`` and the requirement which couldn't be satisfied + by any distribution known to the locator. + """ + + self.provided = {} + self.dists = {} + self.dists_by_name = {} + self.reqts = {} + + meta_extras = set(meta_extras or []) + if ':*:' in meta_extras: + meta_extras.remove(':*:') + # :meta: and :run: are implicitly included + meta_extras |= set([':test:', ':build:', ':dev:']) + + if isinstance(requirement, Distribution): + dist = odist = requirement + logger.debug('passed %s as requirement', odist) + else: + dist = odist = self.locator.locate(requirement, + prereleases=prereleases) + if dist is None: + raise DistlibException('Unable to locate %r' % requirement) + logger.debug('located %s', odist) + dist.requested = True + problems = set() + todo = set([dist]) + install_dists = set([odist]) + while todo: + dist = todo.pop() + name = dist.key # case-insensitive + if name not in self.dists_by_name: + self.add_distribution(dist) + else: + #import pdb; pdb.set_trace() + other = self.dists_by_name[name] + if other != dist: + self.try_to_replace(dist, other, problems) + + ireqts = dist.run_requires | dist.meta_requires + sreqts = dist.build_requires + ereqts = set() + if meta_extras and dist in install_dists: + for key in ('test', 'build', 'dev'): + e = ':%s:' % key + if e in meta_extras: + ereqts |= getattr(dist, '%s_requires' % key) + all_reqts = ireqts | sreqts | ereqts + for r in all_reqts: + providers = self.find_providers(r) + if not providers: + logger.debug('No providers found for %r', r) + provider = self.locator.locate(r, prereleases=prereleases) + # If no provider is found and we didn't consider + # prereleases, consider them now. + if provider is None and not prereleases: + provider = self.locator.locate(r, prereleases=True) + if provider is None: + logger.debug('Cannot satisfy %r', r) + problems.add(('unsatisfied', r)) + else: + n, v = provider.key, provider.version + if (n, v) not in self.dists: + todo.add(provider) + providers.add(provider) + if r in ireqts and dist in install_dists: + install_dists.add(provider) + logger.debug('Adding %s to install_dists', + provider.name_and_version) + for p in providers: + name = p.key + if name not in self.dists_by_name: + self.reqts.setdefault(p, set()).add(r) + else: + other = self.dists_by_name[name] + if other != p: + # see if other can be replaced by p + self.try_to_replace(p, other, problems) + + dists = set(self.dists.values()) + for dist in dists: + dist.build_time_dependency = dist not in install_dists + if dist.build_time_dependency: + logger.debug('%s is a build-time dependency only.', + dist.name_and_version) + logger.debug('find done for %s', odist) + return dists, problems diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/manifest.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/manifest.py new file mode 100644 index 0000000000000000000000000000000000000000..ca0fe442d9ca499466df9438df16eca405c5f102 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/manifest.py @@ -0,0 +1,393 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012-2013 Python Software Foundation. +# See LICENSE.txt and CONTRIBUTORS.txt. +# +""" +Class representing the list of files in a distribution. + +Equivalent to distutils.filelist, but fixes some problems. +""" +import fnmatch +import logging +import os +import re +import sys + +from . import DistlibException +from .compat import fsdecode +from .util import convert_path + + +__all__ = ['Manifest'] + +logger = logging.getLogger(__name__) + +# a \ followed by some spaces + EOL +_COLLAPSE_PATTERN = re.compile('\\\\w*\n', re.M) +_COMMENTED_LINE = re.compile('#.*?(?=\n)|\n(?=$)', re.M | re.S) + +# +# Due to the different results returned by fnmatch.translate, we need +# to do slightly different processing for Python 2.7 and 3.2 ... this needed +# to be brought in for Python 3.6 onwards. +# +_PYTHON_VERSION = sys.version_info[:2] + +class Manifest(object): + """A list of files built by on exploring the filesystem and filtered by + applying various patterns to what we find there. + """ + + def __init__(self, base=None): + """ + Initialise an instance. + + :param base: The base directory to explore under. + """ + self.base = os.path.abspath(os.path.normpath(base or os.getcwd())) + self.prefix = self.base + os.sep + self.allfiles = None + self.files = set() + + # + # Public API + # + + def findall(self): + """Find all files under the base and set ``allfiles`` to the absolute + pathnames of files found. + """ + from stat import S_ISREG, S_ISDIR, S_ISLNK + + self.allfiles = allfiles = [] + root = self.base + stack = [root] + pop = stack.pop + push = stack.append + + while stack: + root = pop() + names = os.listdir(root) + + for name in names: + fullname = os.path.join(root, name) + + # Avoid excess stat calls -- just one will do, thank you! + stat = os.stat(fullname) + mode = stat.st_mode + if S_ISREG(mode): + allfiles.append(fsdecode(fullname)) + elif S_ISDIR(mode) and not S_ISLNK(mode): + push(fullname) + + def add(self, item): + """ + Add a file to the manifest. + + :param item: The pathname to add. This can be relative to the base. + """ + if not item.startswith(self.prefix): + item = os.path.join(self.base, item) + self.files.add(os.path.normpath(item)) + + def add_many(self, items): + """ + Add a list of files to the manifest. + + :param items: The pathnames to add. These can be relative to the base. + """ + for item in items: + self.add(item) + + def sorted(self, wantdirs=False): + """ + Return sorted files in directory order + """ + + def add_dir(dirs, d): + dirs.add(d) + logger.debug('add_dir added %s', d) + if d != self.base: + parent, _ = os.path.split(d) + assert parent not in ('', '/') + add_dir(dirs, parent) + + result = set(self.files) # make a copy! + if wantdirs: + dirs = set() + for f in result: + add_dir(dirs, os.path.dirname(f)) + result |= dirs + return [os.path.join(*path_tuple) for path_tuple in + sorted(os.path.split(path) for path in result)] + + def clear(self): + """Clear all collected files.""" + self.files = set() + self.allfiles = [] + + def process_directive(self, directive): + """ + Process a directive which either adds some files from ``allfiles`` to + ``files``, or removes some files from ``files``. + + :param directive: The directive to process. This should be in a format + compatible with distutils ``MANIFEST.in`` files: + + http://docs.python.org/distutils/sourcedist.html#commands + """ + # Parse the line: split it up, make sure the right number of words + # is there, and return the relevant words. 'action' is always + # defined: it's the first word of the line. Which of the other + # three are defined depends on the action; it'll be either + # patterns, (dir and patterns), or (dirpattern). + action, patterns, thedir, dirpattern = self._parse_directive(directive) + + # OK, now we know that the action is valid and we have the + # right number of words on the line for that action -- so we + # can proceed with minimal error-checking. + if action == 'include': + for pattern in patterns: + if not self._include_pattern(pattern, anchor=True): + logger.warning('no files found matching %r', pattern) + + elif action == 'exclude': + for pattern in patterns: + found = self._exclude_pattern(pattern, anchor=True) + #if not found: + # logger.warning('no previously-included files ' + # 'found matching %r', pattern) + + elif action == 'global-include': + for pattern in patterns: + if not self._include_pattern(pattern, anchor=False): + logger.warning('no files found matching %r ' + 'anywhere in distribution', pattern) + + elif action == 'global-exclude': + for pattern in patterns: + found = self._exclude_pattern(pattern, anchor=False) + #if not found: + # logger.warning('no previously-included files ' + # 'matching %r found anywhere in ' + # 'distribution', pattern) + + elif action == 'recursive-include': + for pattern in patterns: + if not self._include_pattern(pattern, prefix=thedir): + logger.warning('no files found matching %r ' + 'under directory %r', pattern, thedir) + + elif action == 'recursive-exclude': + for pattern in patterns: + found = self._exclude_pattern(pattern, prefix=thedir) + #if not found: + # logger.warning('no previously-included files ' + # 'matching %r found under directory %r', + # pattern, thedir) + + elif action == 'graft': + if not self._include_pattern(None, prefix=dirpattern): + logger.warning('no directories found matching %r', + dirpattern) + + elif action == 'prune': + if not self._exclude_pattern(None, prefix=dirpattern): + logger.warning('no previously-included directories found ' + 'matching %r', dirpattern) + else: # pragma: no cover + # This should never happen, as it should be caught in + # _parse_template_line + raise DistlibException( + 'invalid action %r' % action) + + # + # Private API + # + + def _parse_directive(self, directive): + """ + Validate a directive. + :param directive: The directive to validate. + :return: A tuple of action, patterns, thedir, dir_patterns + """ + words = directive.split() + if len(words) == 1 and words[0] not in ('include', 'exclude', + 'global-include', + 'global-exclude', + 'recursive-include', + 'recursive-exclude', + 'graft', 'prune'): + # no action given, let's use the default 'include' + words.insert(0, 'include') + + action = words[0] + patterns = thedir = dir_pattern = None + + if action in ('include', 'exclude', + 'global-include', 'global-exclude'): + if len(words) < 2: + raise DistlibException( + '%r expects ...' % action) + + patterns = [convert_path(word) for word in words[1:]] + + elif action in ('recursive-include', 'recursive-exclude'): + if len(words) < 3: + raise DistlibException( + '%r expects ...' % action) + + thedir = convert_path(words[1]) + patterns = [convert_path(word) for word in words[2:]] + + elif action in ('graft', 'prune'): + if len(words) != 2: + raise DistlibException( + '%r expects a single ' % action) + + dir_pattern = convert_path(words[1]) + + else: + raise DistlibException('unknown action %r' % action) + + return action, patterns, thedir, dir_pattern + + def _include_pattern(self, pattern, anchor=True, prefix=None, + is_regex=False): + """Select strings (presumably filenames) from 'self.files' that + match 'pattern', a Unix-style wildcard (glob) pattern. + + Patterns are not quite the same as implemented by the 'fnmatch' + module: '*' and '?' match non-special characters, where "special" + is platform-dependent: slash on Unix; colon, slash, and backslash on + DOS/Windows; and colon on Mac OS. + + If 'anchor' is true (the default), then the pattern match is more + stringent: "*.py" will match "foo.py" but not "foo/bar.py". If + 'anchor' is false, both of these will match. + + If 'prefix' is supplied, then only filenames starting with 'prefix' + (itself a pattern) and ending with 'pattern', with anything in between + them, will match. 'anchor' is ignored in this case. + + If 'is_regex' is true, 'anchor' and 'prefix' are ignored, and + 'pattern' is assumed to be either a string containing a regex or a + regex object -- no translation is done, the regex is just compiled + and used as-is. + + Selected strings will be added to self.files. + + Return True if files are found. + """ + # XXX docstring lying about what the special chars are? + found = False + pattern_re = self._translate_pattern(pattern, anchor, prefix, is_regex) + + # delayed loading of allfiles list + if self.allfiles is None: + self.findall() + + for name in self.allfiles: + if pattern_re.search(name): + self.files.add(name) + found = True + return found + + def _exclude_pattern(self, pattern, anchor=True, prefix=None, + is_regex=False): + """Remove strings (presumably filenames) from 'files' that match + 'pattern'. + + Other parameters are the same as for 'include_pattern()', above. + The list 'self.files' is modified in place. Return True if files are + found. + + This API is public to allow e.g. exclusion of SCM subdirs, e.g. when + packaging source distributions + """ + found = False + pattern_re = self._translate_pattern(pattern, anchor, prefix, is_regex) + for f in list(self.files): + if pattern_re.search(f): + self.files.remove(f) + found = True + return found + + def _translate_pattern(self, pattern, anchor=True, prefix=None, + is_regex=False): + """Translate a shell-like wildcard pattern to a compiled regular + expression. + + Return the compiled regex. If 'is_regex' true, + then 'pattern' is directly compiled to a regex (if it's a string) + or just returned as-is (assumes it's a regex object). + """ + if is_regex: + if isinstance(pattern, str): + return re.compile(pattern) + else: + return pattern + + if _PYTHON_VERSION > (3, 2): + # ditch start and end characters + start, _, end = self._glob_to_re('_').partition('_') + + if pattern: + pattern_re = self._glob_to_re(pattern) + if _PYTHON_VERSION > (3, 2): + assert pattern_re.startswith(start) and pattern_re.endswith(end) + else: + pattern_re = '' + + base = re.escape(os.path.join(self.base, '')) + if prefix is not None: + # ditch end of pattern character + if _PYTHON_VERSION <= (3, 2): + empty_pattern = self._glob_to_re('') + prefix_re = self._glob_to_re(prefix)[:-len(empty_pattern)] + else: + prefix_re = self._glob_to_re(prefix) + assert prefix_re.startswith(start) and prefix_re.endswith(end) + prefix_re = prefix_re[len(start): len(prefix_re) - len(end)] + sep = os.sep + if os.sep == '\\': + sep = r'\\' + if _PYTHON_VERSION <= (3, 2): + pattern_re = '^' + base + sep.join((prefix_re, + '.*' + pattern_re)) + else: + pattern_re = pattern_re[len(start): len(pattern_re) - len(end)] + pattern_re = r'%s%s%s%s.*%s%s' % (start, base, prefix_re, sep, + pattern_re, end) + else: # no prefix -- respect anchor flag + if anchor: + if _PYTHON_VERSION <= (3, 2): + pattern_re = '^' + base + pattern_re + else: + pattern_re = r'%s%s%s' % (start, base, pattern_re[len(start):]) + + return re.compile(pattern_re) + + def _glob_to_re(self, pattern): + """Translate a shell-like glob pattern to a regular expression. + + Return a string containing the regex. Differs from + 'fnmatch.translate()' in that '*' does not match "special characters" + (which are platform-specific). + """ + pattern_re = fnmatch.translate(pattern) + + # '?' and '*' in the glob pattern become '.' and '.*' in the RE, which + # IMHO is wrong -- '?' and '*' aren't supposed to match slash in Unix, + # and by extension they shouldn't match such "special characters" under + # any OS. So change all non-escaped dots in the RE to match any + # character except the special characters (currently: just os.sep). + sep = os.sep + if os.sep == '\\': + # we're using a regex to manipulate a regex, so we need + # to escape the backslash twice + sep = r'\\\\' + escaped = r'\1[^%s]' % sep + pattern_re = re.sub(r'((? y, + '!=': lambda x, y: x != y, + '<': lambda x, y: x < y, + '<=': lambda x, y: x == y or x < y, + '>': lambda x, y: x > y, + '>=': lambda x, y: x == y or x > y, + 'and': lambda x, y: x and y, + 'or': lambda x, y: x or y, + 'in': lambda x, y: x in y, + 'not in': lambda x, y: x not in y, + } + + def evaluate(self, expr, context): + """ + Evaluate a marker expression returned by the :func:`parse_requirement` + function in the specified context. + """ + if isinstance(expr, string_types): + if expr[0] in '\'"': + result = expr[1:-1] + else: + if expr not in context: + raise SyntaxError('unknown variable: %s' % expr) + result = context[expr] + else: + assert isinstance(expr, dict) + op = expr['op'] + if op not in self.operations: + raise NotImplementedError('op not implemented: %s' % op) + elhs = expr['lhs'] + erhs = expr['rhs'] + if _is_literal(expr['lhs']) and _is_literal(expr['rhs']): + raise SyntaxError('invalid comparison: %s %s %s' % (elhs, op, erhs)) + + lhs = self.evaluate(elhs, context) + rhs = self.evaluate(erhs, context) + result = self.operations[op](lhs, rhs) + return result + +def default_context(): + def format_full_version(info): + version = '%s.%s.%s' % (info.major, info.minor, info.micro) + kind = info.releaselevel + if kind != 'final': + version += kind[0] + str(info.serial) + return version + + if hasattr(sys, 'implementation'): + implementation_version = format_full_version(sys.implementation.version) + implementation_name = sys.implementation.name + else: + implementation_version = '0' + implementation_name = '' + + result = { + 'implementation_name': implementation_name, + 'implementation_version': implementation_version, + 'os_name': os.name, + 'platform_machine': platform.machine(), + 'platform_python_implementation': platform.python_implementation(), + 'platform_release': platform.release(), + 'platform_system': platform.system(), + 'platform_version': platform.version(), + 'platform_in_venv': str(in_venv()), + 'python_full_version': platform.python_version(), + 'python_version': platform.python_version()[:3], + 'sys_platform': sys.platform, + } + return result + +DEFAULT_CONTEXT = default_context() +del default_context + +evaluator = Evaluator() + +def interpret(marker, execution_context=None): + """ + Interpret a marker and return a result depending on environment. + + :param marker: The marker to interpret. + :type marker: str + :param execution_context: The context used for name lookup. + :type execution_context: mapping + """ + try: + expr, rest = parse_marker(marker) + except Exception as e: + raise SyntaxError('Unable to interpret marker syntax: %s: %s' % (marker, e)) + if rest and rest[0] != '#': + raise SyntaxError('unexpected trailing data in marker: %s: %s' % (marker, rest)) + context = dict(DEFAULT_CONTEXT) + if execution_context: + context.update(execution_context) + return evaluator.evaluate(expr, context) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/metadata.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/metadata.py new file mode 100644 index 0000000000000000000000000000000000000000..2d61378e9942fb67c15544db57bac502fa50376b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/metadata.py @@ -0,0 +1,1096 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2012 The Python Software Foundation. +# See LICENSE.txt and CONTRIBUTORS.txt. +# +"""Implementation of the Metadata for Python packages PEPs. + +Supports all metadata formats (1.0, 1.1, 1.2, and 2.0 experimental). +""" +from __future__ import unicode_literals + +import codecs +from email import message_from_file +import json +import logging +import re + + +from . import DistlibException, __version__ +from .compat import StringIO, string_types, text_type +from .markers import interpret +from .util import extract_by_key, get_extras +from .version import get_scheme, PEP440_VERSION_RE + +logger = logging.getLogger(__name__) + + +class MetadataMissingError(DistlibException): + """A required metadata is missing""" + + +class MetadataConflictError(DistlibException): + """Attempt to read or write metadata fields that are conflictual.""" + + +class MetadataUnrecognizedVersionError(DistlibException): + """Unknown metadata version number.""" + + +class MetadataInvalidError(DistlibException): + """A metadata value is invalid""" + +# public API of this module +__all__ = ['Metadata', 'PKG_INFO_ENCODING', 'PKG_INFO_PREFERRED_VERSION'] + +# Encoding used for the PKG-INFO files +PKG_INFO_ENCODING = 'utf-8' + +# preferred version. Hopefully will be changed +# to 1.2 once PEP 345 is supported everywhere +PKG_INFO_PREFERRED_VERSION = '1.1' + +_LINE_PREFIX_1_2 = re.compile('\n \\|') +_LINE_PREFIX_PRE_1_2 = re.compile('\n ') +_241_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform', + 'Summary', 'Description', + 'Keywords', 'Home-page', 'Author', 'Author-email', + 'License') + +_314_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform', + 'Supported-Platform', 'Summary', 'Description', + 'Keywords', 'Home-page', 'Author', 'Author-email', + 'License', 'Classifier', 'Download-URL', 'Obsoletes', + 'Provides', 'Requires') + +_314_MARKERS = ('Obsoletes', 'Provides', 'Requires', 'Classifier', + 'Download-URL') + +_345_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform', + 'Supported-Platform', 'Summary', 'Description', + 'Keywords', 'Home-page', 'Author', 'Author-email', + 'Maintainer', 'Maintainer-email', 'License', + 'Classifier', 'Download-URL', 'Obsoletes-Dist', + 'Project-URL', 'Provides-Dist', 'Requires-Dist', + 'Requires-Python', 'Requires-External') + +_345_MARKERS = ('Provides-Dist', 'Requires-Dist', 'Requires-Python', + 'Obsoletes-Dist', 'Requires-External', 'Maintainer', + 'Maintainer-email', 'Project-URL') + +_426_FIELDS = ('Metadata-Version', 'Name', 'Version', 'Platform', + 'Supported-Platform', 'Summary', 'Description', + 'Keywords', 'Home-page', 'Author', 'Author-email', + 'Maintainer', 'Maintainer-email', 'License', + 'Classifier', 'Download-URL', 'Obsoletes-Dist', + 'Project-URL', 'Provides-Dist', 'Requires-Dist', + 'Requires-Python', 'Requires-External', 'Private-Version', + 'Obsoleted-By', 'Setup-Requires-Dist', 'Extension', + 'Provides-Extra') + +_426_MARKERS = ('Private-Version', 'Provides-Extra', 'Obsoleted-By', + 'Setup-Requires-Dist', 'Extension') + +# See issue #106: Sometimes 'Requires' and 'Provides' occur wrongly in +# the metadata. Include them in the tuple literal below to allow them +# (for now). +_566_FIELDS = _426_FIELDS + ('Description-Content-Type', + 'Requires', 'Provides') + +_566_MARKERS = ('Description-Content-Type',) + +_ALL_FIELDS = set() +_ALL_FIELDS.update(_241_FIELDS) +_ALL_FIELDS.update(_314_FIELDS) +_ALL_FIELDS.update(_345_FIELDS) +_ALL_FIELDS.update(_426_FIELDS) +_ALL_FIELDS.update(_566_FIELDS) + +EXTRA_RE = re.compile(r'''extra\s*==\s*("([^"]+)"|'([^']+)')''') + + +def _version2fieldlist(version): + if version == '1.0': + return _241_FIELDS + elif version == '1.1': + return _314_FIELDS + elif version == '1.2': + return _345_FIELDS + elif version in ('1.3', '2.1'): + return _345_FIELDS + _566_FIELDS + elif version == '2.0': + return _426_FIELDS + raise MetadataUnrecognizedVersionError(version) + + +def _best_version(fields): + """Detect the best version depending on the fields used.""" + def _has_marker(keys, markers): + for marker in markers: + if marker in keys: + return True + return False + + keys = [] + for key, value in fields.items(): + if value in ([], 'UNKNOWN', None): + continue + keys.append(key) + + possible_versions = ['1.0', '1.1', '1.2', '1.3', '2.0', '2.1'] + + # first let's try to see if a field is not part of one of the version + for key in keys: + if key not in _241_FIELDS and '1.0' in possible_versions: + possible_versions.remove('1.0') + logger.debug('Removed 1.0 due to %s', key) + if key not in _314_FIELDS and '1.1' in possible_versions: + possible_versions.remove('1.1') + logger.debug('Removed 1.1 due to %s', key) + if key not in _345_FIELDS and '1.2' in possible_versions: + possible_versions.remove('1.2') + logger.debug('Removed 1.2 due to %s', key) + if key not in _566_FIELDS and '1.3' in possible_versions: + possible_versions.remove('1.3') + logger.debug('Removed 1.3 due to %s', key) + if key not in _566_FIELDS and '2.1' in possible_versions: + if key != 'Description': # In 2.1, description allowed after headers + possible_versions.remove('2.1') + logger.debug('Removed 2.1 due to %s', key) + if key not in _426_FIELDS and '2.0' in possible_versions: + possible_versions.remove('2.0') + logger.debug('Removed 2.0 due to %s', key) + + # possible_version contains qualified versions + if len(possible_versions) == 1: + return possible_versions[0] # found ! + elif len(possible_versions) == 0: + logger.debug('Out of options - unknown metadata set: %s', fields) + raise MetadataConflictError('Unknown metadata set') + + # let's see if one unique marker is found + is_1_1 = '1.1' in possible_versions and _has_marker(keys, _314_MARKERS) + is_1_2 = '1.2' in possible_versions and _has_marker(keys, _345_MARKERS) + is_2_1 = '2.1' in possible_versions and _has_marker(keys, _566_MARKERS) + is_2_0 = '2.0' in possible_versions and _has_marker(keys, _426_MARKERS) + if int(is_1_1) + int(is_1_2) + int(is_2_1) + int(is_2_0) > 1: + raise MetadataConflictError('You used incompatible 1.1/1.2/2.0/2.1 fields') + + # we have the choice, 1.0, or 1.2, or 2.0 + # - 1.0 has a broken Summary field but works with all tools + # - 1.1 is to avoid + # - 1.2 fixes Summary but has little adoption + # - 2.0 adds more features and is very new + if not is_1_1 and not is_1_2 and not is_2_1 and not is_2_0: + # we couldn't find any specific marker + if PKG_INFO_PREFERRED_VERSION in possible_versions: + return PKG_INFO_PREFERRED_VERSION + if is_1_1: + return '1.1' + if is_1_2: + return '1.2' + if is_2_1: + return '2.1' + + return '2.0' + +_ATTR2FIELD = { + 'metadata_version': 'Metadata-Version', + 'name': 'Name', + 'version': 'Version', + 'platform': 'Platform', + 'supported_platform': 'Supported-Platform', + 'summary': 'Summary', + 'description': 'Description', + 'keywords': 'Keywords', + 'home_page': 'Home-page', + 'author': 'Author', + 'author_email': 'Author-email', + 'maintainer': 'Maintainer', + 'maintainer_email': 'Maintainer-email', + 'license': 'License', + 'classifier': 'Classifier', + 'download_url': 'Download-URL', + 'obsoletes_dist': 'Obsoletes-Dist', + 'provides_dist': 'Provides-Dist', + 'requires_dist': 'Requires-Dist', + 'setup_requires_dist': 'Setup-Requires-Dist', + 'requires_python': 'Requires-Python', + 'requires_external': 'Requires-External', + 'requires': 'Requires', + 'provides': 'Provides', + 'obsoletes': 'Obsoletes', + 'project_url': 'Project-URL', + 'private_version': 'Private-Version', + 'obsoleted_by': 'Obsoleted-By', + 'extension': 'Extension', + 'provides_extra': 'Provides-Extra', +} + +_PREDICATE_FIELDS = ('Requires-Dist', 'Obsoletes-Dist', 'Provides-Dist') +_VERSIONS_FIELDS = ('Requires-Python',) +_VERSION_FIELDS = ('Version',) +_LISTFIELDS = ('Platform', 'Classifier', 'Obsoletes', + 'Requires', 'Provides', 'Obsoletes-Dist', + 'Provides-Dist', 'Requires-Dist', 'Requires-External', + 'Project-URL', 'Supported-Platform', 'Setup-Requires-Dist', + 'Provides-Extra', 'Extension') +_LISTTUPLEFIELDS = ('Project-URL',) + +_ELEMENTSFIELD = ('Keywords',) + +_UNICODEFIELDS = ('Author', 'Maintainer', 'Summary', 'Description') + +_MISSING = object() + +_FILESAFE = re.compile('[^A-Za-z0-9.]+') + + +def _get_name_and_version(name, version, for_filename=False): + """Return the distribution name with version. + + If for_filename is true, return a filename-escaped form.""" + if for_filename: + # For both name and version any runs of non-alphanumeric or '.' + # characters are replaced with a single '-'. Additionally any + # spaces in the version string become '.' + name = _FILESAFE.sub('-', name) + version = _FILESAFE.sub('-', version.replace(' ', '.')) + return '%s-%s' % (name, version) + + +class LegacyMetadata(object): + """The legacy metadata of a release. + + Supports versions 1.0, 1.1 and 1.2 (auto-detected). You can + instantiate the class with one of these arguments (or none): + - *path*, the path to a metadata file + - *fileobj* give a file-like object with metadata as content + - *mapping* is a dict-like object + - *scheme* is a version scheme name + """ + # TODO document the mapping API and UNKNOWN default key + + def __init__(self, path=None, fileobj=None, mapping=None, + scheme='default'): + if [path, fileobj, mapping].count(None) < 2: + raise TypeError('path, fileobj and mapping are exclusive') + self._fields = {} + self.requires_files = [] + self._dependencies = None + self.scheme = scheme + if path is not None: + self.read(path) + elif fileobj is not None: + self.read_file(fileobj) + elif mapping is not None: + self.update(mapping) + self.set_metadata_version() + + def set_metadata_version(self): + self._fields['Metadata-Version'] = _best_version(self._fields) + + def _write_field(self, fileobj, name, value): + fileobj.write('%s: %s\n' % (name, value)) + + def __getitem__(self, name): + return self.get(name) + + def __setitem__(self, name, value): + return self.set(name, value) + + def __delitem__(self, name): + field_name = self._convert_name(name) + try: + del self._fields[field_name] + except KeyError: + raise KeyError(name) + + def __contains__(self, name): + return (name in self._fields or + self._convert_name(name) in self._fields) + + def _convert_name(self, name): + if name in _ALL_FIELDS: + return name + name = name.replace('-', '_').lower() + return _ATTR2FIELD.get(name, name) + + def _default_value(self, name): + if name in _LISTFIELDS or name in _ELEMENTSFIELD: + return [] + return 'UNKNOWN' + + def _remove_line_prefix(self, value): + if self.metadata_version in ('1.0', '1.1'): + return _LINE_PREFIX_PRE_1_2.sub('\n', value) + else: + return _LINE_PREFIX_1_2.sub('\n', value) + + def __getattr__(self, name): + if name in _ATTR2FIELD: + return self[name] + raise AttributeError(name) + + # + # Public API + # + +# dependencies = property(_get_dependencies, _set_dependencies) + + def get_fullname(self, filesafe=False): + """Return the distribution name with version. + + If filesafe is true, return a filename-escaped form.""" + return _get_name_and_version(self['Name'], self['Version'], filesafe) + + def is_field(self, name): + """return True if name is a valid metadata key""" + name = self._convert_name(name) + return name in _ALL_FIELDS + + def is_multi_field(self, name): + name = self._convert_name(name) + return name in _LISTFIELDS + + def read(self, filepath): + """Read the metadata values from a file path.""" + fp = codecs.open(filepath, 'r', encoding='utf-8') + try: + self.read_file(fp) + finally: + fp.close() + + def read_file(self, fileob): + """Read the metadata values from a file object.""" + msg = message_from_file(fileob) + self._fields['Metadata-Version'] = msg['metadata-version'] + + # When reading, get all the fields we can + for field in _ALL_FIELDS: + if field not in msg: + continue + if field in _LISTFIELDS: + # we can have multiple lines + values = msg.get_all(field) + if field in _LISTTUPLEFIELDS and values is not None: + values = [tuple(value.split(',')) for value in values] + self.set(field, values) + else: + # single line + value = msg[field] + if value is not None and value != 'UNKNOWN': + self.set(field, value) + # logger.debug('Attempting to set metadata for %s', self) + # self.set_metadata_version() + + def write(self, filepath, skip_unknown=False): + """Write the metadata fields to filepath.""" + fp = codecs.open(filepath, 'w', encoding='utf-8') + try: + self.write_file(fp, skip_unknown) + finally: + fp.close() + + def write_file(self, fileobject, skip_unknown=False): + """Write the PKG-INFO format data to a file object.""" + self.set_metadata_version() + + for field in _version2fieldlist(self['Metadata-Version']): + values = self.get(field) + if skip_unknown and values in ('UNKNOWN', [], ['UNKNOWN']): + continue + if field in _ELEMENTSFIELD: + self._write_field(fileobject, field, ','.join(values)) + continue + if field not in _LISTFIELDS: + if field == 'Description': + if self.metadata_version in ('1.0', '1.1'): + values = values.replace('\n', '\n ') + else: + values = values.replace('\n', '\n |') + values = [values] + + if field in _LISTTUPLEFIELDS: + values = [','.join(value) for value in values] + + for value in values: + self._write_field(fileobject, field, value) + + def update(self, other=None, **kwargs): + """Set metadata values from the given iterable `other` and kwargs. + + Behavior is like `dict.update`: If `other` has a ``keys`` method, + they are looped over and ``self[key]`` is assigned ``other[key]``. + Else, ``other`` is an iterable of ``(key, value)`` iterables. + + Keys that don't match a metadata field or that have an empty value are + dropped. + """ + def _set(key, value): + if key in _ATTR2FIELD and value: + self.set(self._convert_name(key), value) + + if not other: + # other is None or empty container + pass + elif hasattr(other, 'keys'): + for k in other.keys(): + _set(k, other[k]) + else: + for k, v in other: + _set(k, v) + + if kwargs: + for k, v in kwargs.items(): + _set(k, v) + + def set(self, name, value): + """Control then set a metadata field.""" + name = self._convert_name(name) + + if ((name in _ELEMENTSFIELD or name == 'Platform') and + not isinstance(value, (list, tuple))): + if isinstance(value, string_types): + value = [v.strip() for v in value.split(',')] + else: + value = [] + elif (name in _LISTFIELDS and + not isinstance(value, (list, tuple))): + if isinstance(value, string_types): + value = [value] + else: + value = [] + + if logger.isEnabledFor(logging.WARNING): + project_name = self['Name'] + + scheme = get_scheme(self.scheme) + if name in _PREDICATE_FIELDS and value is not None: + for v in value: + # check that the values are valid + if not scheme.is_valid_matcher(v.split(';')[0]): + logger.warning( + "'%s': '%s' is not valid (field '%s')", + project_name, v, name) + # FIXME this rejects UNKNOWN, is that right? + elif name in _VERSIONS_FIELDS and value is not None: + if not scheme.is_valid_constraint_list(value): + logger.warning("'%s': '%s' is not a valid version (field '%s')", + project_name, value, name) + elif name in _VERSION_FIELDS and value is not None: + if not scheme.is_valid_version(value): + logger.warning("'%s': '%s' is not a valid version (field '%s')", + project_name, value, name) + + if name in _UNICODEFIELDS: + if name == 'Description': + value = self._remove_line_prefix(value) + + self._fields[name] = value + + def get(self, name, default=_MISSING): + """Get a metadata field.""" + name = self._convert_name(name) + if name not in self._fields: + if default is _MISSING: + default = self._default_value(name) + return default + if name in _UNICODEFIELDS: + value = self._fields[name] + return value + elif name in _LISTFIELDS: + value = self._fields[name] + if value is None: + return [] + res = [] + for val in value: + if name not in _LISTTUPLEFIELDS: + res.append(val) + else: + # That's for Project-URL + res.append((val[0], val[1])) + return res + + elif name in _ELEMENTSFIELD: + value = self._fields[name] + if isinstance(value, string_types): + return value.split(',') + return self._fields[name] + + def check(self, strict=False): + """Check if the metadata is compliant. If strict is True then raise if + no Name or Version are provided""" + self.set_metadata_version() + + # XXX should check the versions (if the file was loaded) + missing, warnings = [], [] + + for attr in ('Name', 'Version'): # required by PEP 345 + if attr not in self: + missing.append(attr) + + if strict and missing != []: + msg = 'missing required metadata: %s' % ', '.join(missing) + raise MetadataMissingError(msg) + + for attr in ('Home-page', 'Author'): + if attr not in self: + missing.append(attr) + + # checking metadata 1.2 (XXX needs to check 1.1, 1.0) + if self['Metadata-Version'] != '1.2': + return missing, warnings + + scheme = get_scheme(self.scheme) + + def are_valid_constraints(value): + for v in value: + if not scheme.is_valid_matcher(v.split(';')[0]): + return False + return True + + for fields, controller in ((_PREDICATE_FIELDS, are_valid_constraints), + (_VERSIONS_FIELDS, + scheme.is_valid_constraint_list), + (_VERSION_FIELDS, + scheme.is_valid_version)): + for field in fields: + value = self.get(field, None) + if value is not None and not controller(value): + warnings.append("Wrong value for '%s': %s" % (field, value)) + + return missing, warnings + + def todict(self, skip_missing=False): + """Return fields as a dict. + + Field names will be converted to use the underscore-lowercase style + instead of hyphen-mixed case (i.e. home_page instead of Home-page). + """ + self.set_metadata_version() + + mapping_1_0 = ( + ('metadata_version', 'Metadata-Version'), + ('name', 'Name'), + ('version', 'Version'), + ('summary', 'Summary'), + ('home_page', 'Home-page'), + ('author', 'Author'), + ('author_email', 'Author-email'), + ('license', 'License'), + ('description', 'Description'), + ('keywords', 'Keywords'), + ('platform', 'Platform'), + ('classifiers', 'Classifier'), + ('download_url', 'Download-URL'), + ) + + data = {} + for key, field_name in mapping_1_0: + if not skip_missing or field_name in self._fields: + data[key] = self[field_name] + + if self['Metadata-Version'] == '1.2': + mapping_1_2 = ( + ('requires_dist', 'Requires-Dist'), + ('requires_python', 'Requires-Python'), + ('requires_external', 'Requires-External'), + ('provides_dist', 'Provides-Dist'), + ('obsoletes_dist', 'Obsoletes-Dist'), + ('project_url', 'Project-URL'), + ('maintainer', 'Maintainer'), + ('maintainer_email', 'Maintainer-email'), + ) + for key, field_name in mapping_1_2: + if not skip_missing or field_name in self._fields: + if key != 'project_url': + data[key] = self[field_name] + else: + data[key] = [','.join(u) for u in self[field_name]] + + elif self['Metadata-Version'] == '1.1': + mapping_1_1 = ( + ('provides', 'Provides'), + ('requires', 'Requires'), + ('obsoletes', 'Obsoletes'), + ) + for key, field_name in mapping_1_1: + if not skip_missing or field_name in self._fields: + data[key] = self[field_name] + + return data + + def add_requirements(self, requirements): + if self['Metadata-Version'] == '1.1': + # we can't have 1.1 metadata *and* Setuptools requires + for field in ('Obsoletes', 'Requires', 'Provides'): + if field in self: + del self[field] + self['Requires-Dist'] += requirements + + # Mapping API + # TODO could add iter* variants + + def keys(self): + return list(_version2fieldlist(self['Metadata-Version'])) + + def __iter__(self): + for key in self.keys(): + yield key + + def values(self): + return [self[key] for key in self.keys()] + + def items(self): + return [(key, self[key]) for key in self.keys()] + + def __repr__(self): + return '<%s %s %s>' % (self.__class__.__name__, self.name, + self.version) + + +METADATA_FILENAME = 'pydist.json' +WHEEL_METADATA_FILENAME = 'metadata.json' +LEGACY_METADATA_FILENAME = 'METADATA' + + +class Metadata(object): + """ + The metadata of a release. This implementation uses 2.0 (JSON) + metadata where possible. If not possible, it wraps a LegacyMetadata + instance which handles the key-value metadata format. + """ + + METADATA_VERSION_MATCHER = re.compile(r'^\d+(\.\d+)*$') + + NAME_MATCHER = re.compile('^[0-9A-Z]([0-9A-Z_.-]*[0-9A-Z])?$', re.I) + + VERSION_MATCHER = PEP440_VERSION_RE + + SUMMARY_MATCHER = re.compile('.{1,2047}') + + METADATA_VERSION = '2.0' + + GENERATOR = 'distlib (%s)' % __version__ + + MANDATORY_KEYS = { + 'name': (), + 'version': (), + 'summary': ('legacy',), + } + + INDEX_KEYS = ('name version license summary description author ' + 'author_email keywords platform home_page classifiers ' + 'download_url') + + DEPENDENCY_KEYS = ('extras run_requires test_requires build_requires ' + 'dev_requires provides meta_requires obsoleted_by ' + 'supports_environments') + + SYNTAX_VALIDATORS = { + 'metadata_version': (METADATA_VERSION_MATCHER, ()), + 'name': (NAME_MATCHER, ('legacy',)), + 'version': (VERSION_MATCHER, ('legacy',)), + 'summary': (SUMMARY_MATCHER, ('legacy',)), + } + + __slots__ = ('_legacy', '_data', 'scheme') + + def __init__(self, path=None, fileobj=None, mapping=None, + scheme='default'): + if [path, fileobj, mapping].count(None) < 2: + raise TypeError('path, fileobj and mapping are exclusive') + self._legacy = None + self._data = None + self.scheme = scheme + #import pdb; pdb.set_trace() + if mapping is not None: + try: + self._validate_mapping(mapping, scheme) + self._data = mapping + except MetadataUnrecognizedVersionError: + self._legacy = LegacyMetadata(mapping=mapping, scheme=scheme) + self.validate() + else: + data = None + if path: + with open(path, 'rb') as f: + data = f.read() + elif fileobj: + data = fileobj.read() + if data is None: + # Initialised with no args - to be added + self._data = { + 'metadata_version': self.METADATA_VERSION, + 'generator': self.GENERATOR, + } + else: + if not isinstance(data, text_type): + data = data.decode('utf-8') + try: + self._data = json.loads(data) + self._validate_mapping(self._data, scheme) + except ValueError: + # Note: MetadataUnrecognizedVersionError does not + # inherit from ValueError (it's a DistlibException, + # which should not inherit from ValueError). + # The ValueError comes from the json.load - if that + # succeeds and we get a validation error, we want + # that to propagate + self._legacy = LegacyMetadata(fileobj=StringIO(data), + scheme=scheme) + self.validate() + + common_keys = set(('name', 'version', 'license', 'keywords', 'summary')) + + none_list = (None, list) + none_dict = (None, dict) + + mapped_keys = { + 'run_requires': ('Requires-Dist', list), + 'build_requires': ('Setup-Requires-Dist', list), + 'dev_requires': none_list, + 'test_requires': none_list, + 'meta_requires': none_list, + 'extras': ('Provides-Extra', list), + 'modules': none_list, + 'namespaces': none_list, + 'exports': none_dict, + 'commands': none_dict, + 'classifiers': ('Classifier', list), + 'source_url': ('Download-URL', None), + 'metadata_version': ('Metadata-Version', None), + } + + del none_list, none_dict + + def __getattribute__(self, key): + common = object.__getattribute__(self, 'common_keys') + mapped = object.__getattribute__(self, 'mapped_keys') + if key in mapped: + lk, maker = mapped[key] + if self._legacy: + if lk is None: + result = None if maker is None else maker() + else: + result = self._legacy.get(lk) + else: + value = None if maker is None else maker() + if key not in ('commands', 'exports', 'modules', 'namespaces', + 'classifiers'): + result = self._data.get(key, value) + else: + # special cases for PEP 459 + sentinel = object() + result = sentinel + d = self._data.get('extensions') + if d: + if key == 'commands': + result = d.get('python.commands', value) + elif key == 'classifiers': + d = d.get('python.details') + if d: + result = d.get(key, value) + else: + d = d.get('python.exports') + if not d: + d = self._data.get('python.exports') + if d: + result = d.get(key, value) + if result is sentinel: + result = value + elif key not in common: + result = object.__getattribute__(self, key) + elif self._legacy: + result = self._legacy.get(key) + else: + result = self._data.get(key) + return result + + def _validate_value(self, key, value, scheme=None): + if key in self.SYNTAX_VALIDATORS: + pattern, exclusions = self.SYNTAX_VALIDATORS[key] + if (scheme or self.scheme) not in exclusions: + m = pattern.match(value) + if not m: + raise MetadataInvalidError("'%s' is an invalid value for " + "the '%s' property" % (value, + key)) + + def __setattr__(self, key, value): + self._validate_value(key, value) + common = object.__getattribute__(self, 'common_keys') + mapped = object.__getattribute__(self, 'mapped_keys') + if key in mapped: + lk, _ = mapped[key] + if self._legacy: + if lk is None: + raise NotImplementedError + self._legacy[lk] = value + elif key not in ('commands', 'exports', 'modules', 'namespaces', + 'classifiers'): + self._data[key] = value + else: + # special cases for PEP 459 + d = self._data.setdefault('extensions', {}) + if key == 'commands': + d['python.commands'] = value + elif key == 'classifiers': + d = d.setdefault('python.details', {}) + d[key] = value + else: + d = d.setdefault('python.exports', {}) + d[key] = value + elif key not in common: + object.__setattr__(self, key, value) + else: + if key == 'keywords': + if isinstance(value, string_types): + value = value.strip() + if value: + value = value.split() + else: + value = [] + if self._legacy: + self._legacy[key] = value + else: + self._data[key] = value + + @property + def name_and_version(self): + return _get_name_and_version(self.name, self.version, True) + + @property + def provides(self): + if self._legacy: + result = self._legacy['Provides-Dist'] + else: + result = self._data.setdefault('provides', []) + s = '%s (%s)' % (self.name, self.version) + if s not in result: + result.append(s) + return result + + @provides.setter + def provides(self, value): + if self._legacy: + self._legacy['Provides-Dist'] = value + else: + self._data['provides'] = value + + def get_requirements(self, reqts, extras=None, env=None): + """ + Base method to get dependencies, given a set of extras + to satisfy and an optional environment context. + :param reqts: A list of sometimes-wanted dependencies, + perhaps dependent on extras and environment. + :param extras: A list of optional components being requested. + :param env: An optional environment for marker evaluation. + """ + if self._legacy: + result = reqts + else: + result = [] + extras = get_extras(extras or [], self.extras) + for d in reqts: + if 'extra' not in d and 'environment' not in d: + # unconditional + include = True + else: + if 'extra' not in d: + # Not extra-dependent - only environment-dependent + include = True + else: + include = d.get('extra') in extras + if include: + # Not excluded because of extras, check environment + marker = d.get('environment') + if marker: + include = interpret(marker, env) + if include: + result.extend(d['requires']) + for key in ('build', 'dev', 'test'): + e = ':%s:' % key + if e in extras: + extras.remove(e) + # A recursive call, but it should terminate since 'test' + # has been removed from the extras + reqts = self._data.get('%s_requires' % key, []) + result.extend(self.get_requirements(reqts, extras=extras, + env=env)) + return result + + @property + def dictionary(self): + if self._legacy: + return self._from_legacy() + return self._data + + @property + def dependencies(self): + if self._legacy: + raise NotImplementedError + else: + return extract_by_key(self._data, self.DEPENDENCY_KEYS) + + @dependencies.setter + def dependencies(self, value): + if self._legacy: + raise NotImplementedError + else: + self._data.update(value) + + def _validate_mapping(self, mapping, scheme): + if mapping.get('metadata_version') != self.METADATA_VERSION: + raise MetadataUnrecognizedVersionError() + missing = [] + for key, exclusions in self.MANDATORY_KEYS.items(): + if key not in mapping: + if scheme not in exclusions: + missing.append(key) + if missing: + msg = 'Missing metadata items: %s' % ', '.join(missing) + raise MetadataMissingError(msg) + for k, v in mapping.items(): + self._validate_value(k, v, scheme) + + def validate(self): + if self._legacy: + missing, warnings = self._legacy.check(True) + if missing or warnings: + logger.warning('Metadata: missing: %s, warnings: %s', + missing, warnings) + else: + self._validate_mapping(self._data, self.scheme) + + def todict(self): + if self._legacy: + return self._legacy.todict(True) + else: + result = extract_by_key(self._data, self.INDEX_KEYS) + return result + + def _from_legacy(self): + assert self._legacy and not self._data + result = { + 'metadata_version': self.METADATA_VERSION, + 'generator': self.GENERATOR, + } + lmd = self._legacy.todict(True) # skip missing ones + for k in ('name', 'version', 'license', 'summary', 'description', + 'classifier'): + if k in lmd: + if k == 'classifier': + nk = 'classifiers' + else: + nk = k + result[nk] = lmd[k] + kw = lmd.get('Keywords', []) + if kw == ['']: + kw = [] + result['keywords'] = kw + keys = (('requires_dist', 'run_requires'), + ('setup_requires_dist', 'build_requires')) + for ok, nk in keys: + if ok in lmd and lmd[ok]: + result[nk] = [{'requires': lmd[ok]}] + result['provides'] = self.provides + author = {} + maintainer = {} + return result + + LEGACY_MAPPING = { + 'name': 'Name', + 'version': 'Version', + 'license': 'License', + 'summary': 'Summary', + 'description': 'Description', + 'classifiers': 'Classifier', + } + + def _to_legacy(self): + def process_entries(entries): + reqts = set() + for e in entries: + extra = e.get('extra') + env = e.get('environment') + rlist = e['requires'] + for r in rlist: + if not env and not extra: + reqts.add(r) + else: + marker = '' + if extra: + marker = 'extra == "%s"' % extra + if env: + if marker: + marker = '(%s) and %s' % (env, marker) + else: + marker = env + reqts.add(';'.join((r, marker))) + return reqts + + assert self._data and not self._legacy + result = LegacyMetadata() + nmd = self._data + for nk, ok in self.LEGACY_MAPPING.items(): + if nk in nmd: + result[ok] = nmd[nk] + r1 = process_entries(self.run_requires + self.meta_requires) + r2 = process_entries(self.build_requires + self.dev_requires) + if self.extras: + result['Provides-Extra'] = sorted(self.extras) + result['Requires-Dist'] = sorted(r1) + result['Setup-Requires-Dist'] = sorted(r2) + # TODO: other fields such as contacts + return result + + def write(self, path=None, fileobj=None, legacy=False, skip_unknown=True): + if [path, fileobj].count(None) != 1: + raise ValueError('Exactly one of path and fileobj is needed') + self.validate() + if legacy: + if self._legacy: + legacy_md = self._legacy + else: + legacy_md = self._to_legacy() + if path: + legacy_md.write(path, skip_unknown=skip_unknown) + else: + legacy_md.write_file(fileobj, skip_unknown=skip_unknown) + else: + if self._legacy: + d = self._from_legacy() + else: + d = self._data + if fileobj: + json.dump(d, fileobj, ensure_ascii=True, indent=2, + sort_keys=True) + else: + with codecs.open(path, 'w', 'utf-8') as f: + json.dump(d, f, ensure_ascii=True, indent=2, + sort_keys=True) + + def add_requirements(self, requirements): + if self._legacy: + self._legacy.add_requirements(requirements) + else: + run_requires = self._data.setdefault('run_requires', []) + always = None + for entry in run_requires: + if 'environment' not in entry and 'extra' not in entry: + always = entry + break + if always is None: + always = { 'requires': requirements } + run_requires.insert(0, always) + else: + rset = set(always['requires']) | set(requirements) + always['requires'] = sorted(rset) + + def __repr__(self): + name = self.name or '(no name)' + version = self.version or 'no version' + return '<%s %s %s (%s)>' % (self.__class__.__name__, + self.metadata_version, name, version) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/resources.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/resources.py new file mode 100644 index 0000000000000000000000000000000000000000..18840167a9e3ea1cf443b0803230e41481df41d2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/resources.py @@ -0,0 +1,355 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2013-2017 Vinay Sajip. +# Licensed to the Python Software Foundation under a contributor agreement. +# See LICENSE.txt and CONTRIBUTORS.txt. +# +from __future__ import unicode_literals + +import bisect +import io +import logging +import os +import pkgutil +import shutil +import sys +import types +import zipimport + +from . import DistlibException +from .util import cached_property, get_cache_base, path_to_cache_dir, Cache + +logger = logging.getLogger(__name__) + + +cache = None # created when needed + + +class ResourceCache(Cache): + def __init__(self, base=None): + if base is None: + # Use native string to avoid issues on 2.x: see Python #20140. + base = os.path.join(get_cache_base(), str('resource-cache')) + super(ResourceCache, self).__init__(base) + + def is_stale(self, resource, path): + """ + Is the cache stale for the given resource? + + :param resource: The :class:`Resource` being cached. + :param path: The path of the resource in the cache. + :return: True if the cache is stale. + """ + # Cache invalidation is a hard problem :-) + return True + + def get(self, resource): + """ + Get a resource into the cache, + + :param resource: A :class:`Resource` instance. + :return: The pathname of the resource in the cache. + """ + prefix, path = resource.finder.get_cache_info(resource) + if prefix is None: + result = path + else: + result = os.path.join(self.base, self.prefix_to_dir(prefix), path) + dirname = os.path.dirname(result) + if not os.path.isdir(dirname): + os.makedirs(dirname) + if not os.path.exists(result): + stale = True + else: + stale = self.is_stale(resource, path) + if stale: + # write the bytes of the resource to the cache location + with open(result, 'wb') as f: + f.write(resource.bytes) + return result + + +class ResourceBase(object): + def __init__(self, finder, name): + self.finder = finder + self.name = name + + +class Resource(ResourceBase): + """ + A class representing an in-package resource, such as a data file. This is + not normally instantiated by user code, but rather by a + :class:`ResourceFinder` which manages the resource. + """ + is_container = False # Backwards compatibility + + def as_stream(self): + """ + Get the resource as a stream. + + This is not a property to make it obvious that it returns a new stream + each time. + """ + return self.finder.get_stream(self) + + @cached_property + def file_path(self): + global cache + if cache is None: + cache = ResourceCache() + return cache.get(self) + + @cached_property + def bytes(self): + return self.finder.get_bytes(self) + + @cached_property + def size(self): + return self.finder.get_size(self) + + +class ResourceContainer(ResourceBase): + is_container = True # Backwards compatibility + + @cached_property + def resources(self): + return self.finder.get_resources(self) + + +class ResourceFinder(object): + """ + Resource finder for file system resources. + """ + + if sys.platform.startswith('java'): + skipped_extensions = ('.pyc', '.pyo', '.class') + else: + skipped_extensions = ('.pyc', '.pyo') + + def __init__(self, module): + self.module = module + self.loader = getattr(module, '__loader__', None) + self.base = os.path.dirname(getattr(module, '__file__', '')) + + def _adjust_path(self, path): + return os.path.realpath(path) + + def _make_path(self, resource_name): + # Issue #50: need to preserve type of path on Python 2.x + # like os.path._get_sep + if isinstance(resource_name, bytes): # should only happen on 2.x + sep = b'/' + else: + sep = '/' + parts = resource_name.split(sep) + parts.insert(0, self.base) + result = os.path.join(*parts) + return self._adjust_path(result) + + def _find(self, path): + return os.path.exists(path) + + def get_cache_info(self, resource): + return None, resource.path + + def find(self, resource_name): + path = self._make_path(resource_name) + if not self._find(path): + result = None + else: + if self._is_directory(path): + result = ResourceContainer(self, resource_name) + else: + result = Resource(self, resource_name) + result.path = path + return result + + def get_stream(self, resource): + return open(resource.path, 'rb') + + def get_bytes(self, resource): + with open(resource.path, 'rb') as f: + return f.read() + + def get_size(self, resource): + return os.path.getsize(resource.path) + + def get_resources(self, resource): + def allowed(f): + return (f != '__pycache__' and not + f.endswith(self.skipped_extensions)) + return set([f for f in os.listdir(resource.path) if allowed(f)]) + + def is_container(self, resource): + return self._is_directory(resource.path) + + _is_directory = staticmethod(os.path.isdir) + + def iterator(self, resource_name): + resource = self.find(resource_name) + if resource is not None: + todo = [resource] + while todo: + resource = todo.pop(0) + yield resource + if resource.is_container: + rname = resource.name + for name in resource.resources: + if not rname: + new_name = name + else: + new_name = '/'.join([rname, name]) + child = self.find(new_name) + if child.is_container: + todo.append(child) + else: + yield child + + +class ZipResourceFinder(ResourceFinder): + """ + Resource finder for resources in .zip files. + """ + def __init__(self, module): + super(ZipResourceFinder, self).__init__(module) + archive = self.loader.archive + self.prefix_len = 1 + len(archive) + # PyPy doesn't have a _files attr on zipimporter, and you can't set one + if hasattr(self.loader, '_files'): + self._files = self.loader._files + else: + self._files = zipimport._zip_directory_cache[archive] + self.index = sorted(self._files) + + def _adjust_path(self, path): + return path + + def _find(self, path): + path = path[self.prefix_len:] + if path in self._files: + result = True + else: + if path and path[-1] != os.sep: + path = path + os.sep + i = bisect.bisect(self.index, path) + try: + result = self.index[i].startswith(path) + except IndexError: + result = False + if not result: + logger.debug('_find failed: %r %r', path, self.loader.prefix) + else: + logger.debug('_find worked: %r %r', path, self.loader.prefix) + return result + + def get_cache_info(self, resource): + prefix = self.loader.archive + path = resource.path[1 + len(prefix):] + return prefix, path + + def get_bytes(self, resource): + return self.loader.get_data(resource.path) + + def get_stream(self, resource): + return io.BytesIO(self.get_bytes(resource)) + + def get_size(self, resource): + path = resource.path[self.prefix_len:] + return self._files[path][3] + + def get_resources(self, resource): + path = resource.path[self.prefix_len:] + if path and path[-1] != os.sep: + path += os.sep + plen = len(path) + result = set() + i = bisect.bisect(self.index, path) + while i < len(self.index): + if not self.index[i].startswith(path): + break + s = self.index[i][plen:] + result.add(s.split(os.sep, 1)[0]) # only immediate children + i += 1 + return result + + def _is_directory(self, path): + path = path[self.prefix_len:] + if path and path[-1] != os.sep: + path += os.sep + i = bisect.bisect(self.index, path) + try: + result = self.index[i].startswith(path) + except IndexError: + result = False + return result + +_finder_registry = { + type(None): ResourceFinder, + zipimport.zipimporter: ZipResourceFinder +} + +try: + # In Python 3.6, _frozen_importlib -> _frozen_importlib_external + try: + import _frozen_importlib_external as _fi + except ImportError: + import _frozen_importlib as _fi + _finder_registry[_fi.SourceFileLoader] = ResourceFinder + _finder_registry[_fi.FileFinder] = ResourceFinder + del _fi +except (ImportError, AttributeError): + pass + + +def register_finder(loader, finder_maker): + _finder_registry[type(loader)] = finder_maker + +_finder_cache = {} + + +def finder(package): + """ + Return a resource finder for a package. + :param package: The name of the package. + :return: A :class:`ResourceFinder` instance for the package. + """ + if package in _finder_cache: + result = _finder_cache[package] + else: + if package not in sys.modules: + __import__(package) + module = sys.modules[package] + path = getattr(module, '__path__', None) + if path is None: + raise DistlibException('You cannot get a finder for a module, ' + 'only for a package') + loader = getattr(module, '__loader__', None) + finder_maker = _finder_registry.get(type(loader)) + if finder_maker is None: + raise DistlibException('Unable to locate finder for %r' % package) + result = finder_maker(module) + _finder_cache[package] = result + return result + + +_dummy_module = types.ModuleType(str('__dummy__')) + + +def finder_for_path(path): + """ + Return a resource finder for a path, which should represent a container. + + :param path: The path. + :return: A :class:`ResourceFinder` instance for the path. + """ + result = None + # calls any path hooks, gets importer into cache + pkgutil.get_importer(path) + loader = sys.path_importer_cache.get(path) + finder = _finder_registry.get(type(loader)) + if finder: + module = _dummy_module + module.__file__ = os.path.join(path, '') + module.__loader__ = loader + result = finder(module) + return result diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/scripts.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/scripts.py new file mode 100644 index 0000000000000000000000000000000000000000..5965e241d60db22148c0c291630abb6e3a26e525 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/distlib/scripts.py @@ -0,0 +1,403 @@ +# -*- coding: utf-8 -*- +# +# Copyright (C) 2013-2015 Vinay Sajip. +# Licensed to the Python Software Foundation under a contributor agreement. +# See LICENSE.txt and CONTRIBUTORS.txt. +# +from io import BytesIO +import logging +import os +import re +import struct +import sys + +from .compat import sysconfig, detect_encoding, ZipFile +from .resources import finder +from .util import (FileOperator, get_export_entry, convert_path, + get_executable, in_venv) + +logger = logging.getLogger(__name__) + +_DEFAULT_MANIFEST = ''' + + + + + + + + + + + + +'''.strip() + +# check if Python is called on the first line with this expression +FIRST_LINE_RE = re.compile(b'^#!.*pythonw?[0-9.]*([ \t].*)?$') +SCRIPT_TEMPLATE = r'''# -*- coding: utf-8 -*- +import re +import sys +from %(module)s import %(import_name)s +if __name__ == '__main__': + sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0]) + sys.exit(%(func)s()) +''' + + +def _enquote_executable(executable): + if ' ' in executable: + # make sure we quote only the executable in case of env + # for example /usr/bin/env "/dir with spaces/bin/jython" + # instead of "/usr/bin/env /dir with spaces/bin/jython" + # otherwise whole + if executable.startswith('/usr/bin/env '): + env, _executable = executable.split(' ', 1) + if ' ' in _executable and not _executable.startswith('"'): + executable = '%s "%s"' % (env, _executable) + else: + if not executable.startswith('"'): + executable = '"%s"' % executable + return executable + + +class ScriptMaker(object): + """ + A class to copy or create scripts from source scripts or callable + specifications. + """ + script_template = SCRIPT_TEMPLATE + + executable = None # for shebangs + + def __init__(self, source_dir, target_dir, add_launchers=True, + dry_run=False, fileop=None): + self.source_dir = source_dir + self.target_dir = target_dir + self.add_launchers = add_launchers + self.force = False + self.clobber = False + # It only makes sense to set mode bits on POSIX. + self.set_mode = (os.name == 'posix') or (os.name == 'java' and + os._name == 'posix') + self.variants = set(('', 'X.Y')) + self._fileop = fileop or FileOperator(dry_run) + + self._is_nt = os.name == 'nt' or ( + os.name == 'java' and os._name == 'nt') + + def _get_alternate_executable(self, executable, options): + if options.get('gui', False) and self._is_nt: # pragma: no cover + dn, fn = os.path.split(executable) + fn = fn.replace('python', 'pythonw') + executable = os.path.join(dn, fn) + return executable + + if sys.platform.startswith('java'): # pragma: no cover + def _is_shell(self, executable): + """ + Determine if the specified executable is a script + (contains a #! line) + """ + try: + with open(executable) as fp: + return fp.read(2) == '#!' + except (OSError, IOError): + logger.warning('Failed to open %s', executable) + return False + + def _fix_jython_executable(self, executable): + if self._is_shell(executable): + # Workaround for Jython is not needed on Linux systems. + import java + + if java.lang.System.getProperty('os.name') == 'Linux': + return executable + elif executable.lower().endswith('jython.exe'): + # Use wrapper exe for Jython on Windows + return executable + return '/usr/bin/env %s' % executable + + def _build_shebang(self, executable, post_interp): + """ + Build a shebang line. In the simple case (on Windows, or a shebang line + which is not too long or contains spaces) use a simple formulation for + the shebang. Otherwise, use /bin/sh as the executable, with a contrived + shebang which allows the script to run either under Python or sh, using + suitable quoting. Thanks to Harald Nordgren for his input. + + See also: http://www.in-ulm.de/~mascheck/various/shebang/#length + https://hg.mozilla.org/mozilla-central/file/tip/mach + """ + if os.name != 'posix': + simple_shebang = True + else: + # Add 3 for '#!' prefix and newline suffix. + shebang_length = len(executable) + len(post_interp) + 3 + if sys.platform == 'darwin': + max_shebang_length = 512 + else: + max_shebang_length = 127 + simple_shebang = ((b' ' not in executable) and + (shebang_length <= max_shebang_length)) + + if simple_shebang: + result = b'#!' + executable + post_interp + b'\n' + else: + result = b'#!/bin/sh\n' + result += b"'''exec' " + executable + post_interp + b' "$0" "$@"\n' + result += b"' '''" + return result + + def _get_shebang(self, encoding, post_interp=b'', options=None): + enquote = True + if self.executable: + executable = self.executable + enquote = False # assume this will be taken care of + elif not sysconfig.is_python_build(): + executable = get_executable() + elif in_venv(): # pragma: no cover + executable = os.path.join(sysconfig.get_path('scripts'), + 'python%s' % sysconfig.get_config_var('EXE')) + else: # pragma: no cover + executable = os.path.join( + sysconfig.get_config_var('BINDIR'), + 'python%s%s' % (sysconfig.get_config_var('VERSION'), + sysconfig.get_config_var('EXE'))) + if options: + executable = self._get_alternate_executable(executable, options) + + if sys.platform.startswith('java'): # pragma: no cover + executable = self._fix_jython_executable(executable) + # Normalise case for Windows + executable = os.path.normcase(executable) + # If the user didn't specify an executable, it may be necessary to + # cater for executable paths with spaces (not uncommon on Windows) + if enquote: + executable = _enquote_executable(executable) + # Issue #51: don't use fsencode, since we later try to + # check that the shebang is decodable using utf-8. + executable = executable.encode('utf-8') + # in case of IronPython, play safe and enable frames support + if (sys.platform == 'cli' and '-X:Frames' not in post_interp + and '-X:FullFrames' not in post_interp): # pragma: no cover + post_interp += b' -X:Frames' + shebang = self._build_shebang(executable, post_interp) + # Python parser starts to read a script using UTF-8 until + # it gets a #coding:xxx cookie. The shebang has to be the + # first line of a file, the #coding:xxx cookie cannot be + # written before. So the shebang has to be decodable from + # UTF-8. + try: + shebang.decode('utf-8') + except UnicodeDecodeError: # pragma: no cover + raise ValueError( + 'The shebang (%r) is not decodable from utf-8' % shebang) + # If the script is encoded to a custom encoding (use a + # #coding:xxx cookie), the shebang has to be decodable from + # the script encoding too. + if encoding != 'utf-8': + try: + shebang.decode(encoding) + except UnicodeDecodeError: # pragma: no cover + raise ValueError( + 'The shebang (%r) is not decodable ' + 'from the script encoding (%r)' % (shebang, encoding)) + return shebang + + def _get_script_text(self, entry): + return self.script_template % dict(module=entry.prefix, + import_name=entry.suffix.split('.')[0], + func=entry.suffix) + + manifest = _DEFAULT_MANIFEST + + def get_manifest(self, exename): + base = os.path.basename(exename) + return self.manifest % base + + def _write_script(self, names, shebang, script_bytes, filenames, ext): + use_launcher = self.add_launchers and self._is_nt + linesep = os.linesep.encode('utf-8') + if not shebang.endswith(linesep): + shebang += linesep + if not use_launcher: + script_bytes = shebang + script_bytes + else: # pragma: no cover + if ext == 'py': + launcher = self._get_launcher('t') + else: + launcher = self._get_launcher('w') + stream = BytesIO() + with ZipFile(stream, 'w') as zf: + zf.writestr('__main__.py', script_bytes) + zip_data = stream.getvalue() + script_bytes = launcher + shebang + zip_data + for name in names: + outname = os.path.join(self.target_dir, name) + if use_launcher: # pragma: no cover + n, e = os.path.splitext(outname) + if e.startswith('.py'): + outname = n + outname = '%s.exe' % outname + try: + self._fileop.write_binary_file(outname, script_bytes) + except Exception: + # Failed writing an executable - it might be in use. + logger.warning('Failed to write executable - trying to ' + 'use .deleteme logic') + dfname = '%s.deleteme' % outname + if os.path.exists(dfname): + os.remove(dfname) # Not allowed to fail here + os.rename(outname, dfname) # nor here + self._fileop.write_binary_file(outname, script_bytes) + logger.debug('Able to replace executable using ' + '.deleteme logic') + try: + os.remove(dfname) + except Exception: + pass # still in use - ignore error + else: + if self._is_nt and not outname.endswith('.' + ext): # pragma: no cover + outname = '%s.%s' % (outname, ext) + if os.path.exists(outname) and not self.clobber: + logger.warning('Skipping existing file %s', outname) + continue + self._fileop.write_binary_file(outname, script_bytes) + if self.set_mode: + self._fileop.set_executable_mode([outname]) + filenames.append(outname) + + def _make_script(self, entry, filenames, options=None): + post_interp = b'' + if options: + args = options.get('interpreter_args', []) + if args: + args = ' %s' % ' '.join(args) + post_interp = args.encode('utf-8') + shebang = self._get_shebang('utf-8', post_interp, options=options) + script = self._get_script_text(entry).encode('utf-8') + name = entry.name + scriptnames = set() + if '' in self.variants: + scriptnames.add(name) + if 'X' in self.variants: + scriptnames.add('%s%s' % (name, sys.version[0])) + if 'X.Y' in self.variants: + scriptnames.add('%s-%s' % (name, sys.version[:3])) + if options and options.get('gui', False): + ext = 'pyw' + else: + ext = 'py' + self._write_script(scriptnames, shebang, script, filenames, ext) + + def _copy_script(self, script, filenames): + adjust = False + script = os.path.join(self.source_dir, convert_path(script)) + outname = os.path.join(self.target_dir, os.path.basename(script)) + if not self.force and not self._fileop.newer(script, outname): + logger.debug('not copying %s (up-to-date)', script) + return + + # Always open the file, but ignore failures in dry-run mode -- + # that way, we'll get accurate feedback if we can read the + # script. + try: + f = open(script, 'rb') + except IOError: # pragma: no cover + if not self.dry_run: + raise + f = None + else: + first_line = f.readline() + if not first_line: # pragma: no cover + logger.warning('%s: %s is an empty file (skipping)', + self.get_command_name(), script) + return + + match = FIRST_LINE_RE.match(first_line.replace(b'\r\n', b'\n')) + if match: + adjust = True + post_interp = match.group(1) or b'' + + if not adjust: + if f: + f.close() + self._fileop.copy_file(script, outname) + if self.set_mode: + self._fileop.set_executable_mode([outname]) + filenames.append(outname) + else: + logger.info('copying and adjusting %s -> %s', script, + self.target_dir) + if not self._fileop.dry_run: + encoding, lines = detect_encoding(f.readline) + f.seek(0) + shebang = self._get_shebang(encoding, post_interp) + if b'pythonw' in first_line: # pragma: no cover + ext = 'pyw' + else: + ext = 'py' + n = os.path.basename(outname) + self._write_script([n], shebang, f.read(), filenames, ext) + if f: + f.close() + + @property + def dry_run(self): + return self._fileop.dry_run + + @dry_run.setter + def dry_run(self, value): + self._fileop.dry_run = value + + if os.name == 'nt' or (os.name == 'java' and os._name == 'nt'): # pragma: no cover + # Executable launcher support. + # Launchers are from https://bitbucket.org/vinay.sajip/simple_launcher/ + + def _get_launcher(self, kind): + if struct.calcsize('P') == 8: # 64-bit + bits = '64' + else: + bits = '32' + name = '%s%s.exe' % (kind, bits) + # Issue 31: don't hardcode an absolute package name, but + # determine it relative to the current package + distlib_package = __name__.rsplit('.', 1)[0] + result = finder(distlib_package).find(name).bytes + return result + + # Public API follows + + def make(self, specification, options=None): + """ + Make a script. + + :param specification: The specification, which is either a valid export + entry specification (to make a script from a + callable) or a filename (to make a script by + copying from a source location). + :param options: A dictionary of options controlling script generation. + :return: A list of all absolute pathnames written to. + """ + filenames = [] + entry = get_export_entry(specification) + if entry is None: + self._copy_script(specification, filenames) + else: + self._make_script(entry, filenames, options=options) + return filenames + + def make_multiple(self, specifications, options=None): + """ + Take a list of specifications and make scripts from them, + :param specifications: A list of specifications. + :return: A list of all absolute pathnames written to, + """ + filenames = [] + for specification in specifications: + filenames.extend(self.make(specification, options)) + return filenames diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..049123492e28952b521183e058b3a7ea301ac8d0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/__init__.py @@ -0,0 +1,35 @@ +""" +HTML parsing library based on the `WHATWG HTML specification +`_. The parser is designed to be compatible with +existing HTML found in the wild and implements well-defined error recovery that +is largely compatible with modern desktop web browsers. + +Example usage:: + + from pip._vendor import html5lib + with open("my_document.html", "rb") as f: + tree = html5lib.parse(f) + +For convenience, this module re-exports the following names: + +* :func:`~.html5parser.parse` +* :func:`~.html5parser.parseFragment` +* :class:`~.html5parser.HTMLParser` +* :func:`~.treebuilders.getTreeBuilder` +* :func:`~.treewalkers.getTreeWalker` +* :func:`~.serializer.serialize` +""" + +from __future__ import absolute_import, division, unicode_literals + +from .html5parser import HTMLParser, parse, parseFragment +from .treebuilders import getTreeBuilder +from .treewalkers import getTreeWalker +from .serializer import serialize + +__all__ = ["HTMLParser", "parse", "parseFragment", "getTreeBuilder", + "getTreeWalker", "serialize"] + +# this has to be at the top level, see how setup.py parses this +#: Distribution version number. +__version__ = "1.0.1" diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_tokenizer.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_tokenizer.py new file mode 100644 index 0000000000000000000000000000000000000000..178f6e7fa8c79abe6d18f0c60adfe0c239eb97e1 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_tokenizer.py @@ -0,0 +1,1721 @@ +from __future__ import absolute_import, division, unicode_literals + +from pip._vendor.six import unichr as chr + +from collections import deque + +from .constants import spaceCharacters +from .constants import entities +from .constants import asciiLetters, asciiUpper2Lower +from .constants import digits, hexDigits, EOF +from .constants import tokenTypes, tagTokenTypes +from .constants import replacementCharacters + +from ._inputstream import HTMLInputStream + +from ._trie import Trie + +entitiesTrie = Trie(entities) + + +class HTMLTokenizer(object): + """ This class takes care of tokenizing HTML. + + * self.currentToken + Holds the token that is currently being processed. + + * self.state + Holds a reference to the method to be invoked... XXX + + * self.stream + Points to HTMLInputStream object. + """ + + def __init__(self, stream, parser=None, **kwargs): + + self.stream = HTMLInputStream(stream, **kwargs) + self.parser = parser + + # Setup the initial tokenizer state + self.escapeFlag = False + self.lastFourChars = [] + self.state = self.dataState + self.escape = False + + # The current token being created + self.currentToken = None + super(HTMLTokenizer, self).__init__() + + def __iter__(self): + """ This is where the magic happens. + + We do our usually processing through the states and when we have a token + to return we yield the token which pauses processing until the next token + is requested. + """ + self.tokenQueue = deque([]) + # Start processing. When EOF is reached self.state will return False + # instead of True and the loop will terminate. + while self.state(): + while self.stream.errors: + yield {"type": tokenTypes["ParseError"], "data": self.stream.errors.pop(0)} + while self.tokenQueue: + yield self.tokenQueue.popleft() + + def consumeNumberEntity(self, isHex): + """This function returns either U+FFFD or the character based on the + decimal or hexadecimal representation. It also discards ";" if present. + If not present self.tokenQueue.append({"type": tokenTypes["ParseError"]}) is invoked. + """ + + allowed = digits + radix = 10 + if isHex: + allowed = hexDigits + radix = 16 + + charStack = [] + + # Consume all the characters that are in range while making sure we + # don't hit an EOF. + c = self.stream.char() + while c in allowed and c is not EOF: + charStack.append(c) + c = self.stream.char() + + # Convert the set of characters consumed to an int. + charAsInt = int("".join(charStack), radix) + + # Certain characters get replaced with others + if charAsInt in replacementCharacters: + char = replacementCharacters[charAsInt] + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "illegal-codepoint-for-numeric-entity", + "datavars": {"charAsInt": charAsInt}}) + elif ((0xD800 <= charAsInt <= 0xDFFF) or + (charAsInt > 0x10FFFF)): + char = "\uFFFD" + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "illegal-codepoint-for-numeric-entity", + "datavars": {"charAsInt": charAsInt}}) + else: + # Should speed up this check somehow (e.g. move the set to a constant) + if ((0x0001 <= charAsInt <= 0x0008) or + (0x000E <= charAsInt <= 0x001F) or + (0x007F <= charAsInt <= 0x009F) or + (0xFDD0 <= charAsInt <= 0xFDEF) or + charAsInt in frozenset([0x000B, 0xFFFE, 0xFFFF, 0x1FFFE, + 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE, + 0x3FFFF, 0x4FFFE, 0x4FFFF, 0x5FFFE, + 0x5FFFF, 0x6FFFE, 0x6FFFF, 0x7FFFE, + 0x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE, + 0x9FFFF, 0xAFFFE, 0xAFFFF, 0xBFFFE, + 0xBFFFF, 0xCFFFE, 0xCFFFF, 0xDFFFE, + 0xDFFFF, 0xEFFFE, 0xEFFFF, 0xFFFFE, + 0xFFFFF, 0x10FFFE, 0x10FFFF])): + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": + "illegal-codepoint-for-numeric-entity", + "datavars": {"charAsInt": charAsInt}}) + try: + # Try/except needed as UCS-2 Python builds' unichar only works + # within the BMP. + char = chr(charAsInt) + except ValueError: + v = charAsInt - 0x10000 + char = chr(0xD800 | (v >> 10)) + chr(0xDC00 | (v & 0x3FF)) + + # Discard the ; if present. Otherwise, put it back on the queue and + # invoke parseError on parser. + if c != ";": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "numeric-entity-without-semicolon"}) + self.stream.unget(c) + + return char + + def consumeEntity(self, allowedChar=None, fromAttribute=False): + # Initialise to the default output for when no entity is matched + output = "&" + + charStack = [self.stream.char()] + if (charStack[0] in spaceCharacters or charStack[0] in (EOF, "<", "&") or + (allowedChar is not None and allowedChar == charStack[0])): + self.stream.unget(charStack[0]) + + elif charStack[0] == "#": + # Read the next character to see if it's hex or decimal + hex = False + charStack.append(self.stream.char()) + if charStack[-1] in ("x", "X"): + hex = True + charStack.append(self.stream.char()) + + # charStack[-1] should be the first digit + if (hex and charStack[-1] in hexDigits) \ + or (not hex and charStack[-1] in digits): + # At least one digit found, so consume the whole number + self.stream.unget(charStack[-1]) + output = self.consumeNumberEntity(hex) + else: + # No digits found + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "expected-numeric-entity"}) + self.stream.unget(charStack.pop()) + output = "&" + "".join(charStack) + + else: + # At this point in the process might have named entity. Entities + # are stored in the global variable "entities". + # + # Consume characters and compare to these to a substring of the + # entity names in the list until the substring no longer matches. + while (charStack[-1] is not EOF): + if not entitiesTrie.has_keys_with_prefix("".join(charStack)): + break + charStack.append(self.stream.char()) + + # At this point we have a string that starts with some characters + # that may match an entity + # Try to find the longest entity the string will match to take care + # of ¬i for instance. + try: + entityName = entitiesTrie.longest_prefix("".join(charStack[:-1])) + entityLength = len(entityName) + except KeyError: + entityName = None + + if entityName is not None: + if entityName[-1] != ";": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "named-entity-without-semicolon"}) + if (entityName[-1] != ";" and fromAttribute and + (charStack[entityLength] in asciiLetters or + charStack[entityLength] in digits or + charStack[entityLength] == "=")): + self.stream.unget(charStack.pop()) + output = "&" + "".join(charStack) + else: + output = entities[entityName] + self.stream.unget(charStack.pop()) + output += "".join(charStack[entityLength:]) + else: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-named-entity"}) + self.stream.unget(charStack.pop()) + output = "&" + "".join(charStack) + + if fromAttribute: + self.currentToken["data"][-1][1] += output + else: + if output in spaceCharacters: + tokenType = "SpaceCharacters" + else: + tokenType = "Characters" + self.tokenQueue.append({"type": tokenTypes[tokenType], "data": output}) + + def processEntityInAttribute(self, allowedChar): + """This method replaces the need for "entityInAttributeValueState". + """ + self.consumeEntity(allowedChar=allowedChar, fromAttribute=True) + + def emitCurrentToken(self): + """This method is a generic handler for emitting the tags. It also sets + the state to "data" because that's what's needed after a token has been + emitted. + """ + token = self.currentToken + # Add token to the queue to be yielded + if (token["type"] in tagTokenTypes): + token["name"] = token["name"].translate(asciiUpper2Lower) + if token["type"] == tokenTypes["EndTag"]: + if token["data"]: + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "attributes-in-end-tag"}) + if token["selfClosing"]: + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "self-closing-flag-on-end-tag"}) + self.tokenQueue.append(token) + self.state = self.dataState + + # Below are the various tokenizer states worked out. + def dataState(self): + data = self.stream.char() + if data == "&": + self.state = self.entityDataState + elif data == "<": + self.state = self.tagOpenState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "\u0000"}) + elif data is EOF: + # Tokenization ends. + return False + elif data in spaceCharacters: + # Directly after emitting a token you switch back to the "data + # state". At that point spaceCharacters are important so they are + # emitted separately. + self.tokenQueue.append({"type": tokenTypes["SpaceCharacters"], "data": + data + self.stream.charsUntil(spaceCharacters, True)}) + # No need to update lastFourChars here, since the first space will + # have already been appended to lastFourChars and will have broken + # any sequences + else: + chars = self.stream.charsUntil(("&", "<", "\u0000")) + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": + data + chars}) + return True + + def entityDataState(self): + self.consumeEntity() + self.state = self.dataState + return True + + def rcdataState(self): + data = self.stream.char() + if data == "&": + self.state = self.characterReferenceInRcdata + elif data == "<": + self.state = self.rcdataLessThanSignState + elif data == EOF: + # Tokenization ends. + return False + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "\uFFFD"}) + elif data in spaceCharacters: + # Directly after emitting a token you switch back to the "data + # state". At that point spaceCharacters are important so they are + # emitted separately. + self.tokenQueue.append({"type": tokenTypes["SpaceCharacters"], "data": + data + self.stream.charsUntil(spaceCharacters, True)}) + # No need to update lastFourChars here, since the first space will + # have already been appended to lastFourChars and will have broken + # any sequences + else: + chars = self.stream.charsUntil(("&", "<", "\u0000")) + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": + data + chars}) + return True + + def characterReferenceInRcdata(self): + self.consumeEntity() + self.state = self.rcdataState + return True + + def rawtextState(self): + data = self.stream.char() + if data == "<": + self.state = self.rawtextLessThanSignState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "\uFFFD"}) + elif data == EOF: + # Tokenization ends. + return False + else: + chars = self.stream.charsUntil(("<", "\u0000")) + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": + data + chars}) + return True + + def scriptDataState(self): + data = self.stream.char() + if data == "<": + self.state = self.scriptDataLessThanSignState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "\uFFFD"}) + elif data == EOF: + # Tokenization ends. + return False + else: + chars = self.stream.charsUntil(("<", "\u0000")) + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": + data + chars}) + return True + + def plaintextState(self): + data = self.stream.char() + if data == EOF: + # Tokenization ends. + return False + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "\uFFFD"}) + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": + data + self.stream.charsUntil("\u0000")}) + return True + + def tagOpenState(self): + data = self.stream.char() + if data == "!": + self.state = self.markupDeclarationOpenState + elif data == "/": + self.state = self.closeTagOpenState + elif data in asciiLetters: + self.currentToken = {"type": tokenTypes["StartTag"], + "name": data, "data": [], + "selfClosing": False, + "selfClosingAcknowledged": False} + self.state = self.tagNameState + elif data == ">": + # XXX In theory it could be something besides a tag name. But + # do we really care? + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-tag-name-but-got-right-bracket"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<>"}) + self.state = self.dataState + elif data == "?": + # XXX In theory it could be something besides a tag name. But + # do we really care? + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-tag-name-but-got-question-mark"}) + self.stream.unget(data) + self.state = self.bogusCommentState + else: + # XXX + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-tag-name"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"}) + self.stream.unget(data) + self.state = self.dataState + return True + + def closeTagOpenState(self): + data = self.stream.char() + if data in asciiLetters: + self.currentToken = {"type": tokenTypes["EndTag"], "name": data, + "data": [], "selfClosing": False} + self.state = self.tagNameState + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-closing-tag-but-got-right-bracket"}) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-closing-tag-but-got-eof"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "": + self.emitCurrentToken() + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-tag-name"}) + self.state = self.dataState + elif data == "/": + self.state = self.selfClosingStartTagState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["name"] += "\uFFFD" + else: + self.currentToken["name"] += data + # (Don't use charsUntil here, because tag names are + # very short and it's faster to not do anything fancy) + return True + + def rcdataLessThanSignState(self): + data = self.stream.char() + if data == "/": + self.temporaryBuffer = "" + self.state = self.rcdataEndTagOpenState + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"}) + self.stream.unget(data) + self.state = self.rcdataState + return True + + def rcdataEndTagOpenState(self): + data = self.stream.char() + if data in asciiLetters: + self.temporaryBuffer += data + self.state = self.rcdataEndTagNameState + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "" and appropriate: + self.currentToken = {"type": tokenTypes["EndTag"], + "name": self.temporaryBuffer, + "data": [], "selfClosing": False} + self.emitCurrentToken() + self.state = self.dataState + elif data in asciiLetters: + self.temporaryBuffer += data + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "" and appropriate: + self.currentToken = {"type": tokenTypes["EndTag"], + "name": self.temporaryBuffer, + "data": [], "selfClosing": False} + self.emitCurrentToken() + self.state = self.dataState + elif data in asciiLetters: + self.temporaryBuffer += data + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "" and appropriate: + self.currentToken = {"type": tokenTypes["EndTag"], + "name": self.temporaryBuffer, + "data": [], "selfClosing": False} + self.emitCurrentToken() + self.state = self.dataState + elif data in asciiLetters: + self.temporaryBuffer += data + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "": + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": ">"}) + self.state = self.scriptDataState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "\uFFFD"}) + self.state = self.scriptDataEscapedState + elif data == EOF: + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data}) + self.state = self.scriptDataEscapedState + return True + + def scriptDataEscapedLessThanSignState(self): + data = self.stream.char() + if data == "/": + self.temporaryBuffer = "" + self.state = self.scriptDataEscapedEndTagOpenState + elif data in asciiLetters: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<" + data}) + self.temporaryBuffer = data + self.state = self.scriptDataDoubleEscapeStartState + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"}) + self.stream.unget(data) + self.state = self.scriptDataEscapedState + return True + + def scriptDataEscapedEndTagOpenState(self): + data = self.stream.char() + if data in asciiLetters: + self.temporaryBuffer = data + self.state = self.scriptDataEscapedEndTagNameState + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "" and appropriate: + self.currentToken = {"type": tokenTypes["EndTag"], + "name": self.temporaryBuffer, + "data": [], "selfClosing": False} + self.emitCurrentToken() + self.state = self.dataState + elif data in asciiLetters: + self.temporaryBuffer += data + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": ""))): + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data}) + if self.temporaryBuffer.lower() == "script": + self.state = self.scriptDataDoubleEscapedState + else: + self.state = self.scriptDataEscapedState + elif data in asciiLetters: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data}) + self.temporaryBuffer += data + else: + self.stream.unget(data) + self.state = self.scriptDataEscapedState + return True + + def scriptDataDoubleEscapedState(self): + data = self.stream.char() + if data == "-": + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"}) + self.state = self.scriptDataDoubleEscapedDashState + elif data == "<": + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"}) + self.state = self.scriptDataDoubleEscapedLessThanSignState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "\uFFFD"}) + elif data == EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-script-in-script"}) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data}) + return True + + def scriptDataDoubleEscapedDashState(self): + data = self.stream.char() + if data == "-": + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"}) + self.state = self.scriptDataDoubleEscapedDashDashState + elif data == "<": + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"}) + self.state = self.scriptDataDoubleEscapedLessThanSignState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "\uFFFD"}) + self.state = self.scriptDataDoubleEscapedState + elif data == EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-script-in-script"}) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data}) + self.state = self.scriptDataDoubleEscapedState + return True + + def scriptDataDoubleEscapedDashDashState(self): + data = self.stream.char() + if data == "-": + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "-"}) + elif data == "<": + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "<"}) + self.state = self.scriptDataDoubleEscapedLessThanSignState + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": ">"}) + self.state = self.scriptDataState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": "\uFFFD"}) + self.state = self.scriptDataDoubleEscapedState + elif data == EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-script-in-script"}) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data}) + self.state = self.scriptDataDoubleEscapedState + return True + + def scriptDataDoubleEscapedLessThanSignState(self): + data = self.stream.char() + if data == "/": + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": "/"}) + self.temporaryBuffer = "" + self.state = self.scriptDataDoubleEscapeEndState + else: + self.stream.unget(data) + self.state = self.scriptDataDoubleEscapedState + return True + + def scriptDataDoubleEscapeEndState(self): + data = self.stream.char() + if data in (spaceCharacters | frozenset(("/", ">"))): + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data}) + if self.temporaryBuffer.lower() == "script": + self.state = self.scriptDataEscapedState + else: + self.state = self.scriptDataDoubleEscapedState + elif data in asciiLetters: + self.tokenQueue.append({"type": tokenTypes["Characters"], "data": data}) + self.temporaryBuffer += data + else: + self.stream.unget(data) + self.state = self.scriptDataDoubleEscapedState + return True + + def beforeAttributeNameState(self): + data = self.stream.char() + if data in spaceCharacters: + self.stream.charsUntil(spaceCharacters, True) + elif data in asciiLetters: + self.currentToken["data"].append([data, ""]) + self.state = self.attributeNameState + elif data == ">": + self.emitCurrentToken() + elif data == "/": + self.state = self.selfClosingStartTagState + elif data in ("'", '"', "=", "<"): + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "invalid-character-in-attribute-name"}) + self.currentToken["data"].append([data, ""]) + self.state = self.attributeNameState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"].append(["\uFFFD", ""]) + self.state = self.attributeNameState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-attribute-name-but-got-eof"}) + self.state = self.dataState + else: + self.currentToken["data"].append([data, ""]) + self.state = self.attributeNameState + return True + + def attributeNameState(self): + data = self.stream.char() + leavingThisState = True + emitToken = False + if data == "=": + self.state = self.beforeAttributeValueState + elif data in asciiLetters: + self.currentToken["data"][-1][0] += data +\ + self.stream.charsUntil(asciiLetters, True) + leavingThisState = False + elif data == ">": + # XXX If we emit here the attributes are converted to a dict + # without being checked and when the code below runs we error + # because data is a dict not a list + emitToken = True + elif data in spaceCharacters: + self.state = self.afterAttributeNameState + elif data == "/": + self.state = self.selfClosingStartTagState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"][-1][0] += "\uFFFD" + leavingThisState = False + elif data in ("'", '"', "<"): + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": + "invalid-character-in-attribute-name"}) + self.currentToken["data"][-1][0] += data + leavingThisState = False + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "eof-in-attribute-name"}) + self.state = self.dataState + else: + self.currentToken["data"][-1][0] += data + leavingThisState = False + + if leavingThisState: + # Attributes are not dropped at this stage. That happens when the + # start tag token is emitted so values can still be safely appended + # to attributes, but we do want to report the parse error in time. + self.currentToken["data"][-1][0] = ( + self.currentToken["data"][-1][0].translate(asciiUpper2Lower)) + for name, _ in self.currentToken["data"][:-1]: + if self.currentToken["data"][-1][0] == name: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "duplicate-attribute"}) + break + # XXX Fix for above XXX + if emitToken: + self.emitCurrentToken() + return True + + def afterAttributeNameState(self): + data = self.stream.char() + if data in spaceCharacters: + self.stream.charsUntil(spaceCharacters, True) + elif data == "=": + self.state = self.beforeAttributeValueState + elif data == ">": + self.emitCurrentToken() + elif data in asciiLetters: + self.currentToken["data"].append([data, ""]) + self.state = self.attributeNameState + elif data == "/": + self.state = self.selfClosingStartTagState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"].append(["\uFFFD", ""]) + self.state = self.attributeNameState + elif data in ("'", '"', "<"): + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "invalid-character-after-attribute-name"}) + self.currentToken["data"].append([data, ""]) + self.state = self.attributeNameState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-end-of-tag-but-got-eof"}) + self.state = self.dataState + else: + self.currentToken["data"].append([data, ""]) + self.state = self.attributeNameState + return True + + def beforeAttributeValueState(self): + data = self.stream.char() + if data in spaceCharacters: + self.stream.charsUntil(spaceCharacters, True) + elif data == "\"": + self.state = self.attributeValueDoubleQuotedState + elif data == "&": + self.state = self.attributeValueUnQuotedState + self.stream.unget(data) + elif data == "'": + self.state = self.attributeValueSingleQuotedState + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-attribute-value-but-got-right-bracket"}) + self.emitCurrentToken() + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"][-1][1] += "\uFFFD" + self.state = self.attributeValueUnQuotedState + elif data in ("=", "<", "`"): + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "equals-in-unquoted-attribute-value"}) + self.currentToken["data"][-1][1] += data + self.state = self.attributeValueUnQuotedState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-attribute-value-but-got-eof"}) + self.state = self.dataState + else: + self.currentToken["data"][-1][1] += data + self.state = self.attributeValueUnQuotedState + return True + + def attributeValueDoubleQuotedState(self): + data = self.stream.char() + if data == "\"": + self.state = self.afterAttributeValueState + elif data == "&": + self.processEntityInAttribute('"') + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"][-1][1] += "\uFFFD" + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-attribute-value-double-quote"}) + self.state = self.dataState + else: + self.currentToken["data"][-1][1] += data +\ + self.stream.charsUntil(("\"", "&", "\u0000")) + return True + + def attributeValueSingleQuotedState(self): + data = self.stream.char() + if data == "'": + self.state = self.afterAttributeValueState + elif data == "&": + self.processEntityInAttribute("'") + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"][-1][1] += "\uFFFD" + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-attribute-value-single-quote"}) + self.state = self.dataState + else: + self.currentToken["data"][-1][1] += data +\ + self.stream.charsUntil(("'", "&", "\u0000")) + return True + + def attributeValueUnQuotedState(self): + data = self.stream.char() + if data in spaceCharacters: + self.state = self.beforeAttributeNameState + elif data == "&": + self.processEntityInAttribute(">") + elif data == ">": + self.emitCurrentToken() + elif data in ('"', "'", "=", "<", "`"): + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-character-in-unquoted-attribute-value"}) + self.currentToken["data"][-1][1] += data + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"][-1][1] += "\uFFFD" + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-attribute-value-no-quotes"}) + self.state = self.dataState + else: + self.currentToken["data"][-1][1] += data + self.stream.charsUntil( + frozenset(("&", ">", '"', "'", "=", "<", "`", "\u0000")) | spaceCharacters) + return True + + def afterAttributeValueState(self): + data = self.stream.char() + if data in spaceCharacters: + self.state = self.beforeAttributeNameState + elif data == ">": + self.emitCurrentToken() + elif data == "/": + self.state = self.selfClosingStartTagState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-EOF-after-attribute-value"}) + self.stream.unget(data) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-character-after-attribute-value"}) + self.stream.unget(data) + self.state = self.beforeAttributeNameState + return True + + def selfClosingStartTagState(self): + data = self.stream.char() + if data == ">": + self.currentToken["selfClosing"] = True + self.emitCurrentToken() + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": + "unexpected-EOF-after-solidus-in-tag"}) + self.stream.unget(data) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-character-after-solidus-in-tag"}) + self.stream.unget(data) + self.state = self.beforeAttributeNameState + return True + + def bogusCommentState(self): + # Make a new comment token and give it as value all the characters + # until the first > or EOF (charsUntil checks for EOF automatically) + # and emit it. + data = self.stream.charsUntil(">") + data = data.replace("\u0000", "\uFFFD") + self.tokenQueue.append( + {"type": tokenTypes["Comment"], "data": data}) + + # Eat the character directly after the bogus comment which is either a + # ">" or an EOF. + self.stream.char() + self.state = self.dataState + return True + + def markupDeclarationOpenState(self): + charStack = [self.stream.char()] + if charStack[-1] == "-": + charStack.append(self.stream.char()) + if charStack[-1] == "-": + self.currentToken = {"type": tokenTypes["Comment"], "data": ""} + self.state = self.commentStartState + return True + elif charStack[-1] in ('d', 'D'): + matched = True + for expected in (('o', 'O'), ('c', 'C'), ('t', 'T'), + ('y', 'Y'), ('p', 'P'), ('e', 'E')): + charStack.append(self.stream.char()) + if charStack[-1] not in expected: + matched = False + break + if matched: + self.currentToken = {"type": tokenTypes["Doctype"], + "name": "", + "publicId": None, "systemId": None, + "correct": True} + self.state = self.doctypeState + return True + elif (charStack[-1] == "[" and + self.parser is not None and + self.parser.tree.openElements and + self.parser.tree.openElements[-1].namespace != self.parser.tree.defaultNamespace): + matched = True + for expected in ["C", "D", "A", "T", "A", "["]: + charStack.append(self.stream.char()) + if charStack[-1] != expected: + matched = False + break + if matched: + self.state = self.cdataSectionState + return True + + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-dashes-or-doctype"}) + + while charStack: + self.stream.unget(charStack.pop()) + self.state = self.bogusCommentState + return True + + def commentStartState(self): + data = self.stream.char() + if data == "-": + self.state = self.commentStartDashState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"] += "\uFFFD" + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "incorrect-comment"}) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-comment"}) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["data"] += data + self.state = self.commentState + return True + + def commentStartDashState(self): + data = self.stream.char() + if data == "-": + self.state = self.commentEndState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"] += "-\uFFFD" + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "incorrect-comment"}) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-comment"}) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["data"] += "-" + data + self.state = self.commentState + return True + + def commentState(self): + data = self.stream.char() + if data == "-": + self.state = self.commentEndDashState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"] += "\uFFFD" + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "eof-in-comment"}) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["data"] += data + \ + self.stream.charsUntil(("-", "\u0000")) + return True + + def commentEndDashState(self): + data = self.stream.char() + if data == "-": + self.state = self.commentEndState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"] += "-\uFFFD" + self.state = self.commentState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-comment-end-dash"}) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["data"] += "-" + data + self.state = self.commentState + return True + + def commentEndState(self): + data = self.stream.char() + if data == ">": + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"] += "--\uFFFD" + self.state = self.commentState + elif data == "!": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-bang-after-double-dash-in-comment"}) + self.state = self.commentEndBangState + elif data == "-": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-dash-after-double-dash-in-comment"}) + self.currentToken["data"] += data + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-comment-double-dash"}) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + # XXX + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-comment"}) + self.currentToken["data"] += "--" + data + self.state = self.commentState + return True + + def commentEndBangState(self): + data = self.stream.char() + if data == ">": + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data == "-": + self.currentToken["data"] += "--!" + self.state = self.commentEndDashState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["data"] += "--!\uFFFD" + self.state = self.commentState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-comment-end-bang-state"}) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["data"] += "--!" + data + self.state = self.commentState + return True + + def doctypeState(self): + data = self.stream.char() + if data in spaceCharacters: + self.state = self.beforeDoctypeNameState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-doctype-name-but-got-eof"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "need-space-after-doctype"}) + self.stream.unget(data) + self.state = self.beforeDoctypeNameState + return True + + def beforeDoctypeNameState(self): + data = self.stream.char() + if data in spaceCharacters: + pass + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-doctype-name-but-got-right-bracket"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["name"] = "\uFFFD" + self.state = self.doctypeNameState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-doctype-name-but-got-eof"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["name"] = data + self.state = self.doctypeNameState + return True + + def doctypeNameState(self): + data = self.stream.char() + if data in spaceCharacters: + self.currentToken["name"] = self.currentToken["name"].translate(asciiUpper2Lower) + self.state = self.afterDoctypeNameState + elif data == ">": + self.currentToken["name"] = self.currentToken["name"].translate(asciiUpper2Lower) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["name"] += "\uFFFD" + self.state = self.doctypeNameState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype-name"}) + self.currentToken["correct"] = False + self.currentToken["name"] = self.currentToken["name"].translate(asciiUpper2Lower) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["name"] += data + return True + + def afterDoctypeNameState(self): + data = self.stream.char() + if data in spaceCharacters: + pass + elif data == ">": + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.currentToken["correct"] = False + self.stream.unget(data) + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + if data in ("p", "P"): + matched = True + for expected in (("u", "U"), ("b", "B"), ("l", "L"), + ("i", "I"), ("c", "C")): + data = self.stream.char() + if data not in expected: + matched = False + break + if matched: + self.state = self.afterDoctypePublicKeywordState + return True + elif data in ("s", "S"): + matched = True + for expected in (("y", "Y"), ("s", "S"), ("t", "T"), + ("e", "E"), ("m", "M")): + data = self.stream.char() + if data not in expected: + matched = False + break + if matched: + self.state = self.afterDoctypeSystemKeywordState + return True + + # All the characters read before the current 'data' will be + # [a-zA-Z], so they're garbage in the bogus doctype and can be + # discarded; only the latest character might be '>' or EOF + # and needs to be ungetted + self.stream.unget(data) + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "expected-space-or-right-bracket-in-doctype", "datavars": + {"data": data}}) + self.currentToken["correct"] = False + self.state = self.bogusDoctypeState + + return True + + def afterDoctypePublicKeywordState(self): + data = self.stream.char() + if data in spaceCharacters: + self.state = self.beforeDoctypePublicIdentifierState + elif data in ("'", '"'): + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.stream.unget(data) + self.state = self.beforeDoctypePublicIdentifierState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.stream.unget(data) + self.state = self.beforeDoctypePublicIdentifierState + return True + + def beforeDoctypePublicIdentifierState(self): + data = self.stream.char() + if data in spaceCharacters: + pass + elif data == "\"": + self.currentToken["publicId"] = "" + self.state = self.doctypePublicIdentifierDoubleQuotedState + elif data == "'": + self.currentToken["publicId"] = "" + self.state = self.doctypePublicIdentifierSingleQuotedState + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.currentToken["correct"] = False + self.state = self.bogusDoctypeState + return True + + def doctypePublicIdentifierDoubleQuotedState(self): + data = self.stream.char() + if data == "\"": + self.state = self.afterDoctypePublicIdentifierState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["publicId"] += "\uFFFD" + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["publicId"] += data + return True + + def doctypePublicIdentifierSingleQuotedState(self): + data = self.stream.char() + if data == "'": + self.state = self.afterDoctypePublicIdentifierState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["publicId"] += "\uFFFD" + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["publicId"] += data + return True + + def afterDoctypePublicIdentifierState(self): + data = self.stream.char() + if data in spaceCharacters: + self.state = self.betweenDoctypePublicAndSystemIdentifiersState + elif data == ">": + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data == '"': + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.currentToken["systemId"] = "" + self.state = self.doctypeSystemIdentifierDoubleQuotedState + elif data == "'": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.currentToken["systemId"] = "" + self.state = self.doctypeSystemIdentifierSingleQuotedState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.currentToken["correct"] = False + self.state = self.bogusDoctypeState + return True + + def betweenDoctypePublicAndSystemIdentifiersState(self): + data = self.stream.char() + if data in spaceCharacters: + pass + elif data == ">": + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data == '"': + self.currentToken["systemId"] = "" + self.state = self.doctypeSystemIdentifierDoubleQuotedState + elif data == "'": + self.currentToken["systemId"] = "" + self.state = self.doctypeSystemIdentifierSingleQuotedState + elif data == EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.currentToken["correct"] = False + self.state = self.bogusDoctypeState + return True + + def afterDoctypeSystemKeywordState(self): + data = self.stream.char() + if data in spaceCharacters: + self.state = self.beforeDoctypeSystemIdentifierState + elif data in ("'", '"'): + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.stream.unget(data) + self.state = self.beforeDoctypeSystemIdentifierState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.stream.unget(data) + self.state = self.beforeDoctypeSystemIdentifierState + return True + + def beforeDoctypeSystemIdentifierState(self): + data = self.stream.char() + if data in spaceCharacters: + pass + elif data == "\"": + self.currentToken["systemId"] = "" + self.state = self.doctypeSystemIdentifierDoubleQuotedState + elif data == "'": + self.currentToken["systemId"] = "" + self.state = self.doctypeSystemIdentifierSingleQuotedState + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.currentToken["correct"] = False + self.state = self.bogusDoctypeState + return True + + def doctypeSystemIdentifierDoubleQuotedState(self): + data = self.stream.char() + if data == "\"": + self.state = self.afterDoctypeSystemIdentifierState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["systemId"] += "\uFFFD" + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["systemId"] += data + return True + + def doctypeSystemIdentifierSingleQuotedState(self): + data = self.stream.char() + if data == "'": + self.state = self.afterDoctypeSystemIdentifierState + elif data == "\u0000": + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + self.currentToken["systemId"] += "\uFFFD" + elif data == ">": + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-end-of-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.currentToken["systemId"] += data + return True + + def afterDoctypeSystemIdentifierState(self): + data = self.stream.char() + if data in spaceCharacters: + pass + elif data == ">": + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "eof-in-doctype"}) + self.currentToken["correct"] = False + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + self.tokenQueue.append({"type": tokenTypes["ParseError"], "data": + "unexpected-char-in-doctype"}) + self.state = self.bogusDoctypeState + return True + + def bogusDoctypeState(self): + data = self.stream.char() + if data == ">": + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + elif data is EOF: + # XXX EMIT + self.stream.unget(data) + self.tokenQueue.append(self.currentToken) + self.state = self.dataState + else: + pass + return True + + def cdataSectionState(self): + data = [] + while True: + data.append(self.stream.charsUntil("]")) + data.append(self.stream.charsUntil(">")) + char = self.stream.char() + if char == EOF: + break + else: + assert char == ">" + if data[-1][-2:] == "]]": + data[-1] = data[-1][:-2] + break + else: + data.append(char) + + data = "".join(data) # pylint:disable=redefined-variable-type + # Deal with null here rather than in the parser + nullCount = data.count("\u0000") + if nullCount > 0: + for _ in range(nullCount): + self.tokenQueue.append({"type": tokenTypes["ParseError"], + "data": "invalid-codepoint"}) + data = data.replace("\u0000", "\uFFFD") + if data: + self.tokenQueue.append({"type": tokenTypes["Characters"], + "data": data}) + self.state = self.dataState + return True diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_utils.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..0703afb38b13bf56998d43aa542dcea9839d8132 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/html5lib/_utils.py @@ -0,0 +1,124 @@ +from __future__ import absolute_import, division, unicode_literals + +from types import ModuleType + +from pip._vendor.six import text_type + +try: + import xml.etree.cElementTree as default_etree +except ImportError: + import xml.etree.ElementTree as default_etree + + +__all__ = ["default_etree", "MethodDispatcher", "isSurrogatePair", + "surrogatePairToCodepoint", "moduleFactoryFactory", + "supports_lone_surrogates"] + + +# Platforms not supporting lone surrogates (\uD800-\uDFFF) should be +# caught by the below test. In general this would be any platform +# using UTF-16 as its encoding of unicode strings, such as +# Jython. This is because UTF-16 itself is based on the use of such +# surrogates, and there is no mechanism to further escape such +# escapes. +try: + _x = eval('"\\uD800"') # pylint:disable=eval-used + if not isinstance(_x, text_type): + # We need this with u"" because of http://bugs.jython.org/issue2039 + _x = eval('u"\\uD800"') # pylint:disable=eval-used + assert isinstance(_x, text_type) +except: # pylint:disable=bare-except + supports_lone_surrogates = False +else: + supports_lone_surrogates = True + + +class MethodDispatcher(dict): + """Dict with 2 special properties: + + On initiation, keys that are lists, sets or tuples are converted to + multiple keys so accessing any one of the items in the original + list-like object returns the matching value + + md = MethodDispatcher({("foo", "bar"):"baz"}) + md["foo"] == "baz" + + A default value which can be set through the default attribute. + """ + + def __init__(self, items=()): + # Using _dictEntries instead of directly assigning to self is about + # twice as fast. Please do careful performance testing before changing + # anything here. + _dictEntries = [] + for name, value in items: + if isinstance(name, (list, tuple, frozenset, set)): + for item in name: + _dictEntries.append((item, value)) + else: + _dictEntries.append((name, value)) + dict.__init__(self, _dictEntries) + assert len(self) == len(_dictEntries) + self.default = None + + def __getitem__(self, key): + return dict.get(self, key, self.default) + + +# Some utility functions to deal with weirdness around UCS2 vs UCS4 +# python builds + +def isSurrogatePair(data): + return (len(data) == 2 and + ord(data[0]) >= 0xD800 and ord(data[0]) <= 0xDBFF and + ord(data[1]) >= 0xDC00 and ord(data[1]) <= 0xDFFF) + + +def surrogatePairToCodepoint(data): + char_val = (0x10000 + (ord(data[0]) - 0xD800) * 0x400 + + (ord(data[1]) - 0xDC00)) + return char_val + +# Module Factory Factory (no, this isn't Java, I know) +# Here to stop this being duplicated all over the place. + + +def moduleFactoryFactory(factory): + moduleCache = {} + + def moduleFactory(baseModule, *args, **kwargs): + if isinstance(ModuleType.__name__, type("")): + name = "_%s_factory" % baseModule.__name__ + else: + name = b"_%s_factory" % baseModule.__name__ + + kwargs_tuple = tuple(kwargs.items()) + + try: + return moduleCache[name][args][kwargs_tuple] + except KeyError: + mod = ModuleType(name) + objs = factory(baseModule, *args, **kwargs) + mod.__dict__.update(objs) + if "name" not in moduleCache: + moduleCache[name] = {} + if "args" not in moduleCache[name]: + moduleCache[name][args] = {} + if "kwargs" not in moduleCache[name][args]: + moduleCache[name][args][kwargs_tuple] = {} + moduleCache[name][args][kwargs_tuple] = mod + return mod + + return moduleFactory + + +def memoize(func): + cache = {} + + def wrapped(*args, **kwargs): + key = (tuple(args), tuple(kwargs.items())) + if key not in cache: + cache[key] = func(*args, **kwargs) + return cache[key] + + return wrapped diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..847bf9354781fddc44ed2f47055a67c025972fd4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/__init__.py @@ -0,0 +1,2 @@ +from .package_data import __version__ +from .core import * diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/codec.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/codec.py new file mode 100644 index 0000000000000000000000000000000000000000..98c65ead146e42b359a11703d719bafe916b1ad7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/codec.py @@ -0,0 +1,118 @@ +from .core import encode, decode, alabel, ulabel, IDNAError +import codecs +import re + +_unicode_dots_re = re.compile(u'[\u002e\u3002\uff0e\uff61]') + +class Codec(codecs.Codec): + + def encode(self, data, errors='strict'): + + if errors != 'strict': + raise IDNAError("Unsupported error handling \"{0}\"".format(errors)) + + if not data: + return "", 0 + + return encode(data), len(data) + + def decode(self, data, errors='strict'): + + if errors != 'strict': + raise IDNAError("Unsupported error handling \"{0}\"".format(errors)) + + if not data: + return u"", 0 + + return decode(data), len(data) + +class IncrementalEncoder(codecs.BufferedIncrementalEncoder): + def _buffer_encode(self, data, errors, final): + if errors != 'strict': + raise IDNAError("Unsupported error handling \"{0}\"".format(errors)) + + if not data: + return ("", 0) + + labels = _unicode_dots_re.split(data) + trailing_dot = u'' + if labels: + if not labels[-1]: + trailing_dot = '.' + del labels[-1] + elif not final: + # Keep potentially unfinished label until the next call + del labels[-1] + if labels: + trailing_dot = '.' + + result = [] + size = 0 + for label in labels: + result.append(alabel(label)) + if size: + size += 1 + size += len(label) + + # Join with U+002E + result = ".".join(result) + trailing_dot + size += len(trailing_dot) + return (result, size) + +class IncrementalDecoder(codecs.BufferedIncrementalDecoder): + def _buffer_decode(self, data, errors, final): + if errors != 'strict': + raise IDNAError("Unsupported error handling \"{0}\"".format(errors)) + + if not data: + return (u"", 0) + + # IDNA allows decoding to operate on Unicode strings, too. + if isinstance(data, unicode): + labels = _unicode_dots_re.split(data) + else: + # Must be ASCII string + data = str(data) + unicode(data, "ascii") + labels = data.split(".") + + trailing_dot = u'' + if labels: + if not labels[-1]: + trailing_dot = u'.' + del labels[-1] + elif not final: + # Keep potentially unfinished label until the next call + del labels[-1] + if labels: + trailing_dot = u'.' + + result = [] + size = 0 + for label in labels: + result.append(ulabel(label)) + if size: + size += 1 + size += len(label) + + result = u".".join(result) + trailing_dot + size += len(trailing_dot) + return (result, size) + + +class StreamWriter(Codec, codecs.StreamWriter): + pass + +class StreamReader(Codec, codecs.StreamReader): + pass + +def getregentry(): + return codecs.CodecInfo( + name='idna', + encode=Codec().encode, + decode=Codec().decode, + incrementalencoder=IncrementalEncoder, + incrementaldecoder=IncrementalDecoder, + streamwriter=StreamWriter, + streamreader=StreamReader, + ) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/compat.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/compat.py new file mode 100644 index 0000000000000000000000000000000000000000..4d47f336dbc55ca7141150c14ec1a7924dd0e854 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/compat.py @@ -0,0 +1,12 @@ +from .core import * +from .codec import * + +def ToASCII(label): + return encode(label) + +def ToUnicode(label): + return decode(label) + +def nameprep(s): + raise NotImplementedError("IDNA 2008 does not utilise nameprep protocol") + diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/core.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/core.py new file mode 100644 index 0000000000000000000000000000000000000000..104624ad2ddd7b18e255a74dcaa099a84223d959 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/core.py @@ -0,0 +1,396 @@ +from . import idnadata +import bisect +import unicodedata +import re +import sys +from .intranges import intranges_contain + +_virama_combining_class = 9 +_alabel_prefix = b'xn--' +_unicode_dots_re = re.compile(u'[\u002e\u3002\uff0e\uff61]') + +if sys.version_info[0] == 3: + unicode = str + unichr = chr + +class IDNAError(UnicodeError): + """ Base exception for all IDNA-encoding related problems """ + pass + + +class IDNABidiError(IDNAError): + """ Exception when bidirectional requirements are not satisfied """ + pass + + +class InvalidCodepoint(IDNAError): + """ Exception when a disallowed or unallocated codepoint is used """ + pass + + +class InvalidCodepointContext(IDNAError): + """ Exception when the codepoint is not valid in the context it is used """ + pass + + +def _combining_class(cp): + v = unicodedata.combining(unichr(cp)) + if v == 0: + if not unicodedata.name(unichr(cp)): + raise ValueError("Unknown character in unicodedata") + return v + +def _is_script(cp, script): + return intranges_contain(ord(cp), idnadata.scripts[script]) + +def _punycode(s): + return s.encode('punycode') + +def _unot(s): + return 'U+{0:04X}'.format(s) + + +def valid_label_length(label): + + if len(label) > 63: + return False + return True + + +def valid_string_length(label, trailing_dot): + + if len(label) > (254 if trailing_dot else 253): + return False + return True + + +def check_bidi(label, check_ltr=False): + + # Bidi rules should only be applied if string contains RTL characters + bidi_label = False + for (idx, cp) in enumerate(label, 1): + direction = unicodedata.bidirectional(cp) + if direction == '': + # String likely comes from a newer version of Unicode + raise IDNABidiError('Unknown directionality in label {0} at position {1}'.format(repr(label), idx)) + if direction in ['R', 'AL', 'AN']: + bidi_label = True + if not bidi_label and not check_ltr: + return True + + # Bidi rule 1 + direction = unicodedata.bidirectional(label[0]) + if direction in ['R', 'AL']: + rtl = True + elif direction == 'L': + rtl = False + else: + raise IDNABidiError('First codepoint in label {0} must be directionality L, R or AL'.format(repr(label))) + + valid_ending = False + number_type = False + for (idx, cp) in enumerate(label, 1): + direction = unicodedata.bidirectional(cp) + + if rtl: + # Bidi rule 2 + if not direction in ['R', 'AL', 'AN', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']: + raise IDNABidiError('Invalid direction for codepoint at position {0} in a right-to-left label'.format(idx)) + # Bidi rule 3 + if direction in ['R', 'AL', 'EN', 'AN']: + valid_ending = True + elif direction != 'NSM': + valid_ending = False + # Bidi rule 4 + if direction in ['AN', 'EN']: + if not number_type: + number_type = direction + else: + if number_type != direction: + raise IDNABidiError('Can not mix numeral types in a right-to-left label') + else: + # Bidi rule 5 + if not direction in ['L', 'EN', 'ES', 'CS', 'ET', 'ON', 'BN', 'NSM']: + raise IDNABidiError('Invalid direction for codepoint at position {0} in a left-to-right label'.format(idx)) + # Bidi rule 6 + if direction in ['L', 'EN']: + valid_ending = True + elif direction != 'NSM': + valid_ending = False + + if not valid_ending: + raise IDNABidiError('Label ends with illegal codepoint directionality') + + return True + + +def check_initial_combiner(label): + + if unicodedata.category(label[0])[0] == 'M': + raise IDNAError('Label begins with an illegal combining character') + return True + + +def check_hyphen_ok(label): + + if label[2:4] == '--': + raise IDNAError('Label has disallowed hyphens in 3rd and 4th position') + if label[0] == '-' or label[-1] == '-': + raise IDNAError('Label must not start or end with a hyphen') + return True + + +def check_nfc(label): + + if unicodedata.normalize('NFC', label) != label: + raise IDNAError('Label must be in Normalization Form C') + + +def valid_contextj(label, pos): + + cp_value = ord(label[pos]) + + if cp_value == 0x200c: + + if pos > 0: + if _combining_class(ord(label[pos - 1])) == _virama_combining_class: + return True + + ok = False + for i in range(pos-1, -1, -1): + joining_type = idnadata.joining_types.get(ord(label[i])) + if joining_type == ord('T'): + continue + if joining_type in [ord('L'), ord('D')]: + ok = True + break + + if not ok: + return False + + ok = False + for i in range(pos+1, len(label)): + joining_type = idnadata.joining_types.get(ord(label[i])) + if joining_type == ord('T'): + continue + if joining_type in [ord('R'), ord('D')]: + ok = True + break + return ok + + if cp_value == 0x200d: + + if pos > 0: + if _combining_class(ord(label[pos - 1])) == _virama_combining_class: + return True + return False + + else: + + return False + + +def valid_contexto(label, pos, exception=False): + + cp_value = ord(label[pos]) + + if cp_value == 0x00b7: + if 0 < pos < len(label)-1: + if ord(label[pos - 1]) == 0x006c and ord(label[pos + 1]) == 0x006c: + return True + return False + + elif cp_value == 0x0375: + if pos < len(label)-1 and len(label) > 1: + return _is_script(label[pos + 1], 'Greek') + return False + + elif cp_value == 0x05f3 or cp_value == 0x05f4: + if pos > 0: + return _is_script(label[pos - 1], 'Hebrew') + return False + + elif cp_value == 0x30fb: + for cp in label: + if cp == u'\u30fb': + continue + if _is_script(cp, 'Hiragana') or _is_script(cp, 'Katakana') or _is_script(cp, 'Han'): + return True + return False + + elif 0x660 <= cp_value <= 0x669: + for cp in label: + if 0x6f0 <= ord(cp) <= 0x06f9: + return False + return True + + elif 0x6f0 <= cp_value <= 0x6f9: + for cp in label: + if 0x660 <= ord(cp) <= 0x0669: + return False + return True + + +def check_label(label): + + if isinstance(label, (bytes, bytearray)): + label = label.decode('utf-8') + if len(label) == 0: + raise IDNAError('Empty Label') + + check_nfc(label) + check_hyphen_ok(label) + check_initial_combiner(label) + + for (pos, cp) in enumerate(label): + cp_value = ord(cp) + if intranges_contain(cp_value, idnadata.codepoint_classes['PVALID']): + continue + elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTJ']): + try: + if not valid_contextj(label, pos): + raise InvalidCodepointContext('Joiner {0} not allowed at position {1} in {2}'.format( + _unot(cp_value), pos+1, repr(label))) + except ValueError: + raise IDNAError('Unknown codepoint adjacent to joiner {0} at position {1} in {2}'.format( + _unot(cp_value), pos+1, repr(label))) + elif intranges_contain(cp_value, idnadata.codepoint_classes['CONTEXTO']): + if not valid_contexto(label, pos): + raise InvalidCodepointContext('Codepoint {0} not allowed at position {1} in {2}'.format(_unot(cp_value), pos+1, repr(label))) + else: + raise InvalidCodepoint('Codepoint {0} at position {1} of {2} not allowed'.format(_unot(cp_value), pos+1, repr(label))) + + check_bidi(label) + + +def alabel(label): + + try: + label = label.encode('ascii') + ulabel(label) + if not valid_label_length(label): + raise IDNAError('Label too long') + return label + except UnicodeEncodeError: + pass + + if not label: + raise IDNAError('No Input') + + label = unicode(label) + check_label(label) + label = _punycode(label) + label = _alabel_prefix + label + + if not valid_label_length(label): + raise IDNAError('Label too long') + + return label + + +def ulabel(label): + + if not isinstance(label, (bytes, bytearray)): + try: + label = label.encode('ascii') + except UnicodeEncodeError: + check_label(label) + return label + + label = label.lower() + if label.startswith(_alabel_prefix): + label = label[len(_alabel_prefix):] + else: + check_label(label) + return label.decode('ascii') + + label = label.decode('punycode') + check_label(label) + return label + + +def uts46_remap(domain, std3_rules=True, transitional=False): + """Re-map the characters in the string according to UTS46 processing.""" + from .uts46data import uts46data + output = u"" + try: + for pos, char in enumerate(domain): + code_point = ord(char) + uts46row = uts46data[code_point if code_point < 256 else + bisect.bisect_left(uts46data, (code_point, "Z")) - 1] + status = uts46row[1] + replacement = uts46row[2] if len(uts46row) == 3 else None + if (status == "V" or + (status == "D" and not transitional) or + (status == "3" and not std3_rules and replacement is None)): + output += char + elif replacement is not None and (status == "M" or + (status == "3" and not std3_rules) or + (status == "D" and transitional)): + output += replacement + elif status != "I": + raise IndexError() + return unicodedata.normalize("NFC", output) + except IndexError: + raise InvalidCodepoint( + "Codepoint {0} not allowed at position {1} in {2}".format( + _unot(code_point), pos + 1, repr(domain))) + + +def encode(s, strict=False, uts46=False, std3_rules=False, transitional=False): + + if isinstance(s, (bytes, bytearray)): + s = s.decode("ascii") + if uts46: + s = uts46_remap(s, std3_rules, transitional) + trailing_dot = False + result = [] + if strict: + labels = s.split('.') + else: + labels = _unicode_dots_re.split(s) + if not labels or labels == ['']: + raise IDNAError('Empty domain') + if labels[-1] == '': + del labels[-1] + trailing_dot = True + for label in labels: + s = alabel(label) + if s: + result.append(s) + else: + raise IDNAError('Empty label') + if trailing_dot: + result.append(b'') + s = b'.'.join(result) + if not valid_string_length(s, trailing_dot): + raise IDNAError('Domain too long') + return s + + +def decode(s, strict=False, uts46=False, std3_rules=False): + + if isinstance(s, (bytes, bytearray)): + s = s.decode("ascii") + if uts46: + s = uts46_remap(s, std3_rules, False) + trailing_dot = False + result = [] + if not strict: + labels = _unicode_dots_re.split(s) + else: + labels = s.split(u'.') + if not labels or labels == ['']: + raise IDNAError('Empty domain') + if not labels[-1]: + del labels[-1] + trailing_dot = True + for label in labels: + s = ulabel(label) + if s: + result.append(s) + else: + raise IDNAError('Empty label') + if trailing_dot: + result.append(u'') + return u'.'.join(result) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/idnadata.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/idnadata.py new file mode 100644 index 0000000000000000000000000000000000000000..a80c959d2a7127633cd696f86844d1f356a0bc83 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/idnadata.py @@ -0,0 +1,1979 @@ +# This file is automatically generated by tools/idna-data + +__version__ = "11.0.0" +scripts = { + 'Greek': ( + 0x37000000374, + 0x37500000378, + 0x37a0000037e, + 0x37f00000380, + 0x38400000385, + 0x38600000387, + 0x3880000038b, + 0x38c0000038d, + 0x38e000003a2, + 0x3a3000003e2, + 0x3f000000400, + 0x1d2600001d2b, + 0x1d5d00001d62, + 0x1d6600001d6b, + 0x1dbf00001dc0, + 0x1f0000001f16, + 0x1f1800001f1e, + 0x1f2000001f46, + 0x1f4800001f4e, + 0x1f5000001f58, + 0x1f5900001f5a, + 0x1f5b00001f5c, + 0x1f5d00001f5e, + 0x1f5f00001f7e, + 0x1f8000001fb5, + 0x1fb600001fc5, + 0x1fc600001fd4, + 0x1fd600001fdc, + 0x1fdd00001ff0, + 0x1ff200001ff5, + 0x1ff600001fff, + 0x212600002127, + 0xab650000ab66, + 0x101400001018f, + 0x101a0000101a1, + 0x1d2000001d246, + ), + 'Han': ( + 0x2e8000002e9a, + 0x2e9b00002ef4, + 0x2f0000002fd6, + 0x300500003006, + 0x300700003008, + 0x30210000302a, + 0x30380000303c, + 0x340000004db6, + 0x4e0000009ff0, + 0xf9000000fa6e, + 0xfa700000fada, + 0x200000002a6d7, + 0x2a7000002b735, + 0x2b7400002b81e, + 0x2b8200002cea2, + 0x2ceb00002ebe1, + 0x2f8000002fa1e, + ), + 'Hebrew': ( + 0x591000005c8, + 0x5d0000005eb, + 0x5ef000005f5, + 0xfb1d0000fb37, + 0xfb380000fb3d, + 0xfb3e0000fb3f, + 0xfb400000fb42, + 0xfb430000fb45, + 0xfb460000fb50, + ), + 'Hiragana': ( + 0x304100003097, + 0x309d000030a0, + 0x1b0010001b11f, + 0x1f2000001f201, + ), + 'Katakana': ( + 0x30a1000030fb, + 0x30fd00003100, + 0x31f000003200, + 0x32d0000032ff, + 0x330000003358, + 0xff660000ff70, + 0xff710000ff9e, + 0x1b0000001b001, + ), +} +joining_types = { + 0x600: 85, + 0x601: 85, + 0x602: 85, + 0x603: 85, + 0x604: 85, + 0x605: 85, + 0x608: 85, + 0x60b: 85, + 0x620: 68, + 0x621: 85, + 0x622: 82, + 0x623: 82, + 0x624: 82, + 0x625: 82, + 0x626: 68, + 0x627: 82, + 0x628: 68, + 0x629: 82, + 0x62a: 68, + 0x62b: 68, + 0x62c: 68, + 0x62d: 68, + 0x62e: 68, + 0x62f: 82, + 0x630: 82, + 0x631: 82, + 0x632: 82, + 0x633: 68, + 0x634: 68, + 0x635: 68, + 0x636: 68, + 0x637: 68, + 0x638: 68, + 0x639: 68, + 0x63a: 68, + 0x63b: 68, + 0x63c: 68, + 0x63d: 68, + 0x63e: 68, + 0x63f: 68, + 0x640: 67, + 0x641: 68, + 0x642: 68, + 0x643: 68, + 0x644: 68, + 0x645: 68, + 0x646: 68, + 0x647: 68, + 0x648: 82, + 0x649: 68, + 0x64a: 68, + 0x66e: 68, + 0x66f: 68, + 0x671: 82, + 0x672: 82, + 0x673: 82, + 0x674: 85, + 0x675: 82, + 0x676: 82, + 0x677: 82, + 0x678: 68, + 0x679: 68, + 0x67a: 68, + 0x67b: 68, + 0x67c: 68, + 0x67d: 68, + 0x67e: 68, + 0x67f: 68, + 0x680: 68, + 0x681: 68, + 0x682: 68, + 0x683: 68, + 0x684: 68, + 0x685: 68, + 0x686: 68, + 0x687: 68, + 0x688: 82, + 0x689: 82, + 0x68a: 82, + 0x68b: 82, + 0x68c: 82, + 0x68d: 82, + 0x68e: 82, + 0x68f: 82, + 0x690: 82, + 0x691: 82, + 0x692: 82, + 0x693: 82, + 0x694: 82, + 0x695: 82, + 0x696: 82, + 0x697: 82, + 0x698: 82, + 0x699: 82, + 0x69a: 68, + 0x69b: 68, + 0x69c: 68, + 0x69d: 68, + 0x69e: 68, + 0x69f: 68, + 0x6a0: 68, + 0x6a1: 68, + 0x6a2: 68, + 0x6a3: 68, + 0x6a4: 68, + 0x6a5: 68, + 0x6a6: 68, + 0x6a7: 68, + 0x6a8: 68, + 0x6a9: 68, + 0x6aa: 68, + 0x6ab: 68, + 0x6ac: 68, + 0x6ad: 68, + 0x6ae: 68, + 0x6af: 68, + 0x6b0: 68, + 0x6b1: 68, + 0x6b2: 68, + 0x6b3: 68, + 0x6b4: 68, + 0x6b5: 68, + 0x6b6: 68, + 0x6b7: 68, + 0x6b8: 68, + 0x6b9: 68, + 0x6ba: 68, + 0x6bb: 68, + 0x6bc: 68, + 0x6bd: 68, + 0x6be: 68, + 0x6bf: 68, + 0x6c0: 82, + 0x6c1: 68, + 0x6c2: 68, + 0x6c3: 82, + 0x6c4: 82, + 0x6c5: 82, + 0x6c6: 82, + 0x6c7: 82, + 0x6c8: 82, + 0x6c9: 82, + 0x6ca: 82, + 0x6cb: 82, + 0x6cc: 68, + 0x6cd: 82, + 0x6ce: 68, + 0x6cf: 82, + 0x6d0: 68, + 0x6d1: 68, + 0x6d2: 82, + 0x6d3: 82, + 0x6d5: 82, + 0x6dd: 85, + 0x6ee: 82, + 0x6ef: 82, + 0x6fa: 68, + 0x6fb: 68, + 0x6fc: 68, + 0x6ff: 68, + 0x70f: 84, + 0x710: 82, + 0x712: 68, + 0x713: 68, + 0x714: 68, + 0x715: 82, + 0x716: 82, + 0x717: 82, + 0x718: 82, + 0x719: 82, + 0x71a: 68, + 0x71b: 68, + 0x71c: 68, + 0x71d: 68, + 0x71e: 82, + 0x71f: 68, + 0x720: 68, + 0x721: 68, + 0x722: 68, + 0x723: 68, + 0x724: 68, + 0x725: 68, + 0x726: 68, + 0x727: 68, + 0x728: 82, + 0x729: 68, + 0x72a: 82, + 0x72b: 68, + 0x72c: 82, + 0x72d: 68, + 0x72e: 68, + 0x72f: 82, + 0x74d: 82, + 0x74e: 68, + 0x74f: 68, + 0x750: 68, + 0x751: 68, + 0x752: 68, + 0x753: 68, + 0x754: 68, + 0x755: 68, + 0x756: 68, + 0x757: 68, + 0x758: 68, + 0x759: 82, + 0x75a: 82, + 0x75b: 82, + 0x75c: 68, + 0x75d: 68, + 0x75e: 68, + 0x75f: 68, + 0x760: 68, + 0x761: 68, + 0x762: 68, + 0x763: 68, + 0x764: 68, + 0x765: 68, + 0x766: 68, + 0x767: 68, + 0x768: 68, + 0x769: 68, + 0x76a: 68, + 0x76b: 82, + 0x76c: 82, + 0x76d: 68, + 0x76e: 68, + 0x76f: 68, + 0x770: 68, + 0x771: 82, + 0x772: 68, + 0x773: 82, + 0x774: 82, + 0x775: 68, + 0x776: 68, + 0x777: 68, + 0x778: 82, + 0x779: 82, + 0x77a: 68, + 0x77b: 68, + 0x77c: 68, + 0x77d: 68, + 0x77e: 68, + 0x77f: 68, + 0x7ca: 68, + 0x7cb: 68, + 0x7cc: 68, + 0x7cd: 68, + 0x7ce: 68, + 0x7cf: 68, + 0x7d0: 68, + 0x7d1: 68, + 0x7d2: 68, + 0x7d3: 68, + 0x7d4: 68, + 0x7d5: 68, + 0x7d6: 68, + 0x7d7: 68, + 0x7d8: 68, + 0x7d9: 68, + 0x7da: 68, + 0x7db: 68, + 0x7dc: 68, + 0x7dd: 68, + 0x7de: 68, + 0x7df: 68, + 0x7e0: 68, + 0x7e1: 68, + 0x7e2: 68, + 0x7e3: 68, + 0x7e4: 68, + 0x7e5: 68, + 0x7e6: 68, + 0x7e7: 68, + 0x7e8: 68, + 0x7e9: 68, + 0x7ea: 68, + 0x7fa: 67, + 0x840: 82, + 0x841: 68, + 0x842: 68, + 0x843: 68, + 0x844: 68, + 0x845: 68, + 0x846: 82, + 0x847: 82, + 0x848: 68, + 0x849: 82, + 0x84a: 68, + 0x84b: 68, + 0x84c: 68, + 0x84d: 68, + 0x84e: 68, + 0x84f: 68, + 0x850: 68, + 0x851: 68, + 0x852: 68, + 0x853: 68, + 0x854: 82, + 0x855: 68, + 0x856: 85, + 0x857: 85, + 0x858: 85, + 0x860: 68, + 0x861: 85, + 0x862: 68, + 0x863: 68, + 0x864: 68, + 0x865: 68, + 0x866: 85, + 0x867: 82, + 0x868: 68, + 0x869: 82, + 0x86a: 82, + 0x8a0: 68, + 0x8a1: 68, + 0x8a2: 68, + 0x8a3: 68, + 0x8a4: 68, + 0x8a5: 68, + 0x8a6: 68, + 0x8a7: 68, + 0x8a8: 68, + 0x8a9: 68, + 0x8aa: 82, + 0x8ab: 82, + 0x8ac: 82, + 0x8ad: 85, + 0x8ae: 82, + 0x8af: 68, + 0x8b0: 68, + 0x8b1: 82, + 0x8b2: 82, + 0x8b3: 68, + 0x8b4: 68, + 0x8b6: 68, + 0x8b7: 68, + 0x8b8: 68, + 0x8b9: 82, + 0x8ba: 68, + 0x8bb: 68, + 0x8bc: 68, + 0x8bd: 68, + 0x8e2: 85, + 0x1806: 85, + 0x1807: 68, + 0x180a: 67, + 0x180e: 85, + 0x1820: 68, + 0x1821: 68, + 0x1822: 68, + 0x1823: 68, + 0x1824: 68, + 0x1825: 68, + 0x1826: 68, + 0x1827: 68, + 0x1828: 68, + 0x1829: 68, + 0x182a: 68, + 0x182b: 68, + 0x182c: 68, + 0x182d: 68, + 0x182e: 68, + 0x182f: 68, + 0x1830: 68, + 0x1831: 68, + 0x1832: 68, + 0x1833: 68, + 0x1834: 68, + 0x1835: 68, + 0x1836: 68, + 0x1837: 68, + 0x1838: 68, + 0x1839: 68, + 0x183a: 68, + 0x183b: 68, + 0x183c: 68, + 0x183d: 68, + 0x183e: 68, + 0x183f: 68, + 0x1840: 68, + 0x1841: 68, + 0x1842: 68, + 0x1843: 68, + 0x1844: 68, + 0x1845: 68, + 0x1846: 68, + 0x1847: 68, + 0x1848: 68, + 0x1849: 68, + 0x184a: 68, + 0x184b: 68, + 0x184c: 68, + 0x184d: 68, + 0x184e: 68, + 0x184f: 68, + 0x1850: 68, + 0x1851: 68, + 0x1852: 68, + 0x1853: 68, + 0x1854: 68, + 0x1855: 68, + 0x1856: 68, + 0x1857: 68, + 0x1858: 68, + 0x1859: 68, + 0x185a: 68, + 0x185b: 68, + 0x185c: 68, + 0x185d: 68, + 0x185e: 68, + 0x185f: 68, + 0x1860: 68, + 0x1861: 68, + 0x1862: 68, + 0x1863: 68, + 0x1864: 68, + 0x1865: 68, + 0x1866: 68, + 0x1867: 68, + 0x1868: 68, + 0x1869: 68, + 0x186a: 68, + 0x186b: 68, + 0x186c: 68, + 0x186d: 68, + 0x186e: 68, + 0x186f: 68, + 0x1870: 68, + 0x1871: 68, + 0x1872: 68, + 0x1873: 68, + 0x1874: 68, + 0x1875: 68, + 0x1876: 68, + 0x1877: 68, + 0x1878: 68, + 0x1880: 85, + 0x1881: 85, + 0x1882: 85, + 0x1883: 85, + 0x1884: 85, + 0x1885: 84, + 0x1886: 84, + 0x1887: 68, + 0x1888: 68, + 0x1889: 68, + 0x188a: 68, + 0x188b: 68, + 0x188c: 68, + 0x188d: 68, + 0x188e: 68, + 0x188f: 68, + 0x1890: 68, + 0x1891: 68, + 0x1892: 68, + 0x1893: 68, + 0x1894: 68, + 0x1895: 68, + 0x1896: 68, + 0x1897: 68, + 0x1898: 68, + 0x1899: 68, + 0x189a: 68, + 0x189b: 68, + 0x189c: 68, + 0x189d: 68, + 0x189e: 68, + 0x189f: 68, + 0x18a0: 68, + 0x18a1: 68, + 0x18a2: 68, + 0x18a3: 68, + 0x18a4: 68, + 0x18a5: 68, + 0x18a6: 68, + 0x18a7: 68, + 0x18a8: 68, + 0x18aa: 68, + 0x200c: 85, + 0x200d: 67, + 0x202f: 85, + 0x2066: 85, + 0x2067: 85, + 0x2068: 85, + 0x2069: 85, + 0xa840: 68, + 0xa841: 68, + 0xa842: 68, + 0xa843: 68, + 0xa844: 68, + 0xa845: 68, + 0xa846: 68, + 0xa847: 68, + 0xa848: 68, + 0xa849: 68, + 0xa84a: 68, + 0xa84b: 68, + 0xa84c: 68, + 0xa84d: 68, + 0xa84e: 68, + 0xa84f: 68, + 0xa850: 68, + 0xa851: 68, + 0xa852: 68, + 0xa853: 68, + 0xa854: 68, + 0xa855: 68, + 0xa856: 68, + 0xa857: 68, + 0xa858: 68, + 0xa859: 68, + 0xa85a: 68, + 0xa85b: 68, + 0xa85c: 68, + 0xa85d: 68, + 0xa85e: 68, + 0xa85f: 68, + 0xa860: 68, + 0xa861: 68, + 0xa862: 68, + 0xa863: 68, + 0xa864: 68, + 0xa865: 68, + 0xa866: 68, + 0xa867: 68, + 0xa868: 68, + 0xa869: 68, + 0xa86a: 68, + 0xa86b: 68, + 0xa86c: 68, + 0xa86d: 68, + 0xa86e: 68, + 0xa86f: 68, + 0xa870: 68, + 0xa871: 68, + 0xa872: 76, + 0xa873: 85, + 0x10ac0: 68, + 0x10ac1: 68, + 0x10ac2: 68, + 0x10ac3: 68, + 0x10ac4: 68, + 0x10ac5: 82, + 0x10ac6: 85, + 0x10ac7: 82, + 0x10ac8: 85, + 0x10ac9: 82, + 0x10aca: 82, + 0x10acb: 85, + 0x10acc: 85, + 0x10acd: 76, + 0x10ace: 82, + 0x10acf: 82, + 0x10ad0: 82, + 0x10ad1: 82, + 0x10ad2: 82, + 0x10ad3: 68, + 0x10ad4: 68, + 0x10ad5: 68, + 0x10ad6: 68, + 0x10ad7: 76, + 0x10ad8: 68, + 0x10ad9: 68, + 0x10ada: 68, + 0x10adb: 68, + 0x10adc: 68, + 0x10add: 82, + 0x10ade: 68, + 0x10adf: 68, + 0x10ae0: 68, + 0x10ae1: 82, + 0x10ae2: 85, + 0x10ae3: 85, + 0x10ae4: 82, + 0x10aeb: 68, + 0x10aec: 68, + 0x10aed: 68, + 0x10aee: 68, + 0x10aef: 82, + 0x10b80: 68, + 0x10b81: 82, + 0x10b82: 68, + 0x10b83: 82, + 0x10b84: 82, + 0x10b85: 82, + 0x10b86: 68, + 0x10b87: 68, + 0x10b88: 68, + 0x10b89: 82, + 0x10b8a: 68, + 0x10b8b: 68, + 0x10b8c: 82, + 0x10b8d: 68, + 0x10b8e: 82, + 0x10b8f: 82, + 0x10b90: 68, + 0x10b91: 82, + 0x10ba9: 82, + 0x10baa: 82, + 0x10bab: 82, + 0x10bac: 82, + 0x10bad: 68, + 0x10bae: 68, + 0x10baf: 85, + 0x10d00: 76, + 0x10d01: 68, + 0x10d02: 68, + 0x10d03: 68, + 0x10d04: 68, + 0x10d05: 68, + 0x10d06: 68, + 0x10d07: 68, + 0x10d08: 68, + 0x10d09: 68, + 0x10d0a: 68, + 0x10d0b: 68, + 0x10d0c: 68, + 0x10d0d: 68, + 0x10d0e: 68, + 0x10d0f: 68, + 0x10d10: 68, + 0x10d11: 68, + 0x10d12: 68, + 0x10d13: 68, + 0x10d14: 68, + 0x10d15: 68, + 0x10d16: 68, + 0x10d17: 68, + 0x10d18: 68, + 0x10d19: 68, + 0x10d1a: 68, + 0x10d1b: 68, + 0x10d1c: 68, + 0x10d1d: 68, + 0x10d1e: 68, + 0x10d1f: 68, + 0x10d20: 68, + 0x10d21: 68, + 0x10d22: 82, + 0x10d23: 68, + 0x10f30: 68, + 0x10f31: 68, + 0x10f32: 68, + 0x10f33: 82, + 0x10f34: 68, + 0x10f35: 68, + 0x10f36: 68, + 0x10f37: 68, + 0x10f38: 68, + 0x10f39: 68, + 0x10f3a: 68, + 0x10f3b: 68, + 0x10f3c: 68, + 0x10f3d: 68, + 0x10f3e: 68, + 0x10f3f: 68, + 0x10f40: 68, + 0x10f41: 68, + 0x10f42: 68, + 0x10f43: 68, + 0x10f44: 68, + 0x10f45: 85, + 0x10f51: 68, + 0x10f52: 68, + 0x10f53: 68, + 0x10f54: 82, + 0x110bd: 85, + 0x110cd: 85, + 0x1e900: 68, + 0x1e901: 68, + 0x1e902: 68, + 0x1e903: 68, + 0x1e904: 68, + 0x1e905: 68, + 0x1e906: 68, + 0x1e907: 68, + 0x1e908: 68, + 0x1e909: 68, + 0x1e90a: 68, + 0x1e90b: 68, + 0x1e90c: 68, + 0x1e90d: 68, + 0x1e90e: 68, + 0x1e90f: 68, + 0x1e910: 68, + 0x1e911: 68, + 0x1e912: 68, + 0x1e913: 68, + 0x1e914: 68, + 0x1e915: 68, + 0x1e916: 68, + 0x1e917: 68, + 0x1e918: 68, + 0x1e919: 68, + 0x1e91a: 68, + 0x1e91b: 68, + 0x1e91c: 68, + 0x1e91d: 68, + 0x1e91e: 68, + 0x1e91f: 68, + 0x1e920: 68, + 0x1e921: 68, + 0x1e922: 68, + 0x1e923: 68, + 0x1e924: 68, + 0x1e925: 68, + 0x1e926: 68, + 0x1e927: 68, + 0x1e928: 68, + 0x1e929: 68, + 0x1e92a: 68, + 0x1e92b: 68, + 0x1e92c: 68, + 0x1e92d: 68, + 0x1e92e: 68, + 0x1e92f: 68, + 0x1e930: 68, + 0x1e931: 68, + 0x1e932: 68, + 0x1e933: 68, + 0x1e934: 68, + 0x1e935: 68, + 0x1e936: 68, + 0x1e937: 68, + 0x1e938: 68, + 0x1e939: 68, + 0x1e93a: 68, + 0x1e93b: 68, + 0x1e93c: 68, + 0x1e93d: 68, + 0x1e93e: 68, + 0x1e93f: 68, + 0x1e940: 68, + 0x1e941: 68, + 0x1e942: 68, + 0x1e943: 68, +} +codepoint_classes = { + 'PVALID': ( + 0x2d0000002e, + 0x300000003a, + 0x610000007b, + 0xdf000000f7, + 0xf800000100, + 0x10100000102, + 0x10300000104, + 0x10500000106, + 0x10700000108, + 0x1090000010a, + 0x10b0000010c, + 0x10d0000010e, + 0x10f00000110, + 0x11100000112, + 0x11300000114, + 0x11500000116, + 0x11700000118, + 0x1190000011a, + 0x11b0000011c, + 0x11d0000011e, + 0x11f00000120, + 0x12100000122, + 0x12300000124, + 0x12500000126, + 0x12700000128, + 0x1290000012a, + 0x12b0000012c, + 0x12d0000012e, + 0x12f00000130, + 0x13100000132, + 0x13500000136, + 0x13700000139, + 0x13a0000013b, + 0x13c0000013d, + 0x13e0000013f, + 0x14200000143, + 0x14400000145, + 0x14600000147, + 0x14800000149, + 0x14b0000014c, + 0x14d0000014e, + 0x14f00000150, + 0x15100000152, + 0x15300000154, + 0x15500000156, + 0x15700000158, + 0x1590000015a, + 0x15b0000015c, + 0x15d0000015e, + 0x15f00000160, + 0x16100000162, + 0x16300000164, + 0x16500000166, + 0x16700000168, + 0x1690000016a, + 0x16b0000016c, + 0x16d0000016e, + 0x16f00000170, + 0x17100000172, + 0x17300000174, + 0x17500000176, + 0x17700000178, + 0x17a0000017b, + 0x17c0000017d, + 0x17e0000017f, + 0x18000000181, + 0x18300000184, + 0x18500000186, + 0x18800000189, + 0x18c0000018e, + 0x19200000193, + 0x19500000196, + 0x1990000019c, + 0x19e0000019f, + 0x1a1000001a2, + 0x1a3000001a4, + 0x1a5000001a6, + 0x1a8000001a9, + 0x1aa000001ac, + 0x1ad000001ae, + 0x1b0000001b1, + 0x1b4000001b5, + 0x1b6000001b7, + 0x1b9000001bc, + 0x1bd000001c4, + 0x1ce000001cf, + 0x1d0000001d1, + 0x1d2000001d3, + 0x1d4000001d5, + 0x1d6000001d7, + 0x1d8000001d9, + 0x1da000001db, + 0x1dc000001de, + 0x1df000001e0, + 0x1e1000001e2, + 0x1e3000001e4, + 0x1e5000001e6, + 0x1e7000001e8, + 0x1e9000001ea, + 0x1eb000001ec, + 0x1ed000001ee, + 0x1ef000001f1, + 0x1f5000001f6, + 0x1f9000001fa, + 0x1fb000001fc, + 0x1fd000001fe, + 0x1ff00000200, + 0x20100000202, + 0x20300000204, + 0x20500000206, + 0x20700000208, + 0x2090000020a, + 0x20b0000020c, + 0x20d0000020e, + 0x20f00000210, + 0x21100000212, + 0x21300000214, + 0x21500000216, + 0x21700000218, + 0x2190000021a, + 0x21b0000021c, + 0x21d0000021e, + 0x21f00000220, + 0x22100000222, + 0x22300000224, + 0x22500000226, + 0x22700000228, + 0x2290000022a, + 0x22b0000022c, + 0x22d0000022e, + 0x22f00000230, + 0x23100000232, + 0x2330000023a, + 0x23c0000023d, + 0x23f00000241, + 0x24200000243, + 0x24700000248, + 0x2490000024a, + 0x24b0000024c, + 0x24d0000024e, + 0x24f000002b0, + 0x2b9000002c2, + 0x2c6000002d2, + 0x2ec000002ed, + 0x2ee000002ef, + 0x30000000340, + 0x34200000343, + 0x3460000034f, + 0x35000000370, + 0x37100000372, + 0x37300000374, + 0x37700000378, + 0x37b0000037e, + 0x39000000391, + 0x3ac000003cf, + 0x3d7000003d8, + 0x3d9000003da, + 0x3db000003dc, + 0x3dd000003de, + 0x3df000003e0, + 0x3e1000003e2, + 0x3e3000003e4, + 0x3e5000003e6, + 0x3e7000003e8, + 0x3e9000003ea, + 0x3eb000003ec, + 0x3ed000003ee, + 0x3ef000003f0, + 0x3f3000003f4, + 0x3f8000003f9, + 0x3fb000003fd, + 0x43000000460, + 0x46100000462, + 0x46300000464, + 0x46500000466, + 0x46700000468, + 0x4690000046a, + 0x46b0000046c, + 0x46d0000046e, + 0x46f00000470, + 0x47100000472, + 0x47300000474, + 0x47500000476, + 0x47700000478, + 0x4790000047a, + 0x47b0000047c, + 0x47d0000047e, + 0x47f00000480, + 0x48100000482, + 0x48300000488, + 0x48b0000048c, + 0x48d0000048e, + 0x48f00000490, + 0x49100000492, + 0x49300000494, + 0x49500000496, + 0x49700000498, + 0x4990000049a, + 0x49b0000049c, + 0x49d0000049e, + 0x49f000004a0, + 0x4a1000004a2, + 0x4a3000004a4, + 0x4a5000004a6, + 0x4a7000004a8, + 0x4a9000004aa, + 0x4ab000004ac, + 0x4ad000004ae, + 0x4af000004b0, + 0x4b1000004b2, + 0x4b3000004b4, + 0x4b5000004b6, + 0x4b7000004b8, + 0x4b9000004ba, + 0x4bb000004bc, + 0x4bd000004be, + 0x4bf000004c0, + 0x4c2000004c3, + 0x4c4000004c5, + 0x4c6000004c7, + 0x4c8000004c9, + 0x4ca000004cb, + 0x4cc000004cd, + 0x4ce000004d0, + 0x4d1000004d2, + 0x4d3000004d4, + 0x4d5000004d6, + 0x4d7000004d8, + 0x4d9000004da, + 0x4db000004dc, + 0x4dd000004de, + 0x4df000004e0, + 0x4e1000004e2, + 0x4e3000004e4, + 0x4e5000004e6, + 0x4e7000004e8, + 0x4e9000004ea, + 0x4eb000004ec, + 0x4ed000004ee, + 0x4ef000004f0, + 0x4f1000004f2, + 0x4f3000004f4, + 0x4f5000004f6, + 0x4f7000004f8, + 0x4f9000004fa, + 0x4fb000004fc, + 0x4fd000004fe, + 0x4ff00000500, + 0x50100000502, + 0x50300000504, + 0x50500000506, + 0x50700000508, + 0x5090000050a, + 0x50b0000050c, + 0x50d0000050e, + 0x50f00000510, + 0x51100000512, + 0x51300000514, + 0x51500000516, + 0x51700000518, + 0x5190000051a, + 0x51b0000051c, + 0x51d0000051e, + 0x51f00000520, + 0x52100000522, + 0x52300000524, + 0x52500000526, + 0x52700000528, + 0x5290000052a, + 0x52b0000052c, + 0x52d0000052e, + 0x52f00000530, + 0x5590000055a, + 0x56000000587, + 0x58800000589, + 0x591000005be, + 0x5bf000005c0, + 0x5c1000005c3, + 0x5c4000005c6, + 0x5c7000005c8, + 0x5d0000005eb, + 0x5ef000005f3, + 0x6100000061b, + 0x62000000640, + 0x64100000660, + 0x66e00000675, + 0x679000006d4, + 0x6d5000006dd, + 0x6df000006e9, + 0x6ea000006f0, + 0x6fa00000700, + 0x7100000074b, + 0x74d000007b2, + 0x7c0000007f6, + 0x7fd000007fe, + 0x8000000082e, + 0x8400000085c, + 0x8600000086b, + 0x8a0000008b5, + 0x8b6000008be, + 0x8d3000008e2, + 0x8e300000958, + 0x96000000964, + 0x96600000970, + 0x97100000984, + 0x9850000098d, + 0x98f00000991, + 0x993000009a9, + 0x9aa000009b1, + 0x9b2000009b3, + 0x9b6000009ba, + 0x9bc000009c5, + 0x9c7000009c9, + 0x9cb000009cf, + 0x9d7000009d8, + 0x9e0000009e4, + 0x9e6000009f2, + 0x9fc000009fd, + 0x9fe000009ff, + 0xa0100000a04, + 0xa0500000a0b, + 0xa0f00000a11, + 0xa1300000a29, + 0xa2a00000a31, + 0xa3200000a33, + 0xa3500000a36, + 0xa3800000a3a, + 0xa3c00000a3d, + 0xa3e00000a43, + 0xa4700000a49, + 0xa4b00000a4e, + 0xa5100000a52, + 0xa5c00000a5d, + 0xa6600000a76, + 0xa8100000a84, + 0xa8500000a8e, + 0xa8f00000a92, + 0xa9300000aa9, + 0xaaa00000ab1, + 0xab200000ab4, + 0xab500000aba, + 0xabc00000ac6, + 0xac700000aca, + 0xacb00000ace, + 0xad000000ad1, + 0xae000000ae4, + 0xae600000af0, + 0xaf900000b00, + 0xb0100000b04, + 0xb0500000b0d, + 0xb0f00000b11, + 0xb1300000b29, + 0xb2a00000b31, + 0xb3200000b34, + 0xb3500000b3a, + 0xb3c00000b45, + 0xb4700000b49, + 0xb4b00000b4e, + 0xb5600000b58, + 0xb5f00000b64, + 0xb6600000b70, + 0xb7100000b72, + 0xb8200000b84, + 0xb8500000b8b, + 0xb8e00000b91, + 0xb9200000b96, + 0xb9900000b9b, + 0xb9c00000b9d, + 0xb9e00000ba0, + 0xba300000ba5, + 0xba800000bab, + 0xbae00000bba, + 0xbbe00000bc3, + 0xbc600000bc9, + 0xbca00000bce, + 0xbd000000bd1, + 0xbd700000bd8, + 0xbe600000bf0, + 0xc0000000c0d, + 0xc0e00000c11, + 0xc1200000c29, + 0xc2a00000c3a, + 0xc3d00000c45, + 0xc4600000c49, + 0xc4a00000c4e, + 0xc5500000c57, + 0xc5800000c5b, + 0xc6000000c64, + 0xc6600000c70, + 0xc8000000c84, + 0xc8500000c8d, + 0xc8e00000c91, + 0xc9200000ca9, + 0xcaa00000cb4, + 0xcb500000cba, + 0xcbc00000cc5, + 0xcc600000cc9, + 0xcca00000cce, + 0xcd500000cd7, + 0xcde00000cdf, + 0xce000000ce4, + 0xce600000cf0, + 0xcf100000cf3, + 0xd0000000d04, + 0xd0500000d0d, + 0xd0e00000d11, + 0xd1200000d45, + 0xd4600000d49, + 0xd4a00000d4f, + 0xd5400000d58, + 0xd5f00000d64, + 0xd6600000d70, + 0xd7a00000d80, + 0xd8200000d84, + 0xd8500000d97, + 0xd9a00000db2, + 0xdb300000dbc, + 0xdbd00000dbe, + 0xdc000000dc7, + 0xdca00000dcb, + 0xdcf00000dd5, + 0xdd600000dd7, + 0xdd800000de0, + 0xde600000df0, + 0xdf200000df4, + 0xe0100000e33, + 0xe3400000e3b, + 0xe4000000e4f, + 0xe5000000e5a, + 0xe8100000e83, + 0xe8400000e85, + 0xe8700000e89, + 0xe8a00000e8b, + 0xe8d00000e8e, + 0xe9400000e98, + 0xe9900000ea0, + 0xea100000ea4, + 0xea500000ea6, + 0xea700000ea8, + 0xeaa00000eac, + 0xead00000eb3, + 0xeb400000eba, + 0xebb00000ebe, + 0xec000000ec5, + 0xec600000ec7, + 0xec800000ece, + 0xed000000eda, + 0xede00000ee0, + 0xf0000000f01, + 0xf0b00000f0c, + 0xf1800000f1a, + 0xf2000000f2a, + 0xf3500000f36, + 0xf3700000f38, + 0xf3900000f3a, + 0xf3e00000f43, + 0xf4400000f48, + 0xf4900000f4d, + 0xf4e00000f52, + 0xf5300000f57, + 0xf5800000f5c, + 0xf5d00000f69, + 0xf6a00000f6d, + 0xf7100000f73, + 0xf7400000f75, + 0xf7a00000f81, + 0xf8200000f85, + 0xf8600000f93, + 0xf9400000f98, + 0xf9900000f9d, + 0xf9e00000fa2, + 0xfa300000fa7, + 0xfa800000fac, + 0xfad00000fb9, + 0xfba00000fbd, + 0xfc600000fc7, + 0x10000000104a, + 0x10500000109e, + 0x10d0000010fb, + 0x10fd00001100, + 0x120000001249, + 0x124a0000124e, + 0x125000001257, + 0x125800001259, + 0x125a0000125e, + 0x126000001289, + 0x128a0000128e, + 0x1290000012b1, + 0x12b2000012b6, + 0x12b8000012bf, + 0x12c0000012c1, + 0x12c2000012c6, + 0x12c8000012d7, + 0x12d800001311, + 0x131200001316, + 0x13180000135b, + 0x135d00001360, + 0x138000001390, + 0x13a0000013f6, + 0x14010000166d, + 0x166f00001680, + 0x16810000169b, + 0x16a0000016eb, + 0x16f1000016f9, + 0x17000000170d, + 0x170e00001715, + 0x172000001735, + 0x174000001754, + 0x17600000176d, + 0x176e00001771, + 0x177200001774, + 0x1780000017b4, + 0x17b6000017d4, + 0x17d7000017d8, + 0x17dc000017de, + 0x17e0000017ea, + 0x18100000181a, + 0x182000001879, + 0x1880000018ab, + 0x18b0000018f6, + 0x19000000191f, + 0x19200000192c, + 0x19300000193c, + 0x19460000196e, + 0x197000001975, + 0x1980000019ac, + 0x19b0000019ca, + 0x19d0000019da, + 0x1a0000001a1c, + 0x1a2000001a5f, + 0x1a6000001a7d, + 0x1a7f00001a8a, + 0x1a9000001a9a, + 0x1aa700001aa8, + 0x1ab000001abe, + 0x1b0000001b4c, + 0x1b5000001b5a, + 0x1b6b00001b74, + 0x1b8000001bf4, + 0x1c0000001c38, + 0x1c4000001c4a, + 0x1c4d00001c7e, + 0x1cd000001cd3, + 0x1cd400001cfa, + 0x1d0000001d2c, + 0x1d2f00001d30, + 0x1d3b00001d3c, + 0x1d4e00001d4f, + 0x1d6b00001d78, + 0x1d7900001d9b, + 0x1dc000001dfa, + 0x1dfb00001e00, + 0x1e0100001e02, + 0x1e0300001e04, + 0x1e0500001e06, + 0x1e0700001e08, + 0x1e0900001e0a, + 0x1e0b00001e0c, + 0x1e0d00001e0e, + 0x1e0f00001e10, + 0x1e1100001e12, + 0x1e1300001e14, + 0x1e1500001e16, + 0x1e1700001e18, + 0x1e1900001e1a, + 0x1e1b00001e1c, + 0x1e1d00001e1e, + 0x1e1f00001e20, + 0x1e2100001e22, + 0x1e2300001e24, + 0x1e2500001e26, + 0x1e2700001e28, + 0x1e2900001e2a, + 0x1e2b00001e2c, + 0x1e2d00001e2e, + 0x1e2f00001e30, + 0x1e3100001e32, + 0x1e3300001e34, + 0x1e3500001e36, + 0x1e3700001e38, + 0x1e3900001e3a, + 0x1e3b00001e3c, + 0x1e3d00001e3e, + 0x1e3f00001e40, + 0x1e4100001e42, + 0x1e4300001e44, + 0x1e4500001e46, + 0x1e4700001e48, + 0x1e4900001e4a, + 0x1e4b00001e4c, + 0x1e4d00001e4e, + 0x1e4f00001e50, + 0x1e5100001e52, + 0x1e5300001e54, + 0x1e5500001e56, + 0x1e5700001e58, + 0x1e5900001e5a, + 0x1e5b00001e5c, + 0x1e5d00001e5e, + 0x1e5f00001e60, + 0x1e6100001e62, + 0x1e6300001e64, + 0x1e6500001e66, + 0x1e6700001e68, + 0x1e6900001e6a, + 0x1e6b00001e6c, + 0x1e6d00001e6e, + 0x1e6f00001e70, + 0x1e7100001e72, + 0x1e7300001e74, + 0x1e7500001e76, + 0x1e7700001e78, + 0x1e7900001e7a, + 0x1e7b00001e7c, + 0x1e7d00001e7e, + 0x1e7f00001e80, + 0x1e8100001e82, + 0x1e8300001e84, + 0x1e8500001e86, + 0x1e8700001e88, + 0x1e8900001e8a, + 0x1e8b00001e8c, + 0x1e8d00001e8e, + 0x1e8f00001e90, + 0x1e9100001e92, + 0x1e9300001e94, + 0x1e9500001e9a, + 0x1e9c00001e9e, + 0x1e9f00001ea0, + 0x1ea100001ea2, + 0x1ea300001ea4, + 0x1ea500001ea6, + 0x1ea700001ea8, + 0x1ea900001eaa, + 0x1eab00001eac, + 0x1ead00001eae, + 0x1eaf00001eb0, + 0x1eb100001eb2, + 0x1eb300001eb4, + 0x1eb500001eb6, + 0x1eb700001eb8, + 0x1eb900001eba, + 0x1ebb00001ebc, + 0x1ebd00001ebe, + 0x1ebf00001ec0, + 0x1ec100001ec2, + 0x1ec300001ec4, + 0x1ec500001ec6, + 0x1ec700001ec8, + 0x1ec900001eca, + 0x1ecb00001ecc, + 0x1ecd00001ece, + 0x1ecf00001ed0, + 0x1ed100001ed2, + 0x1ed300001ed4, + 0x1ed500001ed6, + 0x1ed700001ed8, + 0x1ed900001eda, + 0x1edb00001edc, + 0x1edd00001ede, + 0x1edf00001ee0, + 0x1ee100001ee2, + 0x1ee300001ee4, + 0x1ee500001ee6, + 0x1ee700001ee8, + 0x1ee900001eea, + 0x1eeb00001eec, + 0x1eed00001eee, + 0x1eef00001ef0, + 0x1ef100001ef2, + 0x1ef300001ef4, + 0x1ef500001ef6, + 0x1ef700001ef8, + 0x1ef900001efa, + 0x1efb00001efc, + 0x1efd00001efe, + 0x1eff00001f08, + 0x1f1000001f16, + 0x1f2000001f28, + 0x1f3000001f38, + 0x1f4000001f46, + 0x1f5000001f58, + 0x1f6000001f68, + 0x1f7000001f71, + 0x1f7200001f73, + 0x1f7400001f75, + 0x1f7600001f77, + 0x1f7800001f79, + 0x1f7a00001f7b, + 0x1f7c00001f7d, + 0x1fb000001fb2, + 0x1fb600001fb7, + 0x1fc600001fc7, + 0x1fd000001fd3, + 0x1fd600001fd8, + 0x1fe000001fe3, + 0x1fe400001fe8, + 0x1ff600001ff7, + 0x214e0000214f, + 0x218400002185, + 0x2c3000002c5f, + 0x2c6100002c62, + 0x2c6500002c67, + 0x2c6800002c69, + 0x2c6a00002c6b, + 0x2c6c00002c6d, + 0x2c7100002c72, + 0x2c7300002c75, + 0x2c7600002c7c, + 0x2c8100002c82, + 0x2c8300002c84, + 0x2c8500002c86, + 0x2c8700002c88, + 0x2c8900002c8a, + 0x2c8b00002c8c, + 0x2c8d00002c8e, + 0x2c8f00002c90, + 0x2c9100002c92, + 0x2c9300002c94, + 0x2c9500002c96, + 0x2c9700002c98, + 0x2c9900002c9a, + 0x2c9b00002c9c, + 0x2c9d00002c9e, + 0x2c9f00002ca0, + 0x2ca100002ca2, + 0x2ca300002ca4, + 0x2ca500002ca6, + 0x2ca700002ca8, + 0x2ca900002caa, + 0x2cab00002cac, + 0x2cad00002cae, + 0x2caf00002cb0, + 0x2cb100002cb2, + 0x2cb300002cb4, + 0x2cb500002cb6, + 0x2cb700002cb8, + 0x2cb900002cba, + 0x2cbb00002cbc, + 0x2cbd00002cbe, + 0x2cbf00002cc0, + 0x2cc100002cc2, + 0x2cc300002cc4, + 0x2cc500002cc6, + 0x2cc700002cc8, + 0x2cc900002cca, + 0x2ccb00002ccc, + 0x2ccd00002cce, + 0x2ccf00002cd0, + 0x2cd100002cd2, + 0x2cd300002cd4, + 0x2cd500002cd6, + 0x2cd700002cd8, + 0x2cd900002cda, + 0x2cdb00002cdc, + 0x2cdd00002cde, + 0x2cdf00002ce0, + 0x2ce100002ce2, + 0x2ce300002ce5, + 0x2cec00002ced, + 0x2cee00002cf2, + 0x2cf300002cf4, + 0x2d0000002d26, + 0x2d2700002d28, + 0x2d2d00002d2e, + 0x2d3000002d68, + 0x2d7f00002d97, + 0x2da000002da7, + 0x2da800002daf, + 0x2db000002db7, + 0x2db800002dbf, + 0x2dc000002dc7, + 0x2dc800002dcf, + 0x2dd000002dd7, + 0x2dd800002ddf, + 0x2de000002e00, + 0x2e2f00002e30, + 0x300500003008, + 0x302a0000302e, + 0x303c0000303d, + 0x304100003097, + 0x30990000309b, + 0x309d0000309f, + 0x30a1000030fb, + 0x30fc000030ff, + 0x310500003130, + 0x31a0000031bb, + 0x31f000003200, + 0x340000004db6, + 0x4e0000009ff0, + 0xa0000000a48d, + 0xa4d00000a4fe, + 0xa5000000a60d, + 0xa6100000a62c, + 0xa6410000a642, + 0xa6430000a644, + 0xa6450000a646, + 0xa6470000a648, + 0xa6490000a64a, + 0xa64b0000a64c, + 0xa64d0000a64e, + 0xa64f0000a650, + 0xa6510000a652, + 0xa6530000a654, + 0xa6550000a656, + 0xa6570000a658, + 0xa6590000a65a, + 0xa65b0000a65c, + 0xa65d0000a65e, + 0xa65f0000a660, + 0xa6610000a662, + 0xa6630000a664, + 0xa6650000a666, + 0xa6670000a668, + 0xa6690000a66a, + 0xa66b0000a66c, + 0xa66d0000a670, + 0xa6740000a67e, + 0xa67f0000a680, + 0xa6810000a682, + 0xa6830000a684, + 0xa6850000a686, + 0xa6870000a688, + 0xa6890000a68a, + 0xa68b0000a68c, + 0xa68d0000a68e, + 0xa68f0000a690, + 0xa6910000a692, + 0xa6930000a694, + 0xa6950000a696, + 0xa6970000a698, + 0xa6990000a69a, + 0xa69b0000a69c, + 0xa69e0000a6e6, + 0xa6f00000a6f2, + 0xa7170000a720, + 0xa7230000a724, + 0xa7250000a726, + 0xa7270000a728, + 0xa7290000a72a, + 0xa72b0000a72c, + 0xa72d0000a72e, + 0xa72f0000a732, + 0xa7330000a734, + 0xa7350000a736, + 0xa7370000a738, + 0xa7390000a73a, + 0xa73b0000a73c, + 0xa73d0000a73e, + 0xa73f0000a740, + 0xa7410000a742, + 0xa7430000a744, + 0xa7450000a746, + 0xa7470000a748, + 0xa7490000a74a, + 0xa74b0000a74c, + 0xa74d0000a74e, + 0xa74f0000a750, + 0xa7510000a752, + 0xa7530000a754, + 0xa7550000a756, + 0xa7570000a758, + 0xa7590000a75a, + 0xa75b0000a75c, + 0xa75d0000a75e, + 0xa75f0000a760, + 0xa7610000a762, + 0xa7630000a764, + 0xa7650000a766, + 0xa7670000a768, + 0xa7690000a76a, + 0xa76b0000a76c, + 0xa76d0000a76e, + 0xa76f0000a770, + 0xa7710000a779, + 0xa77a0000a77b, + 0xa77c0000a77d, + 0xa77f0000a780, + 0xa7810000a782, + 0xa7830000a784, + 0xa7850000a786, + 0xa7870000a789, + 0xa78c0000a78d, + 0xa78e0000a790, + 0xa7910000a792, + 0xa7930000a796, + 0xa7970000a798, + 0xa7990000a79a, + 0xa79b0000a79c, + 0xa79d0000a79e, + 0xa79f0000a7a0, + 0xa7a10000a7a2, + 0xa7a30000a7a4, + 0xa7a50000a7a6, + 0xa7a70000a7a8, + 0xa7a90000a7aa, + 0xa7af0000a7b0, + 0xa7b50000a7b6, + 0xa7b70000a7b8, + 0xa7b90000a7ba, + 0xa7f70000a7f8, + 0xa7fa0000a828, + 0xa8400000a874, + 0xa8800000a8c6, + 0xa8d00000a8da, + 0xa8e00000a8f8, + 0xa8fb0000a8fc, + 0xa8fd0000a92e, + 0xa9300000a954, + 0xa9800000a9c1, + 0xa9cf0000a9da, + 0xa9e00000a9ff, + 0xaa000000aa37, + 0xaa400000aa4e, + 0xaa500000aa5a, + 0xaa600000aa77, + 0xaa7a0000aac3, + 0xaadb0000aade, + 0xaae00000aaf0, + 0xaaf20000aaf7, + 0xab010000ab07, + 0xab090000ab0f, + 0xab110000ab17, + 0xab200000ab27, + 0xab280000ab2f, + 0xab300000ab5b, + 0xab600000ab66, + 0xabc00000abeb, + 0xabec0000abee, + 0xabf00000abfa, + 0xac000000d7a4, + 0xfa0e0000fa10, + 0xfa110000fa12, + 0xfa130000fa15, + 0xfa1f0000fa20, + 0xfa210000fa22, + 0xfa230000fa25, + 0xfa270000fa2a, + 0xfb1e0000fb1f, + 0xfe200000fe30, + 0xfe730000fe74, + 0x100000001000c, + 0x1000d00010027, + 0x100280001003b, + 0x1003c0001003e, + 0x1003f0001004e, + 0x100500001005e, + 0x10080000100fb, + 0x101fd000101fe, + 0x102800001029d, + 0x102a0000102d1, + 0x102e0000102e1, + 0x1030000010320, + 0x1032d00010341, + 0x103420001034a, + 0x103500001037b, + 0x103800001039e, + 0x103a0000103c4, + 0x103c8000103d0, + 0x104280001049e, + 0x104a0000104aa, + 0x104d8000104fc, + 0x1050000010528, + 0x1053000010564, + 0x1060000010737, + 0x1074000010756, + 0x1076000010768, + 0x1080000010806, + 0x1080800010809, + 0x1080a00010836, + 0x1083700010839, + 0x1083c0001083d, + 0x1083f00010856, + 0x1086000010877, + 0x108800001089f, + 0x108e0000108f3, + 0x108f4000108f6, + 0x1090000010916, + 0x109200001093a, + 0x10980000109b8, + 0x109be000109c0, + 0x10a0000010a04, + 0x10a0500010a07, + 0x10a0c00010a14, + 0x10a1500010a18, + 0x10a1900010a36, + 0x10a3800010a3b, + 0x10a3f00010a40, + 0x10a6000010a7d, + 0x10a8000010a9d, + 0x10ac000010ac8, + 0x10ac900010ae7, + 0x10b0000010b36, + 0x10b4000010b56, + 0x10b6000010b73, + 0x10b8000010b92, + 0x10c0000010c49, + 0x10cc000010cf3, + 0x10d0000010d28, + 0x10d3000010d3a, + 0x10f0000010f1d, + 0x10f2700010f28, + 0x10f3000010f51, + 0x1100000011047, + 0x1106600011070, + 0x1107f000110bb, + 0x110d0000110e9, + 0x110f0000110fa, + 0x1110000011135, + 0x1113600011140, + 0x1114400011147, + 0x1115000011174, + 0x1117600011177, + 0x11180000111c5, + 0x111c9000111cd, + 0x111d0000111db, + 0x111dc000111dd, + 0x1120000011212, + 0x1121300011238, + 0x1123e0001123f, + 0x1128000011287, + 0x1128800011289, + 0x1128a0001128e, + 0x1128f0001129e, + 0x1129f000112a9, + 0x112b0000112eb, + 0x112f0000112fa, + 0x1130000011304, + 0x113050001130d, + 0x1130f00011311, + 0x1131300011329, + 0x1132a00011331, + 0x1133200011334, + 0x113350001133a, + 0x1133b00011345, + 0x1134700011349, + 0x1134b0001134e, + 0x1135000011351, + 0x1135700011358, + 0x1135d00011364, + 0x113660001136d, + 0x1137000011375, + 0x114000001144b, + 0x114500001145a, + 0x1145e0001145f, + 0x11480000114c6, + 0x114c7000114c8, + 0x114d0000114da, + 0x11580000115b6, + 0x115b8000115c1, + 0x115d8000115de, + 0x1160000011641, + 0x1164400011645, + 0x116500001165a, + 0x11680000116b8, + 0x116c0000116ca, + 0x117000001171b, + 0x1171d0001172c, + 0x117300001173a, + 0x118000001183b, + 0x118c0000118ea, + 0x118ff00011900, + 0x11a0000011a3f, + 0x11a4700011a48, + 0x11a5000011a84, + 0x11a8600011a9a, + 0x11a9d00011a9e, + 0x11ac000011af9, + 0x11c0000011c09, + 0x11c0a00011c37, + 0x11c3800011c41, + 0x11c5000011c5a, + 0x11c7200011c90, + 0x11c9200011ca8, + 0x11ca900011cb7, + 0x11d0000011d07, + 0x11d0800011d0a, + 0x11d0b00011d37, + 0x11d3a00011d3b, + 0x11d3c00011d3e, + 0x11d3f00011d48, + 0x11d5000011d5a, + 0x11d6000011d66, + 0x11d6700011d69, + 0x11d6a00011d8f, + 0x11d9000011d92, + 0x11d9300011d99, + 0x11da000011daa, + 0x11ee000011ef7, + 0x120000001239a, + 0x1248000012544, + 0x130000001342f, + 0x1440000014647, + 0x1680000016a39, + 0x16a4000016a5f, + 0x16a6000016a6a, + 0x16ad000016aee, + 0x16af000016af5, + 0x16b0000016b37, + 0x16b4000016b44, + 0x16b5000016b5a, + 0x16b6300016b78, + 0x16b7d00016b90, + 0x16e6000016e80, + 0x16f0000016f45, + 0x16f5000016f7f, + 0x16f8f00016fa0, + 0x16fe000016fe2, + 0x17000000187f2, + 0x1880000018af3, + 0x1b0000001b11f, + 0x1b1700001b2fc, + 0x1bc000001bc6b, + 0x1bc700001bc7d, + 0x1bc800001bc89, + 0x1bc900001bc9a, + 0x1bc9d0001bc9f, + 0x1da000001da37, + 0x1da3b0001da6d, + 0x1da750001da76, + 0x1da840001da85, + 0x1da9b0001daa0, + 0x1daa10001dab0, + 0x1e0000001e007, + 0x1e0080001e019, + 0x1e01b0001e022, + 0x1e0230001e025, + 0x1e0260001e02b, + 0x1e8000001e8c5, + 0x1e8d00001e8d7, + 0x1e9220001e94b, + 0x1e9500001e95a, + 0x200000002a6d7, + 0x2a7000002b735, + 0x2b7400002b81e, + 0x2b8200002cea2, + 0x2ceb00002ebe1, + ), + 'CONTEXTJ': ( + 0x200c0000200e, + ), + 'CONTEXTO': ( + 0xb7000000b8, + 0x37500000376, + 0x5f3000005f5, + 0x6600000066a, + 0x6f0000006fa, + 0x30fb000030fc, + ), +} diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/intranges.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/intranges.py new file mode 100644 index 0000000000000000000000000000000000000000..fa8a735662d0afc1950ba75bc57e99e8480dac88 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/intranges.py @@ -0,0 +1,53 @@ +""" +Given a list of integers, made up of (hopefully) a small number of long runs +of consecutive integers, compute a representation of the form +((start1, end1), (start2, end2) ...). Then answer the question "was x present +in the original list?" in time O(log(# runs)). +""" + +import bisect + +def intranges_from_list(list_): + """Represent a list of integers as a sequence of ranges: + ((start_0, end_0), (start_1, end_1), ...), such that the original + integers are exactly those x such that start_i <= x < end_i for some i. + + Ranges are encoded as single integers (start << 32 | end), not as tuples. + """ + + sorted_list = sorted(list_) + ranges = [] + last_write = -1 + for i in range(len(sorted_list)): + if i+1 < len(sorted_list): + if sorted_list[i] == sorted_list[i+1]-1: + continue + current_range = sorted_list[last_write+1:i+1] + ranges.append(_encode_range(current_range[0], current_range[-1] + 1)) + last_write = i + + return tuple(ranges) + +def _encode_range(start, end): + return (start << 32) | end + +def _decode_range(r): + return (r >> 32), (r & ((1 << 32) - 1)) + + +def intranges_contain(int_, ranges): + """Determine if `int_` falls into one of the ranges in `ranges`.""" + tuple_ = _encode_range(int_, 0) + pos = bisect.bisect_left(ranges, tuple_) + # we could be immediately ahead of a tuple (start, end) + # with start < int_ <= end + if pos > 0: + left, right = _decode_range(ranges[pos-1]) + if left <= int_ < right: + return True + # or we could be immediately behind a tuple (int_, end) + if pos < len(ranges): + left, _ = _decode_range(ranges[pos]) + if left == int_: + return True + return False diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/package_data.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/package_data.py new file mode 100644 index 0000000000000000000000000000000000000000..257e8989393055bec9bf86010828fb8bab7a9645 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/package_data.py @@ -0,0 +1,2 @@ +__version__ = '2.8' + diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/uts46data.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/uts46data.py new file mode 100644 index 0000000000000000000000000000000000000000..a68ed4c0ec3d3a5ffd400dbe8ffb0ec470eb2b66 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/idna/uts46data.py @@ -0,0 +1,8205 @@ +# This file is automatically generated by tools/idna-data +# vim: set fileencoding=utf-8 : + +"""IDNA Mapping Table from UTS46.""" + + +__version__ = "11.0.0" +def _seg_0(): + return [ + (0x0, '3'), + (0x1, '3'), + (0x2, '3'), + (0x3, '3'), + (0x4, '3'), + (0x5, '3'), + (0x6, '3'), + (0x7, '3'), + (0x8, '3'), + (0x9, '3'), + (0xA, '3'), + (0xB, '3'), + (0xC, '3'), + (0xD, '3'), + (0xE, '3'), + (0xF, '3'), + (0x10, '3'), + (0x11, '3'), + (0x12, '3'), + (0x13, '3'), + (0x14, '3'), + (0x15, '3'), + (0x16, '3'), + (0x17, '3'), + (0x18, '3'), + (0x19, '3'), + (0x1A, '3'), + (0x1B, '3'), + (0x1C, '3'), + (0x1D, '3'), + (0x1E, '3'), + (0x1F, '3'), + (0x20, '3'), + (0x21, '3'), + (0x22, '3'), + (0x23, '3'), + (0x24, '3'), + (0x25, '3'), + (0x26, '3'), + (0x27, '3'), + (0x28, '3'), + (0x29, '3'), + (0x2A, '3'), + (0x2B, '3'), + (0x2C, '3'), + (0x2D, 'V'), + (0x2E, 'V'), + (0x2F, '3'), + (0x30, 'V'), + (0x31, 'V'), + (0x32, 'V'), + (0x33, 'V'), + (0x34, 'V'), + (0x35, 'V'), + (0x36, 'V'), + (0x37, 'V'), + (0x38, 'V'), + (0x39, 'V'), + (0x3A, '3'), + (0x3B, '3'), + (0x3C, '3'), + (0x3D, '3'), + (0x3E, '3'), + (0x3F, '3'), + (0x40, '3'), + (0x41, 'M', u'a'), + (0x42, 'M', u'b'), + (0x43, 'M', u'c'), + (0x44, 'M', u'd'), + (0x45, 'M', u'e'), + (0x46, 'M', u'f'), + (0x47, 'M', u'g'), + (0x48, 'M', u'h'), + (0x49, 'M', u'i'), + (0x4A, 'M', u'j'), + (0x4B, 'M', u'k'), + (0x4C, 'M', u'l'), + (0x4D, 'M', u'm'), + (0x4E, 'M', u'n'), + (0x4F, 'M', u'o'), + (0x50, 'M', u'p'), + (0x51, 'M', u'q'), + (0x52, 'M', u'r'), + (0x53, 'M', u's'), + (0x54, 'M', u't'), + (0x55, 'M', u'u'), + (0x56, 'M', u'v'), + (0x57, 'M', u'w'), + (0x58, 'M', u'x'), + (0x59, 'M', u'y'), + (0x5A, 'M', u'z'), + (0x5B, '3'), + (0x5C, '3'), + (0x5D, '3'), + (0x5E, '3'), + (0x5F, '3'), + (0x60, '3'), + (0x61, 'V'), + (0x62, 'V'), + (0x63, 'V'), + ] + +def _seg_1(): + return [ + (0x64, 'V'), + (0x65, 'V'), + (0x66, 'V'), + (0x67, 'V'), + (0x68, 'V'), + (0x69, 'V'), + (0x6A, 'V'), + (0x6B, 'V'), + (0x6C, 'V'), + (0x6D, 'V'), + (0x6E, 'V'), + (0x6F, 'V'), + (0x70, 'V'), + (0x71, 'V'), + (0x72, 'V'), + (0x73, 'V'), + (0x74, 'V'), + (0x75, 'V'), + (0x76, 'V'), + (0x77, 'V'), + (0x78, 'V'), + (0x79, 'V'), + (0x7A, 'V'), + (0x7B, '3'), + (0x7C, '3'), + (0x7D, '3'), + (0x7E, '3'), + (0x7F, '3'), + (0x80, 'X'), + (0x81, 'X'), + (0x82, 'X'), + (0x83, 'X'), + (0x84, 'X'), + (0x85, 'X'), + (0x86, 'X'), + (0x87, 'X'), + (0x88, 'X'), + (0x89, 'X'), + (0x8A, 'X'), + (0x8B, 'X'), + (0x8C, 'X'), + (0x8D, 'X'), + (0x8E, 'X'), + (0x8F, 'X'), + (0x90, 'X'), + (0x91, 'X'), + (0x92, 'X'), + (0x93, 'X'), + (0x94, 'X'), + (0x95, 'X'), + (0x96, 'X'), + (0x97, 'X'), + (0x98, 'X'), + (0x99, 'X'), + (0x9A, 'X'), + (0x9B, 'X'), + (0x9C, 'X'), + (0x9D, 'X'), + (0x9E, 'X'), + (0x9F, 'X'), + (0xA0, '3', u' '), + (0xA1, 'V'), + (0xA2, 'V'), + (0xA3, 'V'), + (0xA4, 'V'), + (0xA5, 'V'), + (0xA6, 'V'), + (0xA7, 'V'), + (0xA8, '3', u' ̈'), + (0xA9, 'V'), + (0xAA, 'M', u'a'), + (0xAB, 'V'), + (0xAC, 'V'), + (0xAD, 'I'), + (0xAE, 'V'), + (0xAF, '3', u' ̄'), + (0xB0, 'V'), + (0xB1, 'V'), + (0xB2, 'M', u'2'), + (0xB3, 'M', u'3'), + (0xB4, '3', u' ́'), + (0xB5, 'M', u'μ'), + (0xB6, 'V'), + (0xB7, 'V'), + (0xB8, '3', u' ̧'), + (0xB9, 'M', u'1'), + (0xBA, 'M', u'o'), + (0xBB, 'V'), + (0xBC, 'M', u'1⁄4'), + (0xBD, 'M', u'1⁄2'), + (0xBE, 'M', u'3⁄4'), + (0xBF, 'V'), + (0xC0, 'M', u'à'), + (0xC1, 'M', u'á'), + (0xC2, 'M', u'â'), + (0xC3, 'M', u'ã'), + (0xC4, 'M', u'ä'), + (0xC5, 'M', u'å'), + (0xC6, 'M', u'æ'), + (0xC7, 'M', u'ç'), + ] + +def _seg_2(): + return [ + (0xC8, 'M', u'è'), + (0xC9, 'M', u'é'), + (0xCA, 'M', u'ê'), + (0xCB, 'M', u'ë'), + (0xCC, 'M', u'ì'), + (0xCD, 'M', u'í'), + (0xCE, 'M', u'î'), + (0xCF, 'M', u'ï'), + (0xD0, 'M', u'ð'), + (0xD1, 'M', u'ñ'), + (0xD2, 'M', u'ò'), + (0xD3, 'M', u'ó'), + (0xD4, 'M', u'ô'), + (0xD5, 'M', u'õ'), + (0xD6, 'M', u'ö'), + (0xD7, 'V'), + (0xD8, 'M', u'ø'), + (0xD9, 'M', u'ù'), + (0xDA, 'M', u'ú'), + (0xDB, 'M', u'û'), + (0xDC, 'M', u'ü'), + (0xDD, 'M', u'ý'), + (0xDE, 'M', u'þ'), + (0xDF, 'D', u'ss'), + (0xE0, 'V'), + (0xE1, 'V'), + (0xE2, 'V'), + (0xE3, 'V'), + (0xE4, 'V'), + (0xE5, 'V'), + (0xE6, 'V'), + (0xE7, 'V'), + (0xE8, 'V'), + (0xE9, 'V'), + (0xEA, 'V'), + (0xEB, 'V'), + (0xEC, 'V'), + (0xED, 'V'), + (0xEE, 'V'), + (0xEF, 'V'), + (0xF0, 'V'), + (0xF1, 'V'), + (0xF2, 'V'), + (0xF3, 'V'), + (0xF4, 'V'), + (0xF5, 'V'), + (0xF6, 'V'), + (0xF7, 'V'), + (0xF8, 'V'), + (0xF9, 'V'), + (0xFA, 'V'), + (0xFB, 'V'), + (0xFC, 'V'), + (0xFD, 'V'), + (0xFE, 'V'), + (0xFF, 'V'), + (0x100, 'M', u'ā'), + (0x101, 'V'), + (0x102, 'M', u'ă'), + (0x103, 'V'), + (0x104, 'M', u'ą'), + (0x105, 'V'), + (0x106, 'M', u'ć'), + (0x107, 'V'), + (0x108, 'M', u'ĉ'), + (0x109, 'V'), + (0x10A, 'M', u'ċ'), + (0x10B, 'V'), + (0x10C, 'M', u'č'), + (0x10D, 'V'), + (0x10E, 'M', u'ď'), + (0x10F, 'V'), + (0x110, 'M', u'đ'), + (0x111, 'V'), + (0x112, 'M', u'ē'), + (0x113, 'V'), + (0x114, 'M', u'ĕ'), + (0x115, 'V'), + (0x116, 'M', u'ė'), + (0x117, 'V'), + (0x118, 'M', u'ę'), + (0x119, 'V'), + (0x11A, 'M', u'ě'), + (0x11B, 'V'), + (0x11C, 'M', u'ĝ'), + (0x11D, 'V'), + (0x11E, 'M', u'ğ'), + (0x11F, 'V'), + (0x120, 'M', u'ġ'), + (0x121, 'V'), + (0x122, 'M', u'ģ'), + (0x123, 'V'), + (0x124, 'M', u'ĥ'), + (0x125, 'V'), + (0x126, 'M', u'ħ'), + (0x127, 'V'), + (0x128, 'M', u'ĩ'), + (0x129, 'V'), + (0x12A, 'M', u'ī'), + (0x12B, 'V'), + ] + +def _seg_3(): + return [ + (0x12C, 'M', u'ĭ'), + (0x12D, 'V'), + (0x12E, 'M', u'į'), + (0x12F, 'V'), + (0x130, 'M', u'i̇'), + (0x131, 'V'), + (0x132, 'M', u'ij'), + (0x134, 'M', u'ĵ'), + (0x135, 'V'), + (0x136, 'M', u'ķ'), + (0x137, 'V'), + (0x139, 'M', u'ĺ'), + (0x13A, 'V'), + (0x13B, 'M', u'ļ'), + (0x13C, 'V'), + (0x13D, 'M', u'ľ'), + (0x13E, 'V'), + (0x13F, 'M', u'l·'), + (0x141, 'M', u'ł'), + (0x142, 'V'), + (0x143, 'M', u'ń'), + (0x144, 'V'), + (0x145, 'M', u'ņ'), + (0x146, 'V'), + (0x147, 'M', u'ň'), + (0x148, 'V'), + (0x149, 'M', u'ʼn'), + (0x14A, 'M', u'ŋ'), + (0x14B, 'V'), + (0x14C, 'M', u'ō'), + (0x14D, 'V'), + (0x14E, 'M', u'ŏ'), + (0x14F, 'V'), + (0x150, 'M', u'ő'), + (0x151, 'V'), + (0x152, 'M', u'œ'), + (0x153, 'V'), + (0x154, 'M', u'ŕ'), + (0x155, 'V'), + (0x156, 'M', u'ŗ'), + (0x157, 'V'), + (0x158, 'M', u'ř'), + (0x159, 'V'), + (0x15A, 'M', u'ś'), + (0x15B, 'V'), + (0x15C, 'M', u'ŝ'), + (0x15D, 'V'), + (0x15E, 'M', u'ş'), + (0x15F, 'V'), + (0x160, 'M', u'š'), + (0x161, 'V'), + (0x162, 'M', u'ţ'), + (0x163, 'V'), + (0x164, 'M', u'ť'), + (0x165, 'V'), + (0x166, 'M', u'ŧ'), + (0x167, 'V'), + (0x168, 'M', u'ũ'), + (0x169, 'V'), + (0x16A, 'M', u'ū'), + (0x16B, 'V'), + (0x16C, 'M', u'ŭ'), + (0x16D, 'V'), + (0x16E, 'M', u'ů'), + (0x16F, 'V'), + (0x170, 'M', u'ű'), + (0x171, 'V'), + (0x172, 'M', u'ų'), + (0x173, 'V'), + (0x174, 'M', u'ŵ'), + (0x175, 'V'), + (0x176, 'M', u'ŷ'), + (0x177, 'V'), + (0x178, 'M', u'ÿ'), + (0x179, 'M', u'ź'), + (0x17A, 'V'), + (0x17B, 'M', u'ż'), + (0x17C, 'V'), + (0x17D, 'M', u'ž'), + (0x17E, 'V'), + (0x17F, 'M', u's'), + (0x180, 'V'), + (0x181, 'M', u'ɓ'), + (0x182, 'M', u'ƃ'), + (0x183, 'V'), + (0x184, 'M', u'ƅ'), + (0x185, 'V'), + (0x186, 'M', u'ɔ'), + (0x187, 'M', u'ƈ'), + (0x188, 'V'), + (0x189, 'M', u'ɖ'), + (0x18A, 'M', u'ɗ'), + (0x18B, 'M', u'ƌ'), + (0x18C, 'V'), + (0x18E, 'M', u'ǝ'), + (0x18F, 'M', u'ə'), + (0x190, 'M', u'ɛ'), + (0x191, 'M', u'ƒ'), + (0x192, 'V'), + (0x193, 'M', u'ɠ'), + ] + +def _seg_4(): + return [ + (0x194, 'M', u'ɣ'), + (0x195, 'V'), + (0x196, 'M', u'ɩ'), + (0x197, 'M', u'ɨ'), + (0x198, 'M', u'ƙ'), + (0x199, 'V'), + (0x19C, 'M', u'ɯ'), + (0x19D, 'M', u'ɲ'), + (0x19E, 'V'), + (0x19F, 'M', u'ɵ'), + (0x1A0, 'M', u'ơ'), + (0x1A1, 'V'), + (0x1A2, 'M', u'ƣ'), + (0x1A3, 'V'), + (0x1A4, 'M', u'ƥ'), + (0x1A5, 'V'), + (0x1A6, 'M', u'ʀ'), + (0x1A7, 'M', u'ƨ'), + (0x1A8, 'V'), + (0x1A9, 'M', u'ʃ'), + (0x1AA, 'V'), + (0x1AC, 'M', u'ƭ'), + (0x1AD, 'V'), + (0x1AE, 'M', u'ʈ'), + (0x1AF, 'M', u'ư'), + (0x1B0, 'V'), + (0x1B1, 'M', u'ʊ'), + (0x1B2, 'M', u'ʋ'), + (0x1B3, 'M', u'ƴ'), + (0x1B4, 'V'), + (0x1B5, 'M', u'ƶ'), + (0x1B6, 'V'), + (0x1B7, 'M', u'ʒ'), + (0x1B8, 'M', u'ƹ'), + (0x1B9, 'V'), + (0x1BC, 'M', u'ƽ'), + (0x1BD, 'V'), + (0x1C4, 'M', u'dž'), + (0x1C7, 'M', u'lj'), + (0x1CA, 'M', u'nj'), + (0x1CD, 'M', u'ǎ'), + (0x1CE, 'V'), + (0x1CF, 'M', u'ǐ'), + (0x1D0, 'V'), + (0x1D1, 'M', u'ǒ'), + (0x1D2, 'V'), + (0x1D3, 'M', u'ǔ'), + (0x1D4, 'V'), + (0x1D5, 'M', u'ǖ'), + (0x1D6, 'V'), + (0x1D7, 'M', u'ǘ'), + (0x1D8, 'V'), + (0x1D9, 'M', u'ǚ'), + (0x1DA, 'V'), + (0x1DB, 'M', u'ǜ'), + (0x1DC, 'V'), + (0x1DE, 'M', u'ǟ'), + (0x1DF, 'V'), + (0x1E0, 'M', u'ǡ'), + (0x1E1, 'V'), + (0x1E2, 'M', u'ǣ'), + (0x1E3, 'V'), + (0x1E4, 'M', u'ǥ'), + (0x1E5, 'V'), + (0x1E6, 'M', u'ǧ'), + (0x1E7, 'V'), + (0x1E8, 'M', u'ǩ'), + (0x1E9, 'V'), + (0x1EA, 'M', u'ǫ'), + (0x1EB, 'V'), + (0x1EC, 'M', u'ǭ'), + (0x1ED, 'V'), + (0x1EE, 'M', u'ǯ'), + (0x1EF, 'V'), + (0x1F1, 'M', u'dz'), + (0x1F4, 'M', u'ǵ'), + (0x1F5, 'V'), + (0x1F6, 'M', u'ƕ'), + (0x1F7, 'M', u'ƿ'), + (0x1F8, 'M', u'ǹ'), + (0x1F9, 'V'), + (0x1FA, 'M', u'ǻ'), + (0x1FB, 'V'), + (0x1FC, 'M', u'ǽ'), + (0x1FD, 'V'), + (0x1FE, 'M', u'ǿ'), + (0x1FF, 'V'), + (0x200, 'M', u'ȁ'), + (0x201, 'V'), + (0x202, 'M', u'ȃ'), + (0x203, 'V'), + (0x204, 'M', u'ȅ'), + (0x205, 'V'), + (0x206, 'M', u'ȇ'), + (0x207, 'V'), + (0x208, 'M', u'ȉ'), + (0x209, 'V'), + (0x20A, 'M', u'ȋ'), + (0x20B, 'V'), + (0x20C, 'M', u'ȍ'), + ] + +def _seg_5(): + return [ + (0x20D, 'V'), + (0x20E, 'M', u'ȏ'), + (0x20F, 'V'), + (0x210, 'M', u'ȑ'), + (0x211, 'V'), + (0x212, 'M', u'ȓ'), + (0x213, 'V'), + (0x214, 'M', u'ȕ'), + (0x215, 'V'), + (0x216, 'M', u'ȗ'), + (0x217, 'V'), + (0x218, 'M', u'ș'), + (0x219, 'V'), + (0x21A, 'M', u'ț'), + (0x21B, 'V'), + (0x21C, 'M', u'ȝ'), + (0x21D, 'V'), + (0x21E, 'M', u'ȟ'), + (0x21F, 'V'), + (0x220, 'M', u'ƞ'), + (0x221, 'V'), + (0x222, 'M', u'ȣ'), + (0x223, 'V'), + (0x224, 'M', u'ȥ'), + (0x225, 'V'), + (0x226, 'M', u'ȧ'), + (0x227, 'V'), + (0x228, 'M', u'ȩ'), + (0x229, 'V'), + (0x22A, 'M', u'ȫ'), + (0x22B, 'V'), + (0x22C, 'M', u'ȭ'), + (0x22D, 'V'), + (0x22E, 'M', u'ȯ'), + (0x22F, 'V'), + (0x230, 'M', u'ȱ'), + (0x231, 'V'), + (0x232, 'M', u'ȳ'), + (0x233, 'V'), + (0x23A, 'M', u'ⱥ'), + (0x23B, 'M', u'ȼ'), + (0x23C, 'V'), + (0x23D, 'M', u'ƚ'), + (0x23E, 'M', u'ⱦ'), + (0x23F, 'V'), + (0x241, 'M', u'ɂ'), + (0x242, 'V'), + (0x243, 'M', u'ƀ'), + (0x244, 'M', u'ʉ'), + (0x245, 'M', u'ʌ'), + (0x246, 'M', u'ɇ'), + (0x247, 'V'), + (0x248, 'M', u'ɉ'), + (0x249, 'V'), + (0x24A, 'M', u'ɋ'), + (0x24B, 'V'), + (0x24C, 'M', u'ɍ'), + (0x24D, 'V'), + (0x24E, 'M', u'ɏ'), + (0x24F, 'V'), + (0x2B0, 'M', u'h'), + (0x2B1, 'M', u'ɦ'), + (0x2B2, 'M', u'j'), + (0x2B3, 'M', u'r'), + (0x2B4, 'M', u'ɹ'), + (0x2B5, 'M', u'ɻ'), + (0x2B6, 'M', u'ʁ'), + (0x2B7, 'M', u'w'), + (0x2B8, 'M', u'y'), + (0x2B9, 'V'), + (0x2D8, '3', u' ̆'), + (0x2D9, '3', u' ̇'), + (0x2DA, '3', u' ̊'), + (0x2DB, '3', u' ̨'), + (0x2DC, '3', u' ̃'), + (0x2DD, '3', u' ̋'), + (0x2DE, 'V'), + (0x2E0, 'M', u'ɣ'), + (0x2E1, 'M', u'l'), + (0x2E2, 'M', u's'), + (0x2E3, 'M', u'x'), + (0x2E4, 'M', u'ʕ'), + (0x2E5, 'V'), + (0x340, 'M', u'̀'), + (0x341, 'M', u'́'), + (0x342, 'V'), + (0x343, 'M', u'̓'), + (0x344, 'M', u'̈́'), + (0x345, 'M', u'ι'), + (0x346, 'V'), + (0x34F, 'I'), + (0x350, 'V'), + (0x370, 'M', u'ͱ'), + (0x371, 'V'), + (0x372, 'M', u'ͳ'), + (0x373, 'V'), + (0x374, 'M', u'ʹ'), + (0x375, 'V'), + (0x376, 'M', u'ͷ'), + (0x377, 'V'), + ] + +def _seg_6(): + return [ + (0x378, 'X'), + (0x37A, '3', u' ι'), + (0x37B, 'V'), + (0x37E, '3', u';'), + (0x37F, 'M', u'ϳ'), + (0x380, 'X'), + (0x384, '3', u' ́'), + (0x385, '3', u' ̈́'), + (0x386, 'M', u'ά'), + (0x387, 'M', u'·'), + (0x388, 'M', u'έ'), + (0x389, 'M', u'ή'), + (0x38A, 'M', u'ί'), + (0x38B, 'X'), + (0x38C, 'M', u'ό'), + (0x38D, 'X'), + (0x38E, 'M', u'ύ'), + (0x38F, 'M', u'ώ'), + (0x390, 'V'), + (0x391, 'M', u'α'), + (0x392, 'M', u'β'), + (0x393, 'M', u'γ'), + (0x394, 'M', u'δ'), + (0x395, 'M', u'ε'), + (0x396, 'M', u'ζ'), + (0x397, 'M', u'η'), + (0x398, 'M', u'θ'), + (0x399, 'M', u'ι'), + (0x39A, 'M', u'κ'), + (0x39B, 'M', u'λ'), + (0x39C, 'M', u'μ'), + (0x39D, 'M', u'ν'), + (0x39E, 'M', u'ξ'), + (0x39F, 'M', u'ο'), + (0x3A0, 'M', u'π'), + (0x3A1, 'M', u'ρ'), + (0x3A2, 'X'), + (0x3A3, 'M', u'σ'), + (0x3A4, 'M', u'τ'), + (0x3A5, 'M', u'υ'), + (0x3A6, 'M', u'φ'), + (0x3A7, 'M', u'χ'), + (0x3A8, 'M', u'ψ'), + (0x3A9, 'M', u'ω'), + (0x3AA, 'M', u'ϊ'), + (0x3AB, 'M', u'ϋ'), + (0x3AC, 'V'), + (0x3C2, 'D', u'σ'), + (0x3C3, 'V'), + (0x3CF, 'M', u'ϗ'), + (0x3D0, 'M', u'β'), + (0x3D1, 'M', u'θ'), + (0x3D2, 'M', u'υ'), + (0x3D3, 'M', u'ύ'), + (0x3D4, 'M', u'ϋ'), + (0x3D5, 'M', u'φ'), + (0x3D6, 'M', u'π'), + (0x3D7, 'V'), + (0x3D8, 'M', u'ϙ'), + (0x3D9, 'V'), + (0x3DA, 'M', u'ϛ'), + (0x3DB, 'V'), + (0x3DC, 'M', u'ϝ'), + (0x3DD, 'V'), + (0x3DE, 'M', u'ϟ'), + (0x3DF, 'V'), + (0x3E0, 'M', u'ϡ'), + (0x3E1, 'V'), + (0x3E2, 'M', u'ϣ'), + (0x3E3, 'V'), + (0x3E4, 'M', u'ϥ'), + (0x3E5, 'V'), + (0x3E6, 'M', u'ϧ'), + (0x3E7, 'V'), + (0x3E8, 'M', u'ϩ'), + (0x3E9, 'V'), + (0x3EA, 'M', u'ϫ'), + (0x3EB, 'V'), + (0x3EC, 'M', u'ϭ'), + (0x3ED, 'V'), + (0x3EE, 'M', u'ϯ'), + (0x3EF, 'V'), + (0x3F0, 'M', u'κ'), + (0x3F1, 'M', u'ρ'), + (0x3F2, 'M', u'σ'), + (0x3F3, 'V'), + (0x3F4, 'M', u'θ'), + (0x3F5, 'M', u'ε'), + (0x3F6, 'V'), + (0x3F7, 'M', u'ϸ'), + (0x3F8, 'V'), + (0x3F9, 'M', u'σ'), + (0x3FA, 'M', u'ϻ'), + (0x3FB, 'V'), + (0x3FD, 'M', u'ͻ'), + (0x3FE, 'M', u'ͼ'), + (0x3FF, 'M', u'ͽ'), + (0x400, 'M', u'ѐ'), + (0x401, 'M', u'ё'), + (0x402, 'M', u'ђ'), + ] + +def _seg_7(): + return [ + (0x403, 'M', u'ѓ'), + (0x404, 'M', u'є'), + (0x405, 'M', u'ѕ'), + (0x406, 'M', u'і'), + (0x407, 'M', u'ї'), + (0x408, 'M', u'ј'), + (0x409, 'M', u'љ'), + (0x40A, 'M', u'њ'), + (0x40B, 'M', u'ћ'), + (0x40C, 'M', u'ќ'), + (0x40D, 'M', u'ѝ'), + (0x40E, 'M', u'ў'), + (0x40F, 'M', u'џ'), + (0x410, 'M', u'а'), + (0x411, 'M', u'б'), + (0x412, 'M', u'в'), + (0x413, 'M', u'г'), + (0x414, 'M', u'д'), + (0x415, 'M', u'е'), + (0x416, 'M', u'ж'), + (0x417, 'M', u'з'), + (0x418, 'M', u'и'), + (0x419, 'M', u'й'), + (0x41A, 'M', u'к'), + (0x41B, 'M', u'л'), + (0x41C, 'M', u'м'), + (0x41D, 'M', u'н'), + (0x41E, 'M', u'о'), + (0x41F, 'M', u'п'), + (0x420, 'M', u'р'), + (0x421, 'M', u'с'), + (0x422, 'M', u'т'), + (0x423, 'M', u'у'), + (0x424, 'M', u'ф'), + (0x425, 'M', u'х'), + (0x426, 'M', u'ц'), + (0x427, 'M', u'ч'), + (0x428, 'M', u'ш'), + (0x429, 'M', u'щ'), + (0x42A, 'M', u'ъ'), + (0x42B, 'M', u'ы'), + (0x42C, 'M', u'ь'), + (0x42D, 'M', u'э'), + (0x42E, 'M', u'ю'), + (0x42F, 'M', u'я'), + (0x430, 'V'), + (0x460, 'M', u'ѡ'), + (0x461, 'V'), + (0x462, 'M', u'ѣ'), + (0x463, 'V'), + (0x464, 'M', u'ѥ'), + (0x465, 'V'), + (0x466, 'M', u'ѧ'), + (0x467, 'V'), + (0x468, 'M', u'ѩ'), + (0x469, 'V'), + (0x46A, 'M', u'ѫ'), + (0x46B, 'V'), + (0x46C, 'M', u'ѭ'), + (0x46D, 'V'), + (0x46E, 'M', u'ѯ'), + (0x46F, 'V'), + (0x470, 'M', u'ѱ'), + (0x471, 'V'), + (0x472, 'M', u'ѳ'), + (0x473, 'V'), + (0x474, 'M', u'ѵ'), + (0x475, 'V'), + (0x476, 'M', u'ѷ'), + (0x477, 'V'), + (0x478, 'M', u'ѹ'), + (0x479, 'V'), + (0x47A, 'M', u'ѻ'), + (0x47B, 'V'), + (0x47C, 'M', u'ѽ'), + (0x47D, 'V'), + (0x47E, 'M', u'ѿ'), + (0x47F, 'V'), + (0x480, 'M', u'ҁ'), + (0x481, 'V'), + (0x48A, 'M', u'ҋ'), + (0x48B, 'V'), + (0x48C, 'M', u'ҍ'), + (0x48D, 'V'), + (0x48E, 'M', u'ҏ'), + (0x48F, 'V'), + (0x490, 'M', u'ґ'), + (0x491, 'V'), + (0x492, 'M', u'ғ'), + (0x493, 'V'), + (0x494, 'M', u'ҕ'), + (0x495, 'V'), + (0x496, 'M', u'җ'), + (0x497, 'V'), + (0x498, 'M', u'ҙ'), + (0x499, 'V'), + (0x49A, 'M', u'қ'), + (0x49B, 'V'), + (0x49C, 'M', u'ҝ'), + (0x49D, 'V'), + ] + +def _seg_8(): + return [ + (0x49E, 'M', u'ҟ'), + (0x49F, 'V'), + (0x4A0, 'M', u'ҡ'), + (0x4A1, 'V'), + (0x4A2, 'M', u'ң'), + (0x4A3, 'V'), + (0x4A4, 'M', u'ҥ'), + (0x4A5, 'V'), + (0x4A6, 'M', u'ҧ'), + (0x4A7, 'V'), + (0x4A8, 'M', u'ҩ'), + (0x4A9, 'V'), + (0x4AA, 'M', u'ҫ'), + (0x4AB, 'V'), + (0x4AC, 'M', u'ҭ'), + (0x4AD, 'V'), + (0x4AE, 'M', u'ү'), + (0x4AF, 'V'), + (0x4B0, 'M', u'ұ'), + (0x4B1, 'V'), + (0x4B2, 'M', u'ҳ'), + (0x4B3, 'V'), + (0x4B4, 'M', u'ҵ'), + (0x4B5, 'V'), + (0x4B6, 'M', u'ҷ'), + (0x4B7, 'V'), + (0x4B8, 'M', u'ҹ'), + (0x4B9, 'V'), + (0x4BA, 'M', u'һ'), + (0x4BB, 'V'), + (0x4BC, 'M', u'ҽ'), + (0x4BD, 'V'), + (0x4BE, 'M', u'ҿ'), + (0x4BF, 'V'), + (0x4C0, 'X'), + (0x4C1, 'M', u'ӂ'), + (0x4C2, 'V'), + (0x4C3, 'M', u'ӄ'), + (0x4C4, 'V'), + (0x4C5, 'M', u'ӆ'), + (0x4C6, 'V'), + (0x4C7, 'M', u'ӈ'), + (0x4C8, 'V'), + (0x4C9, 'M', u'ӊ'), + (0x4CA, 'V'), + (0x4CB, 'M', u'ӌ'), + (0x4CC, 'V'), + (0x4CD, 'M', u'ӎ'), + (0x4CE, 'V'), + (0x4D0, 'M', u'ӑ'), + (0x4D1, 'V'), + (0x4D2, 'M', u'ӓ'), + (0x4D3, 'V'), + (0x4D4, 'M', u'ӕ'), + (0x4D5, 'V'), + (0x4D6, 'M', u'ӗ'), + (0x4D7, 'V'), + (0x4D8, 'M', u'ә'), + (0x4D9, 'V'), + (0x4DA, 'M', u'ӛ'), + (0x4DB, 'V'), + (0x4DC, 'M', u'ӝ'), + (0x4DD, 'V'), + (0x4DE, 'M', u'ӟ'), + (0x4DF, 'V'), + (0x4E0, 'M', u'ӡ'), + (0x4E1, 'V'), + (0x4E2, 'M', u'ӣ'), + (0x4E3, 'V'), + (0x4E4, 'M', u'ӥ'), + (0x4E5, 'V'), + (0x4E6, 'M', u'ӧ'), + (0x4E7, 'V'), + (0x4E8, 'M', u'ө'), + (0x4E9, 'V'), + (0x4EA, 'M', u'ӫ'), + (0x4EB, 'V'), + (0x4EC, 'M', u'ӭ'), + (0x4ED, 'V'), + (0x4EE, 'M', u'ӯ'), + (0x4EF, 'V'), + (0x4F0, 'M', u'ӱ'), + (0x4F1, 'V'), + (0x4F2, 'M', u'ӳ'), + (0x4F3, 'V'), + (0x4F4, 'M', u'ӵ'), + (0x4F5, 'V'), + (0x4F6, 'M', u'ӷ'), + (0x4F7, 'V'), + (0x4F8, 'M', u'ӹ'), + (0x4F9, 'V'), + (0x4FA, 'M', u'ӻ'), + (0x4FB, 'V'), + (0x4FC, 'M', u'ӽ'), + (0x4FD, 'V'), + (0x4FE, 'M', u'ӿ'), + (0x4FF, 'V'), + (0x500, 'M', u'ԁ'), + (0x501, 'V'), + (0x502, 'M', u'ԃ'), + ] + +def _seg_9(): + return [ + (0x503, 'V'), + (0x504, 'M', u'ԅ'), + (0x505, 'V'), + (0x506, 'M', u'ԇ'), + (0x507, 'V'), + (0x508, 'M', u'ԉ'), + (0x509, 'V'), + (0x50A, 'M', u'ԋ'), + (0x50B, 'V'), + (0x50C, 'M', u'ԍ'), + (0x50D, 'V'), + (0x50E, 'M', u'ԏ'), + (0x50F, 'V'), + (0x510, 'M', u'ԑ'), + (0x511, 'V'), + (0x512, 'M', u'ԓ'), + (0x513, 'V'), + (0x514, 'M', u'ԕ'), + (0x515, 'V'), + (0x516, 'M', u'ԗ'), + (0x517, 'V'), + (0x518, 'M', u'ԙ'), + (0x519, 'V'), + (0x51A, 'M', u'ԛ'), + (0x51B, 'V'), + (0x51C, 'M', u'ԝ'), + (0x51D, 'V'), + (0x51E, 'M', u'ԟ'), + (0x51F, 'V'), + (0x520, 'M', u'ԡ'), + (0x521, 'V'), + (0x522, 'M', u'ԣ'), + (0x523, 'V'), + (0x524, 'M', u'ԥ'), + (0x525, 'V'), + (0x526, 'M', u'ԧ'), + (0x527, 'V'), + (0x528, 'M', u'ԩ'), + (0x529, 'V'), + (0x52A, 'M', u'ԫ'), + (0x52B, 'V'), + (0x52C, 'M', u'ԭ'), + (0x52D, 'V'), + (0x52E, 'M', u'ԯ'), + (0x52F, 'V'), + (0x530, 'X'), + (0x531, 'M', u'ա'), + (0x532, 'M', u'բ'), + (0x533, 'M', u'գ'), + (0x534, 'M', u'դ'), + (0x535, 'M', u'ե'), + (0x536, 'M', u'զ'), + (0x537, 'M', u'է'), + (0x538, 'M', u'ը'), + (0x539, 'M', u'թ'), + (0x53A, 'M', u'ժ'), + (0x53B, 'M', u'ի'), + (0x53C, 'M', u'լ'), + (0x53D, 'M', u'խ'), + (0x53E, 'M', u'ծ'), + (0x53F, 'M', u'կ'), + (0x540, 'M', u'հ'), + (0x541, 'M', u'ձ'), + (0x542, 'M', u'ղ'), + (0x543, 'M', u'ճ'), + (0x544, 'M', u'մ'), + (0x545, 'M', u'յ'), + (0x546, 'M', u'ն'), + (0x547, 'M', u'շ'), + (0x548, 'M', u'ո'), + (0x549, 'M', u'չ'), + (0x54A, 'M', u'պ'), + (0x54B, 'M', u'ջ'), + (0x54C, 'M', u'ռ'), + (0x54D, 'M', u'ս'), + (0x54E, 'M', u'վ'), + (0x54F, 'M', u'տ'), + (0x550, 'M', u'ր'), + (0x551, 'M', u'ց'), + (0x552, 'M', u'ւ'), + (0x553, 'M', u'փ'), + (0x554, 'M', u'ք'), + (0x555, 'M', u'օ'), + (0x556, 'M', u'ֆ'), + (0x557, 'X'), + (0x559, 'V'), + (0x587, 'M', u'եւ'), + (0x588, 'V'), + (0x58B, 'X'), + (0x58D, 'V'), + (0x590, 'X'), + (0x591, 'V'), + (0x5C8, 'X'), + (0x5D0, 'V'), + (0x5EB, 'X'), + (0x5EF, 'V'), + (0x5F5, 'X'), + (0x606, 'V'), + (0x61C, 'X'), + (0x61E, 'V'), + ] + +def _seg_10(): + return [ + (0x675, 'M', u'اٴ'), + (0x676, 'M', u'وٴ'), + (0x677, 'M', u'ۇٴ'), + (0x678, 'M', u'يٴ'), + (0x679, 'V'), + (0x6DD, 'X'), + (0x6DE, 'V'), + (0x70E, 'X'), + (0x710, 'V'), + (0x74B, 'X'), + (0x74D, 'V'), + (0x7B2, 'X'), + (0x7C0, 'V'), + (0x7FB, 'X'), + (0x7FD, 'V'), + (0x82E, 'X'), + (0x830, 'V'), + (0x83F, 'X'), + (0x840, 'V'), + (0x85C, 'X'), + (0x85E, 'V'), + (0x85F, 'X'), + (0x860, 'V'), + (0x86B, 'X'), + (0x8A0, 'V'), + (0x8B5, 'X'), + (0x8B6, 'V'), + (0x8BE, 'X'), + (0x8D3, 'V'), + (0x8E2, 'X'), + (0x8E3, 'V'), + (0x958, 'M', u'क़'), + (0x959, 'M', u'ख़'), + (0x95A, 'M', u'ग़'), + (0x95B, 'M', u'ज़'), + (0x95C, 'M', u'ड़'), + (0x95D, 'M', u'ढ़'), + (0x95E, 'M', u'फ़'), + (0x95F, 'M', u'य़'), + (0x960, 'V'), + (0x984, 'X'), + (0x985, 'V'), + (0x98D, 'X'), + (0x98F, 'V'), + (0x991, 'X'), + (0x993, 'V'), + (0x9A9, 'X'), + (0x9AA, 'V'), + (0x9B1, 'X'), + (0x9B2, 'V'), + (0x9B3, 'X'), + (0x9B6, 'V'), + (0x9BA, 'X'), + (0x9BC, 'V'), + (0x9C5, 'X'), + (0x9C7, 'V'), + (0x9C9, 'X'), + (0x9CB, 'V'), + (0x9CF, 'X'), + (0x9D7, 'V'), + (0x9D8, 'X'), + (0x9DC, 'M', u'ড়'), + (0x9DD, 'M', u'ঢ়'), + (0x9DE, 'X'), + (0x9DF, 'M', u'য়'), + (0x9E0, 'V'), + (0x9E4, 'X'), + (0x9E6, 'V'), + (0x9FF, 'X'), + (0xA01, 'V'), + (0xA04, 'X'), + (0xA05, 'V'), + (0xA0B, 'X'), + (0xA0F, 'V'), + (0xA11, 'X'), + (0xA13, 'V'), + (0xA29, 'X'), + (0xA2A, 'V'), + (0xA31, 'X'), + (0xA32, 'V'), + (0xA33, 'M', u'ਲ਼'), + (0xA34, 'X'), + (0xA35, 'V'), + (0xA36, 'M', u'ਸ਼'), + (0xA37, 'X'), + (0xA38, 'V'), + (0xA3A, 'X'), + (0xA3C, 'V'), + (0xA3D, 'X'), + (0xA3E, 'V'), + (0xA43, 'X'), + (0xA47, 'V'), + (0xA49, 'X'), + (0xA4B, 'V'), + (0xA4E, 'X'), + (0xA51, 'V'), + (0xA52, 'X'), + (0xA59, 'M', u'ਖ਼'), + (0xA5A, 'M', u'ਗ਼'), + (0xA5B, 'M', u'ਜ਼'), + ] + +def _seg_11(): + return [ + (0xA5C, 'V'), + (0xA5D, 'X'), + (0xA5E, 'M', u'ਫ਼'), + (0xA5F, 'X'), + (0xA66, 'V'), + (0xA77, 'X'), + (0xA81, 'V'), + (0xA84, 'X'), + (0xA85, 'V'), + (0xA8E, 'X'), + (0xA8F, 'V'), + (0xA92, 'X'), + (0xA93, 'V'), + (0xAA9, 'X'), + (0xAAA, 'V'), + (0xAB1, 'X'), + (0xAB2, 'V'), + (0xAB4, 'X'), + (0xAB5, 'V'), + (0xABA, 'X'), + (0xABC, 'V'), + (0xAC6, 'X'), + (0xAC7, 'V'), + (0xACA, 'X'), + (0xACB, 'V'), + (0xACE, 'X'), + (0xAD0, 'V'), + (0xAD1, 'X'), + (0xAE0, 'V'), + (0xAE4, 'X'), + (0xAE6, 'V'), + (0xAF2, 'X'), + (0xAF9, 'V'), + (0xB00, 'X'), + (0xB01, 'V'), + (0xB04, 'X'), + (0xB05, 'V'), + (0xB0D, 'X'), + (0xB0F, 'V'), + (0xB11, 'X'), + (0xB13, 'V'), + (0xB29, 'X'), + (0xB2A, 'V'), + (0xB31, 'X'), + (0xB32, 'V'), + (0xB34, 'X'), + (0xB35, 'V'), + (0xB3A, 'X'), + (0xB3C, 'V'), + (0xB45, 'X'), + (0xB47, 'V'), + (0xB49, 'X'), + (0xB4B, 'V'), + (0xB4E, 'X'), + (0xB56, 'V'), + (0xB58, 'X'), + (0xB5C, 'M', u'ଡ଼'), + (0xB5D, 'M', u'ଢ଼'), + (0xB5E, 'X'), + (0xB5F, 'V'), + (0xB64, 'X'), + (0xB66, 'V'), + (0xB78, 'X'), + (0xB82, 'V'), + (0xB84, 'X'), + (0xB85, 'V'), + (0xB8B, 'X'), + (0xB8E, 'V'), + (0xB91, 'X'), + (0xB92, 'V'), + (0xB96, 'X'), + (0xB99, 'V'), + (0xB9B, 'X'), + (0xB9C, 'V'), + (0xB9D, 'X'), + (0xB9E, 'V'), + (0xBA0, 'X'), + (0xBA3, 'V'), + (0xBA5, 'X'), + (0xBA8, 'V'), + (0xBAB, 'X'), + (0xBAE, 'V'), + (0xBBA, 'X'), + (0xBBE, 'V'), + (0xBC3, 'X'), + (0xBC6, 'V'), + (0xBC9, 'X'), + (0xBCA, 'V'), + (0xBCE, 'X'), + (0xBD0, 'V'), + (0xBD1, 'X'), + (0xBD7, 'V'), + (0xBD8, 'X'), + (0xBE6, 'V'), + (0xBFB, 'X'), + (0xC00, 'V'), + (0xC0D, 'X'), + (0xC0E, 'V'), + (0xC11, 'X'), + (0xC12, 'V'), + ] + +def _seg_12(): + return [ + (0xC29, 'X'), + (0xC2A, 'V'), + (0xC3A, 'X'), + (0xC3D, 'V'), + (0xC45, 'X'), + (0xC46, 'V'), + (0xC49, 'X'), + (0xC4A, 'V'), + (0xC4E, 'X'), + (0xC55, 'V'), + (0xC57, 'X'), + (0xC58, 'V'), + (0xC5B, 'X'), + (0xC60, 'V'), + (0xC64, 'X'), + (0xC66, 'V'), + (0xC70, 'X'), + (0xC78, 'V'), + (0xC8D, 'X'), + (0xC8E, 'V'), + (0xC91, 'X'), + (0xC92, 'V'), + (0xCA9, 'X'), + (0xCAA, 'V'), + (0xCB4, 'X'), + (0xCB5, 'V'), + (0xCBA, 'X'), + (0xCBC, 'V'), + (0xCC5, 'X'), + (0xCC6, 'V'), + (0xCC9, 'X'), + (0xCCA, 'V'), + (0xCCE, 'X'), + (0xCD5, 'V'), + (0xCD7, 'X'), + (0xCDE, 'V'), + (0xCDF, 'X'), + (0xCE0, 'V'), + (0xCE4, 'X'), + (0xCE6, 'V'), + (0xCF0, 'X'), + (0xCF1, 'V'), + (0xCF3, 'X'), + (0xD00, 'V'), + (0xD04, 'X'), + (0xD05, 'V'), + (0xD0D, 'X'), + (0xD0E, 'V'), + (0xD11, 'X'), + (0xD12, 'V'), + (0xD45, 'X'), + (0xD46, 'V'), + (0xD49, 'X'), + (0xD4A, 'V'), + (0xD50, 'X'), + (0xD54, 'V'), + (0xD64, 'X'), + (0xD66, 'V'), + (0xD80, 'X'), + (0xD82, 'V'), + (0xD84, 'X'), + (0xD85, 'V'), + (0xD97, 'X'), + (0xD9A, 'V'), + (0xDB2, 'X'), + (0xDB3, 'V'), + (0xDBC, 'X'), + (0xDBD, 'V'), + (0xDBE, 'X'), + (0xDC0, 'V'), + (0xDC7, 'X'), + (0xDCA, 'V'), + (0xDCB, 'X'), + (0xDCF, 'V'), + (0xDD5, 'X'), + (0xDD6, 'V'), + (0xDD7, 'X'), + (0xDD8, 'V'), + (0xDE0, 'X'), + (0xDE6, 'V'), + (0xDF0, 'X'), + (0xDF2, 'V'), + (0xDF5, 'X'), + (0xE01, 'V'), + (0xE33, 'M', u'ํา'), + (0xE34, 'V'), + (0xE3B, 'X'), + (0xE3F, 'V'), + (0xE5C, 'X'), + (0xE81, 'V'), + (0xE83, 'X'), + (0xE84, 'V'), + (0xE85, 'X'), + (0xE87, 'V'), + (0xE89, 'X'), + (0xE8A, 'V'), + (0xE8B, 'X'), + (0xE8D, 'V'), + (0xE8E, 'X'), + (0xE94, 'V'), + ] + +def _seg_13(): + return [ + (0xE98, 'X'), + (0xE99, 'V'), + (0xEA0, 'X'), + (0xEA1, 'V'), + (0xEA4, 'X'), + (0xEA5, 'V'), + (0xEA6, 'X'), + (0xEA7, 'V'), + (0xEA8, 'X'), + (0xEAA, 'V'), + (0xEAC, 'X'), + (0xEAD, 'V'), + (0xEB3, 'M', u'ໍາ'), + (0xEB4, 'V'), + (0xEBA, 'X'), + (0xEBB, 'V'), + (0xEBE, 'X'), + (0xEC0, 'V'), + (0xEC5, 'X'), + (0xEC6, 'V'), + (0xEC7, 'X'), + (0xEC8, 'V'), + (0xECE, 'X'), + (0xED0, 'V'), + (0xEDA, 'X'), + (0xEDC, 'M', u'ຫນ'), + (0xEDD, 'M', u'ຫມ'), + (0xEDE, 'V'), + (0xEE0, 'X'), + (0xF00, 'V'), + (0xF0C, 'M', u'་'), + (0xF0D, 'V'), + (0xF43, 'M', u'གྷ'), + (0xF44, 'V'), + (0xF48, 'X'), + (0xF49, 'V'), + (0xF4D, 'M', u'ཌྷ'), + (0xF4E, 'V'), + (0xF52, 'M', u'དྷ'), + (0xF53, 'V'), + (0xF57, 'M', u'བྷ'), + (0xF58, 'V'), + (0xF5C, 'M', u'ཛྷ'), + (0xF5D, 'V'), + (0xF69, 'M', u'ཀྵ'), + (0xF6A, 'V'), + (0xF6D, 'X'), + (0xF71, 'V'), + (0xF73, 'M', u'ཱི'), + (0xF74, 'V'), + (0xF75, 'M', u'ཱུ'), + (0xF76, 'M', u'ྲྀ'), + (0xF77, 'M', u'ྲཱྀ'), + (0xF78, 'M', u'ླྀ'), + (0xF79, 'M', u'ླཱྀ'), + (0xF7A, 'V'), + (0xF81, 'M', u'ཱྀ'), + (0xF82, 'V'), + (0xF93, 'M', u'ྒྷ'), + (0xF94, 'V'), + (0xF98, 'X'), + (0xF99, 'V'), + (0xF9D, 'M', u'ྜྷ'), + (0xF9E, 'V'), + (0xFA2, 'M', u'ྡྷ'), + (0xFA3, 'V'), + (0xFA7, 'M', u'ྦྷ'), + (0xFA8, 'V'), + (0xFAC, 'M', u'ྫྷ'), + (0xFAD, 'V'), + (0xFB9, 'M', u'ྐྵ'), + (0xFBA, 'V'), + (0xFBD, 'X'), + (0xFBE, 'V'), + (0xFCD, 'X'), + (0xFCE, 'V'), + (0xFDB, 'X'), + (0x1000, 'V'), + (0x10A0, 'X'), + (0x10C7, 'M', u'ⴧ'), + (0x10C8, 'X'), + (0x10CD, 'M', u'ⴭ'), + (0x10CE, 'X'), + (0x10D0, 'V'), + (0x10FC, 'M', u'ნ'), + (0x10FD, 'V'), + (0x115F, 'X'), + (0x1161, 'V'), + (0x1249, 'X'), + (0x124A, 'V'), + (0x124E, 'X'), + (0x1250, 'V'), + (0x1257, 'X'), + (0x1258, 'V'), + (0x1259, 'X'), + (0x125A, 'V'), + (0x125E, 'X'), + (0x1260, 'V'), + (0x1289, 'X'), + (0x128A, 'V'), + ] + +def _seg_14(): + return [ + (0x128E, 'X'), + (0x1290, 'V'), + (0x12B1, 'X'), + (0x12B2, 'V'), + (0x12B6, 'X'), + (0x12B8, 'V'), + (0x12BF, 'X'), + (0x12C0, 'V'), + (0x12C1, 'X'), + (0x12C2, 'V'), + (0x12C6, 'X'), + (0x12C8, 'V'), + (0x12D7, 'X'), + (0x12D8, 'V'), + (0x1311, 'X'), + (0x1312, 'V'), + (0x1316, 'X'), + (0x1318, 'V'), + (0x135B, 'X'), + (0x135D, 'V'), + (0x137D, 'X'), + (0x1380, 'V'), + (0x139A, 'X'), + (0x13A0, 'V'), + (0x13F6, 'X'), + (0x13F8, 'M', u'Ᏸ'), + (0x13F9, 'M', u'Ᏹ'), + (0x13FA, 'M', u'Ᏺ'), + (0x13FB, 'M', u'Ᏻ'), + (0x13FC, 'M', u'Ᏼ'), + (0x13FD, 'M', u'Ᏽ'), + (0x13FE, 'X'), + (0x1400, 'V'), + (0x1680, 'X'), + (0x1681, 'V'), + (0x169D, 'X'), + (0x16A0, 'V'), + (0x16F9, 'X'), + (0x1700, 'V'), + (0x170D, 'X'), + (0x170E, 'V'), + (0x1715, 'X'), + (0x1720, 'V'), + (0x1737, 'X'), + (0x1740, 'V'), + (0x1754, 'X'), + (0x1760, 'V'), + (0x176D, 'X'), + (0x176E, 'V'), + (0x1771, 'X'), + (0x1772, 'V'), + (0x1774, 'X'), + (0x1780, 'V'), + (0x17B4, 'X'), + (0x17B6, 'V'), + (0x17DE, 'X'), + (0x17E0, 'V'), + (0x17EA, 'X'), + (0x17F0, 'V'), + (0x17FA, 'X'), + (0x1800, 'V'), + (0x1806, 'X'), + (0x1807, 'V'), + (0x180B, 'I'), + (0x180E, 'X'), + (0x1810, 'V'), + (0x181A, 'X'), + (0x1820, 'V'), + (0x1879, 'X'), + (0x1880, 'V'), + (0x18AB, 'X'), + (0x18B0, 'V'), + (0x18F6, 'X'), + (0x1900, 'V'), + (0x191F, 'X'), + (0x1920, 'V'), + (0x192C, 'X'), + (0x1930, 'V'), + (0x193C, 'X'), + (0x1940, 'V'), + (0x1941, 'X'), + (0x1944, 'V'), + (0x196E, 'X'), + (0x1970, 'V'), + (0x1975, 'X'), + (0x1980, 'V'), + (0x19AC, 'X'), + (0x19B0, 'V'), + (0x19CA, 'X'), + (0x19D0, 'V'), + (0x19DB, 'X'), + (0x19DE, 'V'), + (0x1A1C, 'X'), + (0x1A1E, 'V'), + (0x1A5F, 'X'), + (0x1A60, 'V'), + (0x1A7D, 'X'), + (0x1A7F, 'V'), + (0x1A8A, 'X'), + (0x1A90, 'V'), + ] + +def _seg_15(): + return [ + (0x1A9A, 'X'), + (0x1AA0, 'V'), + (0x1AAE, 'X'), + (0x1AB0, 'V'), + (0x1ABF, 'X'), + (0x1B00, 'V'), + (0x1B4C, 'X'), + (0x1B50, 'V'), + (0x1B7D, 'X'), + (0x1B80, 'V'), + (0x1BF4, 'X'), + (0x1BFC, 'V'), + (0x1C38, 'X'), + (0x1C3B, 'V'), + (0x1C4A, 'X'), + (0x1C4D, 'V'), + (0x1C80, 'M', u'в'), + (0x1C81, 'M', u'д'), + (0x1C82, 'M', u'о'), + (0x1C83, 'M', u'с'), + (0x1C84, 'M', u'т'), + (0x1C86, 'M', u'ъ'), + (0x1C87, 'M', u'ѣ'), + (0x1C88, 'M', u'ꙋ'), + (0x1C89, 'X'), + (0x1CC0, 'V'), + (0x1CC8, 'X'), + (0x1CD0, 'V'), + (0x1CFA, 'X'), + (0x1D00, 'V'), + (0x1D2C, 'M', u'a'), + (0x1D2D, 'M', u'æ'), + (0x1D2E, 'M', u'b'), + (0x1D2F, 'V'), + (0x1D30, 'M', u'd'), + (0x1D31, 'M', u'e'), + (0x1D32, 'M', u'ǝ'), + (0x1D33, 'M', u'g'), + (0x1D34, 'M', u'h'), + (0x1D35, 'M', u'i'), + (0x1D36, 'M', u'j'), + (0x1D37, 'M', u'k'), + (0x1D38, 'M', u'l'), + (0x1D39, 'M', u'm'), + (0x1D3A, 'M', u'n'), + (0x1D3B, 'V'), + (0x1D3C, 'M', u'o'), + (0x1D3D, 'M', u'ȣ'), + (0x1D3E, 'M', u'p'), + (0x1D3F, 'M', u'r'), + (0x1D40, 'M', u't'), + (0x1D41, 'M', u'u'), + (0x1D42, 'M', u'w'), + (0x1D43, 'M', u'a'), + (0x1D44, 'M', u'ɐ'), + (0x1D45, 'M', u'ɑ'), + (0x1D46, 'M', u'ᴂ'), + (0x1D47, 'M', u'b'), + (0x1D48, 'M', u'd'), + (0x1D49, 'M', u'e'), + (0x1D4A, 'M', u'ə'), + (0x1D4B, 'M', u'ɛ'), + (0x1D4C, 'M', u'ɜ'), + (0x1D4D, 'M', u'g'), + (0x1D4E, 'V'), + (0x1D4F, 'M', u'k'), + (0x1D50, 'M', u'm'), + (0x1D51, 'M', u'ŋ'), + (0x1D52, 'M', u'o'), + (0x1D53, 'M', u'ɔ'), + (0x1D54, 'M', u'ᴖ'), + (0x1D55, 'M', u'ᴗ'), + (0x1D56, 'M', u'p'), + (0x1D57, 'M', u't'), + (0x1D58, 'M', u'u'), + (0x1D59, 'M', u'ᴝ'), + (0x1D5A, 'M', u'ɯ'), + (0x1D5B, 'M', u'v'), + (0x1D5C, 'M', u'ᴥ'), + (0x1D5D, 'M', u'β'), + (0x1D5E, 'M', u'γ'), + (0x1D5F, 'M', u'δ'), + (0x1D60, 'M', u'φ'), + (0x1D61, 'M', u'χ'), + (0x1D62, 'M', u'i'), + (0x1D63, 'M', u'r'), + (0x1D64, 'M', u'u'), + (0x1D65, 'M', u'v'), + (0x1D66, 'M', u'β'), + (0x1D67, 'M', u'γ'), + (0x1D68, 'M', u'ρ'), + (0x1D69, 'M', u'φ'), + (0x1D6A, 'M', u'χ'), + (0x1D6B, 'V'), + (0x1D78, 'M', u'н'), + (0x1D79, 'V'), + (0x1D9B, 'M', u'ɒ'), + (0x1D9C, 'M', u'c'), + (0x1D9D, 'M', u'ɕ'), + (0x1D9E, 'M', u'ð'), + ] + +def _seg_16(): + return [ + (0x1D9F, 'M', u'ɜ'), + (0x1DA0, 'M', u'f'), + (0x1DA1, 'M', u'ɟ'), + (0x1DA2, 'M', u'ɡ'), + (0x1DA3, 'M', u'ɥ'), + (0x1DA4, 'M', u'ɨ'), + (0x1DA5, 'M', u'ɩ'), + (0x1DA6, 'M', u'ɪ'), + (0x1DA7, 'M', u'ᵻ'), + (0x1DA8, 'M', u'ʝ'), + (0x1DA9, 'M', u'ɭ'), + (0x1DAA, 'M', u'ᶅ'), + (0x1DAB, 'M', u'ʟ'), + (0x1DAC, 'M', u'ɱ'), + (0x1DAD, 'M', u'ɰ'), + (0x1DAE, 'M', u'ɲ'), + (0x1DAF, 'M', u'ɳ'), + (0x1DB0, 'M', u'ɴ'), + (0x1DB1, 'M', u'ɵ'), + (0x1DB2, 'M', u'ɸ'), + (0x1DB3, 'M', u'ʂ'), + (0x1DB4, 'M', u'ʃ'), + (0x1DB5, 'M', u'ƫ'), + (0x1DB6, 'M', u'ʉ'), + (0x1DB7, 'M', u'ʊ'), + (0x1DB8, 'M', u'ᴜ'), + (0x1DB9, 'M', u'ʋ'), + (0x1DBA, 'M', u'ʌ'), + (0x1DBB, 'M', u'z'), + (0x1DBC, 'M', u'ʐ'), + (0x1DBD, 'M', u'ʑ'), + (0x1DBE, 'M', u'ʒ'), + (0x1DBF, 'M', u'θ'), + (0x1DC0, 'V'), + (0x1DFA, 'X'), + (0x1DFB, 'V'), + (0x1E00, 'M', u'ḁ'), + (0x1E01, 'V'), + (0x1E02, 'M', u'ḃ'), + (0x1E03, 'V'), + (0x1E04, 'M', u'ḅ'), + (0x1E05, 'V'), + (0x1E06, 'M', u'ḇ'), + (0x1E07, 'V'), + (0x1E08, 'M', u'ḉ'), + (0x1E09, 'V'), + (0x1E0A, 'M', u'ḋ'), + (0x1E0B, 'V'), + (0x1E0C, 'M', u'ḍ'), + (0x1E0D, 'V'), + (0x1E0E, 'M', u'ḏ'), + (0x1E0F, 'V'), + (0x1E10, 'M', u'ḑ'), + (0x1E11, 'V'), + (0x1E12, 'M', u'ḓ'), + (0x1E13, 'V'), + (0x1E14, 'M', u'ḕ'), + (0x1E15, 'V'), + (0x1E16, 'M', u'ḗ'), + (0x1E17, 'V'), + (0x1E18, 'M', u'ḙ'), + (0x1E19, 'V'), + (0x1E1A, 'M', u'ḛ'), + (0x1E1B, 'V'), + (0x1E1C, 'M', u'ḝ'), + (0x1E1D, 'V'), + (0x1E1E, 'M', u'ḟ'), + (0x1E1F, 'V'), + (0x1E20, 'M', u'ḡ'), + (0x1E21, 'V'), + (0x1E22, 'M', u'ḣ'), + (0x1E23, 'V'), + (0x1E24, 'M', u'ḥ'), + (0x1E25, 'V'), + (0x1E26, 'M', u'ḧ'), + (0x1E27, 'V'), + (0x1E28, 'M', u'ḩ'), + (0x1E29, 'V'), + (0x1E2A, 'M', u'ḫ'), + (0x1E2B, 'V'), + (0x1E2C, 'M', u'ḭ'), + (0x1E2D, 'V'), + (0x1E2E, 'M', u'ḯ'), + (0x1E2F, 'V'), + (0x1E30, 'M', u'ḱ'), + (0x1E31, 'V'), + (0x1E32, 'M', u'ḳ'), + (0x1E33, 'V'), + (0x1E34, 'M', u'ḵ'), + (0x1E35, 'V'), + (0x1E36, 'M', u'ḷ'), + (0x1E37, 'V'), + (0x1E38, 'M', u'ḹ'), + (0x1E39, 'V'), + (0x1E3A, 'M', u'ḻ'), + (0x1E3B, 'V'), + (0x1E3C, 'M', u'ḽ'), + (0x1E3D, 'V'), + (0x1E3E, 'M', u'ḿ'), + (0x1E3F, 'V'), + ] + +def _seg_17(): + return [ + (0x1E40, 'M', u'ṁ'), + (0x1E41, 'V'), + (0x1E42, 'M', u'ṃ'), + (0x1E43, 'V'), + (0x1E44, 'M', u'ṅ'), + (0x1E45, 'V'), + (0x1E46, 'M', u'ṇ'), + (0x1E47, 'V'), + (0x1E48, 'M', u'ṉ'), + (0x1E49, 'V'), + (0x1E4A, 'M', u'ṋ'), + (0x1E4B, 'V'), + (0x1E4C, 'M', u'ṍ'), + (0x1E4D, 'V'), + (0x1E4E, 'M', u'ṏ'), + (0x1E4F, 'V'), + (0x1E50, 'M', u'ṑ'), + (0x1E51, 'V'), + (0x1E52, 'M', u'ṓ'), + (0x1E53, 'V'), + (0x1E54, 'M', u'ṕ'), + (0x1E55, 'V'), + (0x1E56, 'M', u'ṗ'), + (0x1E57, 'V'), + (0x1E58, 'M', u'ṙ'), + (0x1E59, 'V'), + (0x1E5A, 'M', u'ṛ'), + (0x1E5B, 'V'), + (0x1E5C, 'M', u'ṝ'), + (0x1E5D, 'V'), + (0x1E5E, 'M', u'ṟ'), + (0x1E5F, 'V'), + (0x1E60, 'M', u'ṡ'), + (0x1E61, 'V'), + (0x1E62, 'M', u'ṣ'), + (0x1E63, 'V'), + (0x1E64, 'M', u'ṥ'), + (0x1E65, 'V'), + (0x1E66, 'M', u'ṧ'), + (0x1E67, 'V'), + (0x1E68, 'M', u'ṩ'), + (0x1E69, 'V'), + (0x1E6A, 'M', u'ṫ'), + (0x1E6B, 'V'), + (0x1E6C, 'M', u'ṭ'), + (0x1E6D, 'V'), + (0x1E6E, 'M', u'ṯ'), + (0x1E6F, 'V'), + (0x1E70, 'M', u'ṱ'), + (0x1E71, 'V'), + (0x1E72, 'M', u'ṳ'), + (0x1E73, 'V'), + (0x1E74, 'M', u'ṵ'), + (0x1E75, 'V'), + (0x1E76, 'M', u'ṷ'), + (0x1E77, 'V'), + (0x1E78, 'M', u'ṹ'), + (0x1E79, 'V'), + (0x1E7A, 'M', u'ṻ'), + (0x1E7B, 'V'), + (0x1E7C, 'M', u'ṽ'), + (0x1E7D, 'V'), + (0x1E7E, 'M', u'ṿ'), + (0x1E7F, 'V'), + (0x1E80, 'M', u'ẁ'), + (0x1E81, 'V'), + (0x1E82, 'M', u'ẃ'), + (0x1E83, 'V'), + (0x1E84, 'M', u'ẅ'), + (0x1E85, 'V'), + (0x1E86, 'M', u'ẇ'), + (0x1E87, 'V'), + (0x1E88, 'M', u'ẉ'), + (0x1E89, 'V'), + (0x1E8A, 'M', u'ẋ'), + (0x1E8B, 'V'), + (0x1E8C, 'M', u'ẍ'), + (0x1E8D, 'V'), + (0x1E8E, 'M', u'ẏ'), + (0x1E8F, 'V'), + (0x1E90, 'M', u'ẑ'), + (0x1E91, 'V'), + (0x1E92, 'M', u'ẓ'), + (0x1E93, 'V'), + (0x1E94, 'M', u'ẕ'), + (0x1E95, 'V'), + (0x1E9A, 'M', u'aʾ'), + (0x1E9B, 'M', u'ṡ'), + (0x1E9C, 'V'), + (0x1E9E, 'M', u'ss'), + (0x1E9F, 'V'), + (0x1EA0, 'M', u'ạ'), + (0x1EA1, 'V'), + (0x1EA2, 'M', u'ả'), + (0x1EA3, 'V'), + (0x1EA4, 'M', u'ấ'), + (0x1EA5, 'V'), + (0x1EA6, 'M', u'ầ'), + (0x1EA7, 'V'), + (0x1EA8, 'M', u'ẩ'), + ] + +def _seg_18(): + return [ + (0x1EA9, 'V'), + (0x1EAA, 'M', u'ẫ'), + (0x1EAB, 'V'), + (0x1EAC, 'M', u'ậ'), + (0x1EAD, 'V'), + (0x1EAE, 'M', u'ắ'), + (0x1EAF, 'V'), + (0x1EB0, 'M', u'ằ'), + (0x1EB1, 'V'), + (0x1EB2, 'M', u'ẳ'), + (0x1EB3, 'V'), + (0x1EB4, 'M', u'ẵ'), + (0x1EB5, 'V'), + (0x1EB6, 'M', u'ặ'), + (0x1EB7, 'V'), + (0x1EB8, 'M', u'ẹ'), + (0x1EB9, 'V'), + (0x1EBA, 'M', u'ẻ'), + (0x1EBB, 'V'), + (0x1EBC, 'M', u'ẽ'), + (0x1EBD, 'V'), + (0x1EBE, 'M', u'ế'), + (0x1EBF, 'V'), + (0x1EC0, 'M', u'ề'), + (0x1EC1, 'V'), + (0x1EC2, 'M', u'ể'), + (0x1EC3, 'V'), + (0x1EC4, 'M', u'ễ'), + (0x1EC5, 'V'), + (0x1EC6, 'M', u'ệ'), + (0x1EC7, 'V'), + (0x1EC8, 'M', u'ỉ'), + (0x1EC9, 'V'), + (0x1ECA, 'M', u'ị'), + (0x1ECB, 'V'), + (0x1ECC, 'M', u'ọ'), + (0x1ECD, 'V'), + (0x1ECE, 'M', u'ỏ'), + (0x1ECF, 'V'), + (0x1ED0, 'M', u'ố'), + (0x1ED1, 'V'), + (0x1ED2, 'M', u'ồ'), + (0x1ED3, 'V'), + (0x1ED4, 'M', u'ổ'), + (0x1ED5, 'V'), + (0x1ED6, 'M', u'ỗ'), + (0x1ED7, 'V'), + (0x1ED8, 'M', u'ộ'), + (0x1ED9, 'V'), + (0x1EDA, 'M', u'ớ'), + (0x1EDB, 'V'), + (0x1EDC, 'M', u'ờ'), + (0x1EDD, 'V'), + (0x1EDE, 'M', u'ở'), + (0x1EDF, 'V'), + (0x1EE0, 'M', u'ỡ'), + (0x1EE1, 'V'), + (0x1EE2, 'M', u'ợ'), + (0x1EE3, 'V'), + (0x1EE4, 'M', u'ụ'), + (0x1EE5, 'V'), + (0x1EE6, 'M', u'ủ'), + (0x1EE7, 'V'), + (0x1EE8, 'M', u'ứ'), + (0x1EE9, 'V'), + (0x1EEA, 'M', u'ừ'), + (0x1EEB, 'V'), + (0x1EEC, 'M', u'ử'), + (0x1EED, 'V'), + (0x1EEE, 'M', u'ữ'), + (0x1EEF, 'V'), + (0x1EF0, 'M', u'ự'), + (0x1EF1, 'V'), + (0x1EF2, 'M', u'ỳ'), + (0x1EF3, 'V'), + (0x1EF4, 'M', u'ỵ'), + (0x1EF5, 'V'), + (0x1EF6, 'M', u'ỷ'), + (0x1EF7, 'V'), + (0x1EF8, 'M', u'ỹ'), + (0x1EF9, 'V'), + (0x1EFA, 'M', u'ỻ'), + (0x1EFB, 'V'), + (0x1EFC, 'M', u'ỽ'), + (0x1EFD, 'V'), + (0x1EFE, 'M', u'ỿ'), + (0x1EFF, 'V'), + (0x1F08, 'M', u'ἀ'), + (0x1F09, 'M', u'ἁ'), + (0x1F0A, 'M', u'ἂ'), + (0x1F0B, 'M', u'ἃ'), + (0x1F0C, 'M', u'ἄ'), + (0x1F0D, 'M', u'ἅ'), + (0x1F0E, 'M', u'ἆ'), + (0x1F0F, 'M', u'ἇ'), + (0x1F10, 'V'), + (0x1F16, 'X'), + (0x1F18, 'M', u'ἐ'), + (0x1F19, 'M', u'ἑ'), + (0x1F1A, 'M', u'ἒ'), + ] + +def _seg_19(): + return [ + (0x1F1B, 'M', u'ἓ'), + (0x1F1C, 'M', u'ἔ'), + (0x1F1D, 'M', u'ἕ'), + (0x1F1E, 'X'), + (0x1F20, 'V'), + (0x1F28, 'M', u'ἠ'), + (0x1F29, 'M', u'ἡ'), + (0x1F2A, 'M', u'ἢ'), + (0x1F2B, 'M', u'ἣ'), + (0x1F2C, 'M', u'ἤ'), + (0x1F2D, 'M', u'ἥ'), + (0x1F2E, 'M', u'ἦ'), + (0x1F2F, 'M', u'ἧ'), + (0x1F30, 'V'), + (0x1F38, 'M', u'ἰ'), + (0x1F39, 'M', u'ἱ'), + (0x1F3A, 'M', u'ἲ'), + (0x1F3B, 'M', u'ἳ'), + (0x1F3C, 'M', u'ἴ'), + (0x1F3D, 'M', u'ἵ'), + (0x1F3E, 'M', u'ἶ'), + (0x1F3F, 'M', u'ἷ'), + (0x1F40, 'V'), + (0x1F46, 'X'), + (0x1F48, 'M', u'ὀ'), + (0x1F49, 'M', u'ὁ'), + (0x1F4A, 'M', u'ὂ'), + (0x1F4B, 'M', u'ὃ'), + (0x1F4C, 'M', u'ὄ'), + (0x1F4D, 'M', u'ὅ'), + (0x1F4E, 'X'), + (0x1F50, 'V'), + (0x1F58, 'X'), + (0x1F59, 'M', u'ὑ'), + (0x1F5A, 'X'), + (0x1F5B, 'M', u'ὓ'), + (0x1F5C, 'X'), + (0x1F5D, 'M', u'ὕ'), + (0x1F5E, 'X'), + (0x1F5F, 'M', u'ὗ'), + (0x1F60, 'V'), + (0x1F68, 'M', u'ὠ'), + (0x1F69, 'M', u'ὡ'), + (0x1F6A, 'M', u'ὢ'), + (0x1F6B, 'M', u'ὣ'), + (0x1F6C, 'M', u'ὤ'), + (0x1F6D, 'M', u'ὥ'), + (0x1F6E, 'M', u'ὦ'), + (0x1F6F, 'M', u'ὧ'), + (0x1F70, 'V'), + (0x1F71, 'M', u'ά'), + (0x1F72, 'V'), + (0x1F73, 'M', u'έ'), + (0x1F74, 'V'), + (0x1F75, 'M', u'ή'), + (0x1F76, 'V'), + (0x1F77, 'M', u'ί'), + (0x1F78, 'V'), + (0x1F79, 'M', u'ό'), + (0x1F7A, 'V'), + (0x1F7B, 'M', u'ύ'), + (0x1F7C, 'V'), + (0x1F7D, 'M', u'ώ'), + (0x1F7E, 'X'), + (0x1F80, 'M', u'ἀι'), + (0x1F81, 'M', u'ἁι'), + (0x1F82, 'M', u'ἂι'), + (0x1F83, 'M', u'ἃι'), + (0x1F84, 'M', u'ἄι'), + (0x1F85, 'M', u'ἅι'), + (0x1F86, 'M', u'ἆι'), + (0x1F87, 'M', u'ἇι'), + (0x1F88, 'M', u'ἀι'), + (0x1F89, 'M', u'ἁι'), + (0x1F8A, 'M', u'ἂι'), + (0x1F8B, 'M', u'ἃι'), + (0x1F8C, 'M', u'ἄι'), + (0x1F8D, 'M', u'ἅι'), + (0x1F8E, 'M', u'ἆι'), + (0x1F8F, 'M', u'ἇι'), + (0x1F90, 'M', u'ἠι'), + (0x1F91, 'M', u'ἡι'), + (0x1F92, 'M', u'ἢι'), + (0x1F93, 'M', u'ἣι'), + (0x1F94, 'M', u'ἤι'), + (0x1F95, 'M', u'ἥι'), + (0x1F96, 'M', u'ἦι'), + (0x1F97, 'M', u'ἧι'), + (0x1F98, 'M', u'ἠι'), + (0x1F99, 'M', u'ἡι'), + (0x1F9A, 'M', u'ἢι'), + (0x1F9B, 'M', u'ἣι'), + (0x1F9C, 'M', u'ἤι'), + (0x1F9D, 'M', u'ἥι'), + (0x1F9E, 'M', u'ἦι'), + (0x1F9F, 'M', u'ἧι'), + (0x1FA0, 'M', u'ὠι'), + (0x1FA1, 'M', u'ὡι'), + (0x1FA2, 'M', u'ὢι'), + (0x1FA3, 'M', u'ὣι'), + ] + +def _seg_20(): + return [ + (0x1FA4, 'M', u'ὤι'), + (0x1FA5, 'M', u'ὥι'), + (0x1FA6, 'M', u'ὦι'), + (0x1FA7, 'M', u'ὧι'), + (0x1FA8, 'M', u'ὠι'), + (0x1FA9, 'M', u'ὡι'), + (0x1FAA, 'M', u'ὢι'), + (0x1FAB, 'M', u'ὣι'), + (0x1FAC, 'M', u'ὤι'), + (0x1FAD, 'M', u'ὥι'), + (0x1FAE, 'M', u'ὦι'), + (0x1FAF, 'M', u'ὧι'), + (0x1FB0, 'V'), + (0x1FB2, 'M', u'ὰι'), + (0x1FB3, 'M', u'αι'), + (0x1FB4, 'M', u'άι'), + (0x1FB5, 'X'), + (0x1FB6, 'V'), + (0x1FB7, 'M', u'ᾶι'), + (0x1FB8, 'M', u'ᾰ'), + (0x1FB9, 'M', u'ᾱ'), + (0x1FBA, 'M', u'ὰ'), + (0x1FBB, 'M', u'ά'), + (0x1FBC, 'M', u'αι'), + (0x1FBD, '3', u' ̓'), + (0x1FBE, 'M', u'ι'), + (0x1FBF, '3', u' ̓'), + (0x1FC0, '3', u' ͂'), + (0x1FC1, '3', u' ̈͂'), + (0x1FC2, 'M', u'ὴι'), + (0x1FC3, 'M', u'ηι'), + (0x1FC4, 'M', u'ήι'), + (0x1FC5, 'X'), + (0x1FC6, 'V'), + (0x1FC7, 'M', u'ῆι'), + (0x1FC8, 'M', u'ὲ'), + (0x1FC9, 'M', u'έ'), + (0x1FCA, 'M', u'ὴ'), + (0x1FCB, 'M', u'ή'), + (0x1FCC, 'M', u'ηι'), + (0x1FCD, '3', u' ̓̀'), + (0x1FCE, '3', u' ̓́'), + (0x1FCF, '3', u' ̓͂'), + (0x1FD0, 'V'), + (0x1FD3, 'M', u'ΐ'), + (0x1FD4, 'X'), + (0x1FD6, 'V'), + (0x1FD8, 'M', u'ῐ'), + (0x1FD9, 'M', u'ῑ'), + (0x1FDA, 'M', u'ὶ'), + (0x1FDB, 'M', u'ί'), + (0x1FDC, 'X'), + (0x1FDD, '3', u' ̔̀'), + (0x1FDE, '3', u' ̔́'), + (0x1FDF, '3', u' ̔͂'), + (0x1FE0, 'V'), + (0x1FE3, 'M', u'ΰ'), + (0x1FE4, 'V'), + (0x1FE8, 'M', u'ῠ'), + (0x1FE9, 'M', u'ῡ'), + (0x1FEA, 'M', u'ὺ'), + (0x1FEB, 'M', u'ύ'), + (0x1FEC, 'M', u'ῥ'), + (0x1FED, '3', u' ̈̀'), + (0x1FEE, '3', u' ̈́'), + (0x1FEF, '3', u'`'), + (0x1FF0, 'X'), + (0x1FF2, 'M', u'ὼι'), + (0x1FF3, 'M', u'ωι'), + (0x1FF4, 'M', u'ώι'), + (0x1FF5, 'X'), + (0x1FF6, 'V'), + (0x1FF7, 'M', u'ῶι'), + (0x1FF8, 'M', u'ὸ'), + (0x1FF9, 'M', u'ό'), + (0x1FFA, 'M', u'ὼ'), + (0x1FFB, 'M', u'ώ'), + (0x1FFC, 'M', u'ωι'), + (0x1FFD, '3', u' ́'), + (0x1FFE, '3', u' ̔'), + (0x1FFF, 'X'), + (0x2000, '3', u' '), + (0x200B, 'I'), + (0x200C, 'D', u''), + (0x200E, 'X'), + (0x2010, 'V'), + (0x2011, 'M', u'‐'), + (0x2012, 'V'), + (0x2017, '3', u' ̳'), + (0x2018, 'V'), + (0x2024, 'X'), + (0x2027, 'V'), + (0x2028, 'X'), + (0x202F, '3', u' '), + (0x2030, 'V'), + (0x2033, 'M', u'′′'), + (0x2034, 'M', u'′′′'), + (0x2035, 'V'), + (0x2036, 'M', u'‵‵'), + (0x2037, 'M', u'‵‵‵'), + ] + +def _seg_21(): + return [ + (0x2038, 'V'), + (0x203C, '3', u'!!'), + (0x203D, 'V'), + (0x203E, '3', u' ̅'), + (0x203F, 'V'), + (0x2047, '3', u'??'), + (0x2048, '3', u'?!'), + (0x2049, '3', u'!?'), + (0x204A, 'V'), + (0x2057, 'M', u'′′′′'), + (0x2058, 'V'), + (0x205F, '3', u' '), + (0x2060, 'I'), + (0x2061, 'X'), + (0x2064, 'I'), + (0x2065, 'X'), + (0x2070, 'M', u'0'), + (0x2071, 'M', u'i'), + (0x2072, 'X'), + (0x2074, 'M', u'4'), + (0x2075, 'M', u'5'), + (0x2076, 'M', u'6'), + (0x2077, 'M', u'7'), + (0x2078, 'M', u'8'), + (0x2079, 'M', u'9'), + (0x207A, '3', u'+'), + (0x207B, 'M', u'−'), + (0x207C, '3', u'='), + (0x207D, '3', u'('), + (0x207E, '3', u')'), + (0x207F, 'M', u'n'), + (0x2080, 'M', u'0'), + (0x2081, 'M', u'1'), + (0x2082, 'M', u'2'), + (0x2083, 'M', u'3'), + (0x2084, 'M', u'4'), + (0x2085, 'M', u'5'), + (0x2086, 'M', u'6'), + (0x2087, 'M', u'7'), + (0x2088, 'M', u'8'), + (0x2089, 'M', u'9'), + (0x208A, '3', u'+'), + (0x208B, 'M', u'−'), + (0x208C, '3', u'='), + (0x208D, '3', u'('), + (0x208E, '3', u')'), + (0x208F, 'X'), + (0x2090, 'M', u'a'), + (0x2091, 'M', u'e'), + (0x2092, 'M', u'o'), + (0x2093, 'M', u'x'), + (0x2094, 'M', u'ə'), + (0x2095, 'M', u'h'), + (0x2096, 'M', u'k'), + (0x2097, 'M', u'l'), + (0x2098, 'M', u'm'), + (0x2099, 'M', u'n'), + (0x209A, 'M', u'p'), + (0x209B, 'M', u's'), + (0x209C, 'M', u't'), + (0x209D, 'X'), + (0x20A0, 'V'), + (0x20A8, 'M', u'rs'), + (0x20A9, 'V'), + (0x20C0, 'X'), + (0x20D0, 'V'), + (0x20F1, 'X'), + (0x2100, '3', u'a/c'), + (0x2101, '3', u'a/s'), + (0x2102, 'M', u'c'), + (0x2103, 'M', u'°c'), + (0x2104, 'V'), + (0x2105, '3', u'c/o'), + (0x2106, '3', u'c/u'), + (0x2107, 'M', u'ɛ'), + (0x2108, 'V'), + (0x2109, 'M', u'°f'), + (0x210A, 'M', u'g'), + (0x210B, 'M', u'h'), + (0x210F, 'M', u'ħ'), + (0x2110, 'M', u'i'), + (0x2112, 'M', u'l'), + (0x2114, 'V'), + (0x2115, 'M', u'n'), + (0x2116, 'M', u'no'), + (0x2117, 'V'), + (0x2119, 'M', u'p'), + (0x211A, 'M', u'q'), + (0x211B, 'M', u'r'), + (0x211E, 'V'), + (0x2120, 'M', u'sm'), + (0x2121, 'M', u'tel'), + (0x2122, 'M', u'tm'), + (0x2123, 'V'), + (0x2124, 'M', u'z'), + (0x2125, 'V'), + (0x2126, 'M', u'ω'), + (0x2127, 'V'), + (0x2128, 'M', u'z'), + (0x2129, 'V'), + ] + +def _seg_22(): + return [ + (0x212A, 'M', u'k'), + (0x212B, 'M', u'å'), + (0x212C, 'M', u'b'), + (0x212D, 'M', u'c'), + (0x212E, 'V'), + (0x212F, 'M', u'e'), + (0x2131, 'M', u'f'), + (0x2132, 'X'), + (0x2133, 'M', u'm'), + (0x2134, 'M', u'o'), + (0x2135, 'M', u'א'), + (0x2136, 'M', u'ב'), + (0x2137, 'M', u'ג'), + (0x2138, 'M', u'ד'), + (0x2139, 'M', u'i'), + (0x213A, 'V'), + (0x213B, 'M', u'fax'), + (0x213C, 'M', u'π'), + (0x213D, 'M', u'γ'), + (0x213F, 'M', u'π'), + (0x2140, 'M', u'∑'), + (0x2141, 'V'), + (0x2145, 'M', u'd'), + (0x2147, 'M', u'e'), + (0x2148, 'M', u'i'), + (0x2149, 'M', u'j'), + (0x214A, 'V'), + (0x2150, 'M', u'1⁄7'), + (0x2151, 'M', u'1⁄9'), + (0x2152, 'M', u'1⁄10'), + (0x2153, 'M', u'1⁄3'), + (0x2154, 'M', u'2⁄3'), + (0x2155, 'M', u'1⁄5'), + (0x2156, 'M', u'2⁄5'), + (0x2157, 'M', u'3⁄5'), + (0x2158, 'M', u'4⁄5'), + (0x2159, 'M', u'1⁄6'), + (0x215A, 'M', u'5⁄6'), + (0x215B, 'M', u'1⁄8'), + (0x215C, 'M', u'3⁄8'), + (0x215D, 'M', u'5⁄8'), + (0x215E, 'M', u'7⁄8'), + (0x215F, 'M', u'1⁄'), + (0x2160, 'M', u'i'), + (0x2161, 'M', u'ii'), + (0x2162, 'M', u'iii'), + (0x2163, 'M', u'iv'), + (0x2164, 'M', u'v'), + (0x2165, 'M', u'vi'), + (0x2166, 'M', u'vii'), + (0x2167, 'M', u'viii'), + (0x2168, 'M', u'ix'), + (0x2169, 'M', u'x'), + (0x216A, 'M', u'xi'), + (0x216B, 'M', u'xii'), + (0x216C, 'M', u'l'), + (0x216D, 'M', u'c'), + (0x216E, 'M', u'd'), + (0x216F, 'M', u'm'), + (0x2170, 'M', u'i'), + (0x2171, 'M', u'ii'), + (0x2172, 'M', u'iii'), + (0x2173, 'M', u'iv'), + (0x2174, 'M', u'v'), + (0x2175, 'M', u'vi'), + (0x2176, 'M', u'vii'), + (0x2177, 'M', u'viii'), + (0x2178, 'M', u'ix'), + (0x2179, 'M', u'x'), + (0x217A, 'M', u'xi'), + (0x217B, 'M', u'xii'), + (0x217C, 'M', u'l'), + (0x217D, 'M', u'c'), + (0x217E, 'M', u'd'), + (0x217F, 'M', u'm'), + (0x2180, 'V'), + (0x2183, 'X'), + (0x2184, 'V'), + (0x2189, 'M', u'0⁄3'), + (0x218A, 'V'), + (0x218C, 'X'), + (0x2190, 'V'), + (0x222C, 'M', u'∫∫'), + (0x222D, 'M', u'∫∫∫'), + (0x222E, 'V'), + (0x222F, 'M', u'∮∮'), + (0x2230, 'M', u'∮∮∮'), + (0x2231, 'V'), + (0x2260, '3'), + (0x2261, 'V'), + (0x226E, '3'), + (0x2270, 'V'), + (0x2329, 'M', u'〈'), + (0x232A, 'M', u'〉'), + (0x232B, 'V'), + (0x2427, 'X'), + (0x2440, 'V'), + (0x244B, 'X'), + (0x2460, 'M', u'1'), + (0x2461, 'M', u'2'), + ] + +def _seg_23(): + return [ + (0x2462, 'M', u'3'), + (0x2463, 'M', u'4'), + (0x2464, 'M', u'5'), + (0x2465, 'M', u'6'), + (0x2466, 'M', u'7'), + (0x2467, 'M', u'8'), + (0x2468, 'M', u'9'), + (0x2469, 'M', u'10'), + (0x246A, 'M', u'11'), + (0x246B, 'M', u'12'), + (0x246C, 'M', u'13'), + (0x246D, 'M', u'14'), + (0x246E, 'M', u'15'), + (0x246F, 'M', u'16'), + (0x2470, 'M', u'17'), + (0x2471, 'M', u'18'), + (0x2472, 'M', u'19'), + (0x2473, 'M', u'20'), + (0x2474, '3', u'(1)'), + (0x2475, '3', u'(2)'), + (0x2476, '3', u'(3)'), + (0x2477, '3', u'(4)'), + (0x2478, '3', u'(5)'), + (0x2479, '3', u'(6)'), + (0x247A, '3', u'(7)'), + (0x247B, '3', u'(8)'), + (0x247C, '3', u'(9)'), + (0x247D, '3', u'(10)'), + (0x247E, '3', u'(11)'), + (0x247F, '3', u'(12)'), + (0x2480, '3', u'(13)'), + (0x2481, '3', u'(14)'), + (0x2482, '3', u'(15)'), + (0x2483, '3', u'(16)'), + (0x2484, '3', u'(17)'), + (0x2485, '3', u'(18)'), + (0x2486, '3', u'(19)'), + (0x2487, '3', u'(20)'), + (0x2488, 'X'), + (0x249C, '3', u'(a)'), + (0x249D, '3', u'(b)'), + (0x249E, '3', u'(c)'), + (0x249F, '3', u'(d)'), + (0x24A0, '3', u'(e)'), + (0x24A1, '3', u'(f)'), + (0x24A2, '3', u'(g)'), + (0x24A3, '3', u'(h)'), + (0x24A4, '3', u'(i)'), + (0x24A5, '3', u'(j)'), + (0x24A6, '3', u'(k)'), + (0x24A7, '3', u'(l)'), + (0x24A8, '3', u'(m)'), + (0x24A9, '3', u'(n)'), + (0x24AA, '3', u'(o)'), + (0x24AB, '3', u'(p)'), + (0x24AC, '3', u'(q)'), + (0x24AD, '3', u'(r)'), + (0x24AE, '3', u'(s)'), + (0x24AF, '3', u'(t)'), + (0x24B0, '3', u'(u)'), + (0x24B1, '3', u'(v)'), + (0x24B2, '3', u'(w)'), + (0x24B3, '3', u'(x)'), + (0x24B4, '3', u'(y)'), + (0x24B5, '3', u'(z)'), + (0x24B6, 'M', u'a'), + (0x24B7, 'M', u'b'), + (0x24B8, 'M', u'c'), + (0x24B9, 'M', u'd'), + (0x24BA, 'M', u'e'), + (0x24BB, 'M', u'f'), + (0x24BC, 'M', u'g'), + (0x24BD, 'M', u'h'), + (0x24BE, 'M', u'i'), + (0x24BF, 'M', u'j'), + (0x24C0, 'M', u'k'), + (0x24C1, 'M', u'l'), + (0x24C2, 'M', u'm'), + (0x24C3, 'M', u'n'), + (0x24C4, 'M', u'o'), + (0x24C5, 'M', u'p'), + (0x24C6, 'M', u'q'), + (0x24C7, 'M', u'r'), + (0x24C8, 'M', u's'), + (0x24C9, 'M', u't'), + (0x24CA, 'M', u'u'), + (0x24CB, 'M', u'v'), + (0x24CC, 'M', u'w'), + (0x24CD, 'M', u'x'), + (0x24CE, 'M', u'y'), + (0x24CF, 'M', u'z'), + (0x24D0, 'M', u'a'), + (0x24D1, 'M', u'b'), + (0x24D2, 'M', u'c'), + (0x24D3, 'M', u'd'), + (0x24D4, 'M', u'e'), + (0x24D5, 'M', u'f'), + (0x24D6, 'M', u'g'), + (0x24D7, 'M', u'h'), + (0x24D8, 'M', u'i'), + ] + +def _seg_24(): + return [ + (0x24D9, 'M', u'j'), + (0x24DA, 'M', u'k'), + (0x24DB, 'M', u'l'), + (0x24DC, 'M', u'm'), + (0x24DD, 'M', u'n'), + (0x24DE, 'M', u'o'), + (0x24DF, 'M', u'p'), + (0x24E0, 'M', u'q'), + (0x24E1, 'M', u'r'), + (0x24E2, 'M', u's'), + (0x24E3, 'M', u't'), + (0x24E4, 'M', u'u'), + (0x24E5, 'M', u'v'), + (0x24E6, 'M', u'w'), + (0x24E7, 'M', u'x'), + (0x24E8, 'M', u'y'), + (0x24E9, 'M', u'z'), + (0x24EA, 'M', u'0'), + (0x24EB, 'V'), + (0x2A0C, 'M', u'∫∫∫∫'), + (0x2A0D, 'V'), + (0x2A74, '3', u'::='), + (0x2A75, '3', u'=='), + (0x2A76, '3', u'==='), + (0x2A77, 'V'), + (0x2ADC, 'M', u'⫝̸'), + (0x2ADD, 'V'), + (0x2B74, 'X'), + (0x2B76, 'V'), + (0x2B96, 'X'), + (0x2B98, 'V'), + (0x2BC9, 'X'), + (0x2BCA, 'V'), + (0x2BFF, 'X'), + (0x2C00, 'M', u'ⰰ'), + (0x2C01, 'M', u'ⰱ'), + (0x2C02, 'M', u'ⰲ'), + (0x2C03, 'M', u'ⰳ'), + (0x2C04, 'M', u'ⰴ'), + (0x2C05, 'M', u'ⰵ'), + (0x2C06, 'M', u'ⰶ'), + (0x2C07, 'M', u'ⰷ'), + (0x2C08, 'M', u'ⰸ'), + (0x2C09, 'M', u'ⰹ'), + (0x2C0A, 'M', u'ⰺ'), + (0x2C0B, 'M', u'ⰻ'), + (0x2C0C, 'M', u'ⰼ'), + (0x2C0D, 'M', u'ⰽ'), + (0x2C0E, 'M', u'ⰾ'), + (0x2C0F, 'M', u'ⰿ'), + (0x2C10, 'M', u'ⱀ'), + (0x2C11, 'M', u'ⱁ'), + (0x2C12, 'M', u'ⱂ'), + (0x2C13, 'M', u'ⱃ'), + (0x2C14, 'M', u'ⱄ'), + (0x2C15, 'M', u'ⱅ'), + (0x2C16, 'M', u'ⱆ'), + (0x2C17, 'M', u'ⱇ'), + (0x2C18, 'M', u'ⱈ'), + (0x2C19, 'M', u'ⱉ'), + (0x2C1A, 'M', u'ⱊ'), + (0x2C1B, 'M', u'ⱋ'), + (0x2C1C, 'M', u'ⱌ'), + (0x2C1D, 'M', u'ⱍ'), + (0x2C1E, 'M', u'ⱎ'), + (0x2C1F, 'M', u'ⱏ'), + (0x2C20, 'M', u'ⱐ'), + (0x2C21, 'M', u'ⱑ'), + (0x2C22, 'M', u'ⱒ'), + (0x2C23, 'M', u'ⱓ'), + (0x2C24, 'M', u'ⱔ'), + (0x2C25, 'M', u'ⱕ'), + (0x2C26, 'M', u'ⱖ'), + (0x2C27, 'M', u'ⱗ'), + (0x2C28, 'M', u'ⱘ'), + (0x2C29, 'M', u'ⱙ'), + (0x2C2A, 'M', u'ⱚ'), + (0x2C2B, 'M', u'ⱛ'), + (0x2C2C, 'M', u'ⱜ'), + (0x2C2D, 'M', u'ⱝ'), + (0x2C2E, 'M', u'ⱞ'), + (0x2C2F, 'X'), + (0x2C30, 'V'), + (0x2C5F, 'X'), + (0x2C60, 'M', u'ⱡ'), + (0x2C61, 'V'), + (0x2C62, 'M', u'ɫ'), + (0x2C63, 'M', u'ᵽ'), + (0x2C64, 'M', u'ɽ'), + (0x2C65, 'V'), + (0x2C67, 'M', u'ⱨ'), + (0x2C68, 'V'), + (0x2C69, 'M', u'ⱪ'), + (0x2C6A, 'V'), + (0x2C6B, 'M', u'ⱬ'), + (0x2C6C, 'V'), + (0x2C6D, 'M', u'ɑ'), + (0x2C6E, 'M', u'ɱ'), + (0x2C6F, 'M', u'ɐ'), + (0x2C70, 'M', u'ɒ'), + ] + +def _seg_25(): + return [ + (0x2C71, 'V'), + (0x2C72, 'M', u'ⱳ'), + (0x2C73, 'V'), + (0x2C75, 'M', u'ⱶ'), + (0x2C76, 'V'), + (0x2C7C, 'M', u'j'), + (0x2C7D, 'M', u'v'), + (0x2C7E, 'M', u'ȿ'), + (0x2C7F, 'M', u'ɀ'), + (0x2C80, 'M', u'ⲁ'), + (0x2C81, 'V'), + (0x2C82, 'M', u'ⲃ'), + (0x2C83, 'V'), + (0x2C84, 'M', u'ⲅ'), + (0x2C85, 'V'), + (0x2C86, 'M', u'ⲇ'), + (0x2C87, 'V'), + (0x2C88, 'M', u'ⲉ'), + (0x2C89, 'V'), + (0x2C8A, 'M', u'ⲋ'), + (0x2C8B, 'V'), + (0x2C8C, 'M', u'ⲍ'), + (0x2C8D, 'V'), + (0x2C8E, 'M', u'ⲏ'), + (0x2C8F, 'V'), + (0x2C90, 'M', u'ⲑ'), + (0x2C91, 'V'), + (0x2C92, 'M', u'ⲓ'), + (0x2C93, 'V'), + (0x2C94, 'M', u'ⲕ'), + (0x2C95, 'V'), + (0x2C96, 'M', u'ⲗ'), + (0x2C97, 'V'), + (0x2C98, 'M', u'ⲙ'), + (0x2C99, 'V'), + (0x2C9A, 'M', u'ⲛ'), + (0x2C9B, 'V'), + (0x2C9C, 'M', u'ⲝ'), + (0x2C9D, 'V'), + (0x2C9E, 'M', u'ⲟ'), + (0x2C9F, 'V'), + (0x2CA0, 'M', u'ⲡ'), + (0x2CA1, 'V'), + (0x2CA2, 'M', u'ⲣ'), + (0x2CA3, 'V'), + (0x2CA4, 'M', u'ⲥ'), + (0x2CA5, 'V'), + (0x2CA6, 'M', u'ⲧ'), + (0x2CA7, 'V'), + (0x2CA8, 'M', u'ⲩ'), + (0x2CA9, 'V'), + (0x2CAA, 'M', u'ⲫ'), + (0x2CAB, 'V'), + (0x2CAC, 'M', u'ⲭ'), + (0x2CAD, 'V'), + (0x2CAE, 'M', u'ⲯ'), + (0x2CAF, 'V'), + (0x2CB0, 'M', u'ⲱ'), + (0x2CB1, 'V'), + (0x2CB2, 'M', u'ⲳ'), + (0x2CB3, 'V'), + (0x2CB4, 'M', u'ⲵ'), + (0x2CB5, 'V'), + (0x2CB6, 'M', u'ⲷ'), + (0x2CB7, 'V'), + (0x2CB8, 'M', u'ⲹ'), + (0x2CB9, 'V'), + (0x2CBA, 'M', u'ⲻ'), + (0x2CBB, 'V'), + (0x2CBC, 'M', u'ⲽ'), + (0x2CBD, 'V'), + (0x2CBE, 'M', u'ⲿ'), + (0x2CBF, 'V'), + (0x2CC0, 'M', u'ⳁ'), + (0x2CC1, 'V'), + (0x2CC2, 'M', u'ⳃ'), + (0x2CC3, 'V'), + (0x2CC4, 'M', u'ⳅ'), + (0x2CC5, 'V'), + (0x2CC6, 'M', u'ⳇ'), + (0x2CC7, 'V'), + (0x2CC8, 'M', u'ⳉ'), + (0x2CC9, 'V'), + (0x2CCA, 'M', u'ⳋ'), + (0x2CCB, 'V'), + (0x2CCC, 'M', u'ⳍ'), + (0x2CCD, 'V'), + (0x2CCE, 'M', u'ⳏ'), + (0x2CCF, 'V'), + (0x2CD0, 'M', u'ⳑ'), + (0x2CD1, 'V'), + (0x2CD2, 'M', u'ⳓ'), + (0x2CD3, 'V'), + (0x2CD4, 'M', u'ⳕ'), + (0x2CD5, 'V'), + (0x2CD6, 'M', u'ⳗ'), + (0x2CD7, 'V'), + (0x2CD8, 'M', u'ⳙ'), + (0x2CD9, 'V'), + (0x2CDA, 'M', u'ⳛ'), + ] + +def _seg_26(): + return [ + (0x2CDB, 'V'), + (0x2CDC, 'M', u'ⳝ'), + (0x2CDD, 'V'), + (0x2CDE, 'M', u'ⳟ'), + (0x2CDF, 'V'), + (0x2CE0, 'M', u'ⳡ'), + (0x2CE1, 'V'), + (0x2CE2, 'M', u'ⳣ'), + (0x2CE3, 'V'), + (0x2CEB, 'M', u'ⳬ'), + (0x2CEC, 'V'), + (0x2CED, 'M', u'ⳮ'), + (0x2CEE, 'V'), + (0x2CF2, 'M', u'ⳳ'), + (0x2CF3, 'V'), + (0x2CF4, 'X'), + (0x2CF9, 'V'), + (0x2D26, 'X'), + (0x2D27, 'V'), + (0x2D28, 'X'), + (0x2D2D, 'V'), + (0x2D2E, 'X'), + (0x2D30, 'V'), + (0x2D68, 'X'), + (0x2D6F, 'M', u'ⵡ'), + (0x2D70, 'V'), + (0x2D71, 'X'), + (0x2D7F, 'V'), + (0x2D97, 'X'), + (0x2DA0, 'V'), + (0x2DA7, 'X'), + (0x2DA8, 'V'), + (0x2DAF, 'X'), + (0x2DB0, 'V'), + (0x2DB7, 'X'), + (0x2DB8, 'V'), + (0x2DBF, 'X'), + (0x2DC0, 'V'), + (0x2DC7, 'X'), + (0x2DC8, 'V'), + (0x2DCF, 'X'), + (0x2DD0, 'V'), + (0x2DD7, 'X'), + (0x2DD8, 'V'), + (0x2DDF, 'X'), + (0x2DE0, 'V'), + (0x2E4F, 'X'), + (0x2E80, 'V'), + (0x2E9A, 'X'), + (0x2E9B, 'V'), + (0x2E9F, 'M', u'母'), + (0x2EA0, 'V'), + (0x2EF3, 'M', u'龟'), + (0x2EF4, 'X'), + (0x2F00, 'M', u'一'), + (0x2F01, 'M', u'丨'), + (0x2F02, 'M', u'丶'), + (0x2F03, 'M', u'丿'), + (0x2F04, 'M', u'乙'), + (0x2F05, 'M', u'亅'), + (0x2F06, 'M', u'二'), + (0x2F07, 'M', u'亠'), + (0x2F08, 'M', u'人'), + (0x2F09, 'M', u'儿'), + (0x2F0A, 'M', u'入'), + (0x2F0B, 'M', u'八'), + (0x2F0C, 'M', u'冂'), + (0x2F0D, 'M', u'冖'), + (0x2F0E, 'M', u'冫'), + (0x2F0F, 'M', u'几'), + (0x2F10, 'M', u'凵'), + (0x2F11, 'M', u'刀'), + (0x2F12, 'M', u'力'), + (0x2F13, 'M', u'勹'), + (0x2F14, 'M', u'匕'), + (0x2F15, 'M', u'匚'), + (0x2F16, 'M', u'匸'), + (0x2F17, 'M', u'十'), + (0x2F18, 'M', u'卜'), + (0x2F19, 'M', u'卩'), + (0x2F1A, 'M', u'厂'), + (0x2F1B, 'M', u'厶'), + (0x2F1C, 'M', u'又'), + (0x2F1D, 'M', u'口'), + (0x2F1E, 'M', u'囗'), + (0x2F1F, 'M', u'土'), + (0x2F20, 'M', u'士'), + (0x2F21, 'M', u'夂'), + (0x2F22, 'M', u'夊'), + (0x2F23, 'M', u'夕'), + (0x2F24, 'M', u'大'), + (0x2F25, 'M', u'女'), + (0x2F26, 'M', u'子'), + (0x2F27, 'M', u'宀'), + (0x2F28, 'M', u'寸'), + (0x2F29, 'M', u'小'), + (0x2F2A, 'M', u'尢'), + (0x2F2B, 'M', u'尸'), + (0x2F2C, 'M', u'屮'), + (0x2F2D, 'M', u'山'), + ] + +def _seg_27(): + return [ + (0x2F2E, 'M', u'巛'), + (0x2F2F, 'M', u'工'), + (0x2F30, 'M', u'己'), + (0x2F31, 'M', u'巾'), + (0x2F32, 'M', u'干'), + (0x2F33, 'M', u'幺'), + (0x2F34, 'M', u'广'), + (0x2F35, 'M', u'廴'), + (0x2F36, 'M', u'廾'), + (0x2F37, 'M', u'弋'), + (0x2F38, 'M', u'弓'), + (0x2F39, 'M', u'彐'), + (0x2F3A, 'M', u'彡'), + (0x2F3B, 'M', u'彳'), + (0x2F3C, 'M', u'心'), + (0x2F3D, 'M', u'戈'), + (0x2F3E, 'M', u'戶'), + (0x2F3F, 'M', u'手'), + (0x2F40, 'M', u'支'), + (0x2F41, 'M', u'攴'), + (0x2F42, 'M', u'文'), + (0x2F43, 'M', u'斗'), + (0x2F44, 'M', u'斤'), + (0x2F45, 'M', u'方'), + (0x2F46, 'M', u'无'), + (0x2F47, 'M', u'日'), + (0x2F48, 'M', u'曰'), + (0x2F49, 'M', u'月'), + (0x2F4A, 'M', u'木'), + (0x2F4B, 'M', u'欠'), + (0x2F4C, 'M', u'止'), + (0x2F4D, 'M', u'歹'), + (0x2F4E, 'M', u'殳'), + (0x2F4F, 'M', u'毋'), + (0x2F50, 'M', u'比'), + (0x2F51, 'M', u'毛'), + (0x2F52, 'M', u'氏'), + (0x2F53, 'M', u'气'), + (0x2F54, 'M', u'水'), + (0x2F55, 'M', u'火'), + (0x2F56, 'M', u'爪'), + (0x2F57, 'M', u'父'), + (0x2F58, 'M', u'爻'), + (0x2F59, 'M', u'爿'), + (0x2F5A, 'M', u'片'), + (0x2F5B, 'M', u'牙'), + (0x2F5C, 'M', u'牛'), + (0x2F5D, 'M', u'犬'), + (0x2F5E, 'M', u'玄'), + (0x2F5F, 'M', u'玉'), + (0x2F60, 'M', u'瓜'), + (0x2F61, 'M', u'瓦'), + (0x2F62, 'M', u'甘'), + (0x2F63, 'M', u'生'), + (0x2F64, 'M', u'用'), + (0x2F65, 'M', u'田'), + (0x2F66, 'M', u'疋'), + (0x2F67, 'M', u'疒'), + (0x2F68, 'M', u'癶'), + (0x2F69, 'M', u'白'), + (0x2F6A, 'M', u'皮'), + (0x2F6B, 'M', u'皿'), + (0x2F6C, 'M', u'目'), + (0x2F6D, 'M', u'矛'), + (0x2F6E, 'M', u'矢'), + (0x2F6F, 'M', u'石'), + (0x2F70, 'M', u'示'), + (0x2F71, 'M', u'禸'), + (0x2F72, 'M', u'禾'), + (0x2F73, 'M', u'穴'), + (0x2F74, 'M', u'立'), + (0x2F75, 'M', u'竹'), + (0x2F76, 'M', u'米'), + (0x2F77, 'M', u'糸'), + (0x2F78, 'M', u'缶'), + (0x2F79, 'M', u'网'), + (0x2F7A, 'M', u'羊'), + (0x2F7B, 'M', u'羽'), + (0x2F7C, 'M', u'老'), + (0x2F7D, 'M', u'而'), + (0x2F7E, 'M', u'耒'), + (0x2F7F, 'M', u'耳'), + (0x2F80, 'M', u'聿'), + (0x2F81, 'M', u'肉'), + (0x2F82, 'M', u'臣'), + (0x2F83, 'M', u'自'), + (0x2F84, 'M', u'至'), + (0x2F85, 'M', u'臼'), + (0x2F86, 'M', u'舌'), + (0x2F87, 'M', u'舛'), + (0x2F88, 'M', u'舟'), + (0x2F89, 'M', u'艮'), + (0x2F8A, 'M', u'色'), + (0x2F8B, 'M', u'艸'), + (0x2F8C, 'M', u'虍'), + (0x2F8D, 'M', u'虫'), + (0x2F8E, 'M', u'血'), + (0x2F8F, 'M', u'行'), + (0x2F90, 'M', u'衣'), + (0x2F91, 'M', u'襾'), + ] + +def _seg_28(): + return [ + (0x2F92, 'M', u'見'), + (0x2F93, 'M', u'角'), + (0x2F94, 'M', u'言'), + (0x2F95, 'M', u'谷'), + (0x2F96, 'M', u'豆'), + (0x2F97, 'M', u'豕'), + (0x2F98, 'M', u'豸'), + (0x2F99, 'M', u'貝'), + (0x2F9A, 'M', u'赤'), + (0x2F9B, 'M', u'走'), + (0x2F9C, 'M', u'足'), + (0x2F9D, 'M', u'身'), + (0x2F9E, 'M', u'車'), + (0x2F9F, 'M', u'辛'), + (0x2FA0, 'M', u'辰'), + (0x2FA1, 'M', u'辵'), + (0x2FA2, 'M', u'邑'), + (0x2FA3, 'M', u'酉'), + (0x2FA4, 'M', u'釆'), + (0x2FA5, 'M', u'里'), + (0x2FA6, 'M', u'金'), + (0x2FA7, 'M', u'長'), + (0x2FA8, 'M', u'門'), + (0x2FA9, 'M', u'阜'), + (0x2FAA, 'M', u'隶'), + (0x2FAB, 'M', u'隹'), + (0x2FAC, 'M', u'雨'), + (0x2FAD, 'M', u'靑'), + (0x2FAE, 'M', u'非'), + (0x2FAF, 'M', u'面'), + (0x2FB0, 'M', u'革'), + (0x2FB1, 'M', u'韋'), + (0x2FB2, 'M', u'韭'), + (0x2FB3, 'M', u'音'), + (0x2FB4, 'M', u'頁'), + (0x2FB5, 'M', u'風'), + (0x2FB6, 'M', u'飛'), + (0x2FB7, 'M', u'食'), + (0x2FB8, 'M', u'首'), + (0x2FB9, 'M', u'香'), + (0x2FBA, 'M', u'馬'), + (0x2FBB, 'M', u'骨'), + (0x2FBC, 'M', u'高'), + (0x2FBD, 'M', u'髟'), + (0x2FBE, 'M', u'鬥'), + (0x2FBF, 'M', u'鬯'), + (0x2FC0, 'M', u'鬲'), + (0x2FC1, 'M', u'鬼'), + (0x2FC2, 'M', u'魚'), + (0x2FC3, 'M', u'鳥'), + (0x2FC4, 'M', u'鹵'), + (0x2FC5, 'M', u'鹿'), + (0x2FC6, 'M', u'麥'), + (0x2FC7, 'M', u'麻'), + (0x2FC8, 'M', u'黃'), + (0x2FC9, 'M', u'黍'), + (0x2FCA, 'M', u'黑'), + (0x2FCB, 'M', u'黹'), + (0x2FCC, 'M', u'黽'), + (0x2FCD, 'M', u'鼎'), + (0x2FCE, 'M', u'鼓'), + (0x2FCF, 'M', u'鼠'), + (0x2FD0, 'M', u'鼻'), + (0x2FD1, 'M', u'齊'), + (0x2FD2, 'M', u'齒'), + (0x2FD3, 'M', u'龍'), + (0x2FD4, 'M', u'龜'), + (0x2FD5, 'M', u'龠'), + (0x2FD6, 'X'), + (0x3000, '3', u' '), + (0x3001, 'V'), + (0x3002, 'M', u'.'), + (0x3003, 'V'), + (0x3036, 'M', u'〒'), + (0x3037, 'V'), + (0x3038, 'M', u'十'), + (0x3039, 'M', u'卄'), + (0x303A, 'M', u'卅'), + (0x303B, 'V'), + (0x3040, 'X'), + (0x3041, 'V'), + (0x3097, 'X'), + (0x3099, 'V'), + (0x309B, '3', u' ゙'), + (0x309C, '3', u' ゚'), + (0x309D, 'V'), + (0x309F, 'M', u'より'), + (0x30A0, 'V'), + (0x30FF, 'M', u'コト'), + (0x3100, 'X'), + (0x3105, 'V'), + (0x3130, 'X'), + (0x3131, 'M', u'ᄀ'), + (0x3132, 'M', u'ᄁ'), + (0x3133, 'M', u'ᆪ'), + (0x3134, 'M', u'ᄂ'), + (0x3135, 'M', u'ᆬ'), + (0x3136, 'M', u'ᆭ'), + (0x3137, 'M', u'ᄃ'), + (0x3138, 'M', u'ᄄ'), + ] + +def _seg_29(): + return [ + (0x3139, 'M', u'ᄅ'), + (0x313A, 'M', u'ᆰ'), + (0x313B, 'M', u'ᆱ'), + (0x313C, 'M', u'ᆲ'), + (0x313D, 'M', u'ᆳ'), + (0x313E, 'M', u'ᆴ'), + (0x313F, 'M', u'ᆵ'), + (0x3140, 'M', u'ᄚ'), + (0x3141, 'M', u'ᄆ'), + (0x3142, 'M', u'ᄇ'), + (0x3143, 'M', u'ᄈ'), + (0x3144, 'M', u'ᄡ'), + (0x3145, 'M', u'ᄉ'), + (0x3146, 'M', u'ᄊ'), + (0x3147, 'M', u'ᄋ'), + (0x3148, 'M', u'ᄌ'), + (0x3149, 'M', u'ᄍ'), + (0x314A, 'M', u'ᄎ'), + (0x314B, 'M', u'ᄏ'), + (0x314C, 'M', u'ᄐ'), + (0x314D, 'M', u'ᄑ'), + (0x314E, 'M', u'ᄒ'), + (0x314F, 'M', u'ᅡ'), + (0x3150, 'M', u'ᅢ'), + (0x3151, 'M', u'ᅣ'), + (0x3152, 'M', u'ᅤ'), + (0x3153, 'M', u'ᅥ'), + (0x3154, 'M', u'ᅦ'), + (0x3155, 'M', u'ᅧ'), + (0x3156, 'M', u'ᅨ'), + (0x3157, 'M', u'ᅩ'), + (0x3158, 'M', u'ᅪ'), + (0x3159, 'M', u'ᅫ'), + (0x315A, 'M', u'ᅬ'), + (0x315B, 'M', u'ᅭ'), + (0x315C, 'M', u'ᅮ'), + (0x315D, 'M', u'ᅯ'), + (0x315E, 'M', u'ᅰ'), + (0x315F, 'M', u'ᅱ'), + (0x3160, 'M', u'ᅲ'), + (0x3161, 'M', u'ᅳ'), + (0x3162, 'M', u'ᅴ'), + (0x3163, 'M', u'ᅵ'), + (0x3164, 'X'), + (0x3165, 'M', u'ᄔ'), + (0x3166, 'M', u'ᄕ'), + (0x3167, 'M', u'ᇇ'), + (0x3168, 'M', u'ᇈ'), + (0x3169, 'M', u'ᇌ'), + (0x316A, 'M', u'ᇎ'), + (0x316B, 'M', u'ᇓ'), + (0x316C, 'M', u'ᇗ'), + (0x316D, 'M', u'ᇙ'), + (0x316E, 'M', u'ᄜ'), + (0x316F, 'M', u'ᇝ'), + (0x3170, 'M', u'ᇟ'), + (0x3171, 'M', u'ᄝ'), + (0x3172, 'M', u'ᄞ'), + (0x3173, 'M', u'ᄠ'), + (0x3174, 'M', u'ᄢ'), + (0x3175, 'M', u'ᄣ'), + (0x3176, 'M', u'ᄧ'), + (0x3177, 'M', u'ᄩ'), + (0x3178, 'M', u'ᄫ'), + (0x3179, 'M', u'ᄬ'), + (0x317A, 'M', u'ᄭ'), + (0x317B, 'M', u'ᄮ'), + (0x317C, 'M', u'ᄯ'), + (0x317D, 'M', u'ᄲ'), + (0x317E, 'M', u'ᄶ'), + (0x317F, 'M', u'ᅀ'), + (0x3180, 'M', u'ᅇ'), + (0x3181, 'M', u'ᅌ'), + (0x3182, 'M', u'ᇱ'), + (0x3183, 'M', u'ᇲ'), + (0x3184, 'M', u'ᅗ'), + (0x3185, 'M', u'ᅘ'), + (0x3186, 'M', u'ᅙ'), + (0x3187, 'M', u'ᆄ'), + (0x3188, 'M', u'ᆅ'), + (0x3189, 'M', u'ᆈ'), + (0x318A, 'M', u'ᆑ'), + (0x318B, 'M', u'ᆒ'), + (0x318C, 'M', u'ᆔ'), + (0x318D, 'M', u'ᆞ'), + (0x318E, 'M', u'ᆡ'), + (0x318F, 'X'), + (0x3190, 'V'), + (0x3192, 'M', u'一'), + (0x3193, 'M', u'二'), + (0x3194, 'M', u'三'), + (0x3195, 'M', u'四'), + (0x3196, 'M', u'上'), + (0x3197, 'M', u'中'), + (0x3198, 'M', u'下'), + (0x3199, 'M', u'甲'), + (0x319A, 'M', u'乙'), + (0x319B, 'M', u'丙'), + (0x319C, 'M', u'丁'), + (0x319D, 'M', u'天'), + ] + +def _seg_30(): + return [ + (0x319E, 'M', u'地'), + (0x319F, 'M', u'人'), + (0x31A0, 'V'), + (0x31BB, 'X'), + (0x31C0, 'V'), + (0x31E4, 'X'), + (0x31F0, 'V'), + (0x3200, '3', u'(ᄀ)'), + (0x3201, '3', u'(ᄂ)'), + (0x3202, '3', u'(ᄃ)'), + (0x3203, '3', u'(ᄅ)'), + (0x3204, '3', u'(ᄆ)'), + (0x3205, '3', u'(ᄇ)'), + (0x3206, '3', u'(ᄉ)'), + (0x3207, '3', u'(ᄋ)'), + (0x3208, '3', u'(ᄌ)'), + (0x3209, '3', u'(ᄎ)'), + (0x320A, '3', u'(ᄏ)'), + (0x320B, '3', u'(ᄐ)'), + (0x320C, '3', u'(ᄑ)'), + (0x320D, '3', u'(ᄒ)'), + (0x320E, '3', u'(가)'), + (0x320F, '3', u'(나)'), + (0x3210, '3', u'(다)'), + (0x3211, '3', u'(라)'), + (0x3212, '3', u'(마)'), + (0x3213, '3', u'(바)'), + (0x3214, '3', u'(사)'), + (0x3215, '3', u'(아)'), + (0x3216, '3', u'(자)'), + (0x3217, '3', u'(차)'), + (0x3218, '3', u'(카)'), + (0x3219, '3', u'(타)'), + (0x321A, '3', u'(파)'), + (0x321B, '3', u'(하)'), + (0x321C, '3', u'(주)'), + (0x321D, '3', u'(오전)'), + (0x321E, '3', u'(오후)'), + (0x321F, 'X'), + (0x3220, '3', u'(一)'), + (0x3221, '3', u'(二)'), + (0x3222, '3', u'(三)'), + (0x3223, '3', u'(四)'), + (0x3224, '3', u'(五)'), + (0x3225, '3', u'(六)'), + (0x3226, '3', u'(七)'), + (0x3227, '3', u'(八)'), + (0x3228, '3', u'(九)'), + (0x3229, '3', u'(十)'), + (0x322A, '3', u'(月)'), + (0x322B, '3', u'(火)'), + (0x322C, '3', u'(水)'), + (0x322D, '3', u'(木)'), + (0x322E, '3', u'(金)'), + (0x322F, '3', u'(土)'), + (0x3230, '3', u'(日)'), + (0x3231, '3', u'(株)'), + (0x3232, '3', u'(有)'), + (0x3233, '3', u'(社)'), + (0x3234, '3', u'(名)'), + (0x3235, '3', u'(特)'), + (0x3236, '3', u'(財)'), + (0x3237, '3', u'(祝)'), + (0x3238, '3', u'(労)'), + (0x3239, '3', u'(代)'), + (0x323A, '3', u'(呼)'), + (0x323B, '3', u'(学)'), + (0x323C, '3', u'(監)'), + (0x323D, '3', u'(企)'), + (0x323E, '3', u'(資)'), + (0x323F, '3', u'(協)'), + (0x3240, '3', u'(祭)'), + (0x3241, '3', u'(休)'), + (0x3242, '3', u'(自)'), + (0x3243, '3', u'(至)'), + (0x3244, 'M', u'問'), + (0x3245, 'M', u'幼'), + (0x3246, 'M', u'文'), + (0x3247, 'M', u'箏'), + (0x3248, 'V'), + (0x3250, 'M', u'pte'), + (0x3251, 'M', u'21'), + (0x3252, 'M', u'22'), + (0x3253, 'M', u'23'), + (0x3254, 'M', u'24'), + (0x3255, 'M', u'25'), + (0x3256, 'M', u'26'), + (0x3257, 'M', u'27'), + (0x3258, 'M', u'28'), + (0x3259, 'M', u'29'), + (0x325A, 'M', u'30'), + (0x325B, 'M', u'31'), + (0x325C, 'M', u'32'), + (0x325D, 'M', u'33'), + (0x325E, 'M', u'34'), + (0x325F, 'M', u'35'), + (0x3260, 'M', u'ᄀ'), + (0x3261, 'M', u'ᄂ'), + (0x3262, 'M', u'ᄃ'), + (0x3263, 'M', u'ᄅ'), + ] + +def _seg_31(): + return [ + (0x3264, 'M', u'ᄆ'), + (0x3265, 'M', u'ᄇ'), + (0x3266, 'M', u'ᄉ'), + (0x3267, 'M', u'ᄋ'), + (0x3268, 'M', u'ᄌ'), + (0x3269, 'M', u'ᄎ'), + (0x326A, 'M', u'ᄏ'), + (0x326B, 'M', u'ᄐ'), + (0x326C, 'M', u'ᄑ'), + (0x326D, 'M', u'ᄒ'), + (0x326E, 'M', u'가'), + (0x326F, 'M', u'나'), + (0x3270, 'M', u'다'), + (0x3271, 'M', u'라'), + (0x3272, 'M', u'마'), + (0x3273, 'M', u'바'), + (0x3274, 'M', u'사'), + (0x3275, 'M', u'아'), + (0x3276, 'M', u'자'), + (0x3277, 'M', u'차'), + (0x3278, 'M', u'카'), + (0x3279, 'M', u'타'), + (0x327A, 'M', u'파'), + (0x327B, 'M', u'하'), + (0x327C, 'M', u'참고'), + (0x327D, 'M', u'주의'), + (0x327E, 'M', u'우'), + (0x327F, 'V'), + (0x3280, 'M', u'一'), + (0x3281, 'M', u'二'), + (0x3282, 'M', u'三'), + (0x3283, 'M', u'四'), + (0x3284, 'M', u'五'), + (0x3285, 'M', u'六'), + (0x3286, 'M', u'七'), + (0x3287, 'M', u'八'), + (0x3288, 'M', u'九'), + (0x3289, 'M', u'十'), + (0x328A, 'M', u'月'), + (0x328B, 'M', u'火'), + (0x328C, 'M', u'水'), + (0x328D, 'M', u'木'), + (0x328E, 'M', u'金'), + (0x328F, 'M', u'土'), + (0x3290, 'M', u'日'), + (0x3291, 'M', u'株'), + (0x3292, 'M', u'有'), + (0x3293, 'M', u'社'), + (0x3294, 'M', u'名'), + (0x3295, 'M', u'特'), + (0x3296, 'M', u'財'), + (0x3297, 'M', u'祝'), + (0x3298, 'M', u'労'), + (0x3299, 'M', u'秘'), + (0x329A, 'M', u'男'), + (0x329B, 'M', u'女'), + (0x329C, 'M', u'適'), + (0x329D, 'M', u'優'), + (0x329E, 'M', u'印'), + (0x329F, 'M', u'注'), + (0x32A0, 'M', u'項'), + (0x32A1, 'M', u'休'), + (0x32A2, 'M', u'写'), + (0x32A3, 'M', u'正'), + (0x32A4, 'M', u'上'), + (0x32A5, 'M', u'中'), + (0x32A6, 'M', u'下'), + (0x32A7, 'M', u'左'), + (0x32A8, 'M', u'右'), + (0x32A9, 'M', u'医'), + (0x32AA, 'M', u'宗'), + (0x32AB, 'M', u'学'), + (0x32AC, 'M', u'監'), + (0x32AD, 'M', u'企'), + (0x32AE, 'M', u'資'), + (0x32AF, 'M', u'協'), + (0x32B0, 'M', u'夜'), + (0x32B1, 'M', u'36'), + (0x32B2, 'M', u'37'), + (0x32B3, 'M', u'38'), + (0x32B4, 'M', u'39'), + (0x32B5, 'M', u'40'), + (0x32B6, 'M', u'41'), + (0x32B7, 'M', u'42'), + (0x32B8, 'M', u'43'), + (0x32B9, 'M', u'44'), + (0x32BA, 'M', u'45'), + (0x32BB, 'M', u'46'), + (0x32BC, 'M', u'47'), + (0x32BD, 'M', u'48'), + (0x32BE, 'M', u'49'), + (0x32BF, 'M', u'50'), + (0x32C0, 'M', u'1月'), + (0x32C1, 'M', u'2月'), + (0x32C2, 'M', u'3月'), + (0x32C3, 'M', u'4月'), + (0x32C4, 'M', u'5月'), + (0x32C5, 'M', u'6月'), + (0x32C6, 'M', u'7月'), + (0x32C7, 'M', u'8月'), + ] + +def _seg_32(): + return [ + (0x32C8, 'M', u'9月'), + (0x32C9, 'M', u'10月'), + (0x32CA, 'M', u'11月'), + (0x32CB, 'M', u'12月'), + (0x32CC, 'M', u'hg'), + (0x32CD, 'M', u'erg'), + (0x32CE, 'M', u'ev'), + (0x32CF, 'M', u'ltd'), + (0x32D0, 'M', u'ア'), + (0x32D1, 'M', u'イ'), + (0x32D2, 'M', u'ウ'), + (0x32D3, 'M', u'エ'), + (0x32D4, 'M', u'オ'), + (0x32D5, 'M', u'カ'), + (0x32D6, 'M', u'キ'), + (0x32D7, 'M', u'ク'), + (0x32D8, 'M', u'ケ'), + (0x32D9, 'M', u'コ'), + (0x32DA, 'M', u'サ'), + (0x32DB, 'M', u'シ'), + (0x32DC, 'M', u'ス'), + (0x32DD, 'M', u'セ'), + (0x32DE, 'M', u'ソ'), + (0x32DF, 'M', u'タ'), + (0x32E0, 'M', u'チ'), + (0x32E1, 'M', u'ツ'), + (0x32E2, 'M', u'テ'), + (0x32E3, 'M', u'ト'), + (0x32E4, 'M', u'ナ'), + (0x32E5, 'M', u'ニ'), + (0x32E6, 'M', u'ヌ'), + (0x32E7, 'M', u'ネ'), + (0x32E8, 'M', u'ノ'), + (0x32E9, 'M', u'ハ'), + (0x32EA, 'M', u'ヒ'), + (0x32EB, 'M', u'フ'), + (0x32EC, 'M', u'ヘ'), + (0x32ED, 'M', u'ホ'), + (0x32EE, 'M', u'マ'), + (0x32EF, 'M', u'ミ'), + (0x32F0, 'M', u'ム'), + (0x32F1, 'M', u'メ'), + (0x32F2, 'M', u'モ'), + (0x32F3, 'M', u'ヤ'), + (0x32F4, 'M', u'ユ'), + (0x32F5, 'M', u'ヨ'), + (0x32F6, 'M', u'ラ'), + (0x32F7, 'M', u'リ'), + (0x32F8, 'M', u'ル'), + (0x32F9, 'M', u'レ'), + (0x32FA, 'M', u'ロ'), + (0x32FB, 'M', u'ワ'), + (0x32FC, 'M', u'ヰ'), + (0x32FD, 'M', u'ヱ'), + (0x32FE, 'M', u'ヲ'), + (0x32FF, 'X'), + (0x3300, 'M', u'アパート'), + (0x3301, 'M', u'アルファ'), + (0x3302, 'M', u'アンペア'), + (0x3303, 'M', u'アール'), + (0x3304, 'M', u'イニング'), + (0x3305, 'M', u'インチ'), + (0x3306, 'M', u'ウォン'), + (0x3307, 'M', u'エスクード'), + (0x3308, 'M', u'エーカー'), + (0x3309, 'M', u'オンス'), + (0x330A, 'M', u'オーム'), + (0x330B, 'M', u'カイリ'), + (0x330C, 'M', u'カラット'), + (0x330D, 'M', u'カロリー'), + (0x330E, 'M', u'ガロン'), + (0x330F, 'M', u'ガンマ'), + (0x3310, 'M', u'ギガ'), + (0x3311, 'M', u'ギニー'), + (0x3312, 'M', u'キュリー'), + (0x3313, 'M', u'ギルダー'), + (0x3314, 'M', u'キロ'), + (0x3315, 'M', u'キログラム'), + (0x3316, 'M', u'キロメートル'), + (0x3317, 'M', u'キロワット'), + (0x3318, 'M', u'グラム'), + (0x3319, 'M', u'グラムトン'), + (0x331A, 'M', u'クルゼイロ'), + (0x331B, 'M', u'クローネ'), + (0x331C, 'M', u'ケース'), + (0x331D, 'M', u'コルナ'), + (0x331E, 'M', u'コーポ'), + (0x331F, 'M', u'サイクル'), + (0x3320, 'M', u'サンチーム'), + (0x3321, 'M', u'シリング'), + (0x3322, 'M', u'センチ'), + (0x3323, 'M', u'セント'), + (0x3324, 'M', u'ダース'), + (0x3325, 'M', u'デシ'), + (0x3326, 'M', u'ドル'), + (0x3327, 'M', u'トン'), + (0x3328, 'M', u'ナノ'), + (0x3329, 'M', u'ノット'), + (0x332A, 'M', u'ハイツ'), + (0x332B, 'M', u'パーセント'), + ] + +def _seg_33(): + return [ + (0x332C, 'M', u'パーツ'), + (0x332D, 'M', u'バーレル'), + (0x332E, 'M', u'ピアストル'), + (0x332F, 'M', u'ピクル'), + (0x3330, 'M', u'ピコ'), + (0x3331, 'M', u'ビル'), + (0x3332, 'M', u'ファラッド'), + (0x3333, 'M', u'フィート'), + (0x3334, 'M', u'ブッシェル'), + (0x3335, 'M', u'フラン'), + (0x3336, 'M', u'ヘクタール'), + (0x3337, 'M', u'ペソ'), + (0x3338, 'M', u'ペニヒ'), + (0x3339, 'M', u'ヘルツ'), + (0x333A, 'M', u'ペンス'), + (0x333B, 'M', u'ページ'), + (0x333C, 'M', u'ベータ'), + (0x333D, 'M', u'ポイント'), + (0x333E, 'M', u'ボルト'), + (0x333F, 'M', u'ホン'), + (0x3340, 'M', u'ポンド'), + (0x3341, 'M', u'ホール'), + (0x3342, 'M', u'ホーン'), + (0x3343, 'M', u'マイクロ'), + (0x3344, 'M', u'マイル'), + (0x3345, 'M', u'マッハ'), + (0x3346, 'M', u'マルク'), + (0x3347, 'M', u'マンション'), + (0x3348, 'M', u'ミクロン'), + (0x3349, 'M', u'ミリ'), + (0x334A, 'M', u'ミリバール'), + (0x334B, 'M', u'メガ'), + (0x334C, 'M', u'メガトン'), + (0x334D, 'M', u'メートル'), + (0x334E, 'M', u'ヤード'), + (0x334F, 'M', u'ヤール'), + (0x3350, 'M', u'ユアン'), + (0x3351, 'M', u'リットル'), + (0x3352, 'M', u'リラ'), + (0x3353, 'M', u'ルピー'), + (0x3354, 'M', u'ルーブル'), + (0x3355, 'M', u'レム'), + (0x3356, 'M', u'レントゲン'), + (0x3357, 'M', u'ワット'), + (0x3358, 'M', u'0点'), + (0x3359, 'M', u'1点'), + (0x335A, 'M', u'2点'), + (0x335B, 'M', u'3点'), + (0x335C, 'M', u'4点'), + (0x335D, 'M', u'5点'), + (0x335E, 'M', u'6点'), + (0x335F, 'M', u'7点'), + (0x3360, 'M', u'8点'), + (0x3361, 'M', u'9点'), + (0x3362, 'M', u'10点'), + (0x3363, 'M', u'11点'), + (0x3364, 'M', u'12点'), + (0x3365, 'M', u'13点'), + (0x3366, 'M', u'14点'), + (0x3367, 'M', u'15点'), + (0x3368, 'M', u'16点'), + (0x3369, 'M', u'17点'), + (0x336A, 'M', u'18点'), + (0x336B, 'M', u'19点'), + (0x336C, 'M', u'20点'), + (0x336D, 'M', u'21点'), + (0x336E, 'M', u'22点'), + (0x336F, 'M', u'23点'), + (0x3370, 'M', u'24点'), + (0x3371, 'M', u'hpa'), + (0x3372, 'M', u'da'), + (0x3373, 'M', u'au'), + (0x3374, 'M', u'bar'), + (0x3375, 'M', u'ov'), + (0x3376, 'M', u'pc'), + (0x3377, 'M', u'dm'), + (0x3378, 'M', u'dm2'), + (0x3379, 'M', u'dm3'), + (0x337A, 'M', u'iu'), + (0x337B, 'M', u'平成'), + (0x337C, 'M', u'昭和'), + (0x337D, 'M', u'大正'), + (0x337E, 'M', u'明治'), + (0x337F, 'M', u'株式会社'), + (0x3380, 'M', u'pa'), + (0x3381, 'M', u'na'), + (0x3382, 'M', u'μa'), + (0x3383, 'M', u'ma'), + (0x3384, 'M', u'ka'), + (0x3385, 'M', u'kb'), + (0x3386, 'M', u'mb'), + (0x3387, 'M', u'gb'), + (0x3388, 'M', u'cal'), + (0x3389, 'M', u'kcal'), + (0x338A, 'M', u'pf'), + (0x338B, 'M', u'nf'), + (0x338C, 'M', u'μf'), + (0x338D, 'M', u'μg'), + (0x338E, 'M', u'mg'), + (0x338F, 'M', u'kg'), + ] + +def _seg_34(): + return [ + (0x3390, 'M', u'hz'), + (0x3391, 'M', u'khz'), + (0x3392, 'M', u'mhz'), + (0x3393, 'M', u'ghz'), + (0x3394, 'M', u'thz'), + (0x3395, 'M', u'μl'), + (0x3396, 'M', u'ml'), + (0x3397, 'M', u'dl'), + (0x3398, 'M', u'kl'), + (0x3399, 'M', u'fm'), + (0x339A, 'M', u'nm'), + (0x339B, 'M', u'μm'), + (0x339C, 'M', u'mm'), + (0x339D, 'M', u'cm'), + (0x339E, 'M', u'km'), + (0x339F, 'M', u'mm2'), + (0x33A0, 'M', u'cm2'), + (0x33A1, 'M', u'm2'), + (0x33A2, 'M', u'km2'), + (0x33A3, 'M', u'mm3'), + (0x33A4, 'M', u'cm3'), + (0x33A5, 'M', u'm3'), + (0x33A6, 'M', u'km3'), + (0x33A7, 'M', u'm∕s'), + (0x33A8, 'M', u'm∕s2'), + (0x33A9, 'M', u'pa'), + (0x33AA, 'M', u'kpa'), + (0x33AB, 'M', u'mpa'), + (0x33AC, 'M', u'gpa'), + (0x33AD, 'M', u'rad'), + (0x33AE, 'M', u'rad∕s'), + (0x33AF, 'M', u'rad∕s2'), + (0x33B0, 'M', u'ps'), + (0x33B1, 'M', u'ns'), + (0x33B2, 'M', u'μs'), + (0x33B3, 'M', u'ms'), + (0x33B4, 'M', u'pv'), + (0x33B5, 'M', u'nv'), + (0x33B6, 'M', u'μv'), + (0x33B7, 'M', u'mv'), + (0x33B8, 'M', u'kv'), + (0x33B9, 'M', u'mv'), + (0x33BA, 'M', u'pw'), + (0x33BB, 'M', u'nw'), + (0x33BC, 'M', u'μw'), + (0x33BD, 'M', u'mw'), + (0x33BE, 'M', u'kw'), + (0x33BF, 'M', u'mw'), + (0x33C0, 'M', u'kω'), + (0x33C1, 'M', u'mω'), + (0x33C2, 'X'), + (0x33C3, 'M', u'bq'), + (0x33C4, 'M', u'cc'), + (0x33C5, 'M', u'cd'), + (0x33C6, 'M', u'c∕kg'), + (0x33C7, 'X'), + (0x33C8, 'M', u'db'), + (0x33C9, 'M', u'gy'), + (0x33CA, 'M', u'ha'), + (0x33CB, 'M', u'hp'), + (0x33CC, 'M', u'in'), + (0x33CD, 'M', u'kk'), + (0x33CE, 'M', u'km'), + (0x33CF, 'M', u'kt'), + (0x33D0, 'M', u'lm'), + (0x33D1, 'M', u'ln'), + (0x33D2, 'M', u'log'), + (0x33D3, 'M', u'lx'), + (0x33D4, 'M', u'mb'), + (0x33D5, 'M', u'mil'), + (0x33D6, 'M', u'mol'), + (0x33D7, 'M', u'ph'), + (0x33D8, 'X'), + (0x33D9, 'M', u'ppm'), + (0x33DA, 'M', u'pr'), + (0x33DB, 'M', u'sr'), + (0x33DC, 'M', u'sv'), + (0x33DD, 'M', u'wb'), + (0x33DE, 'M', u'v∕m'), + (0x33DF, 'M', u'a∕m'), + (0x33E0, 'M', u'1日'), + (0x33E1, 'M', u'2日'), + (0x33E2, 'M', u'3日'), + (0x33E3, 'M', u'4日'), + (0x33E4, 'M', u'5日'), + (0x33E5, 'M', u'6日'), + (0x33E6, 'M', u'7日'), + (0x33E7, 'M', u'8日'), + (0x33E8, 'M', u'9日'), + (0x33E9, 'M', u'10日'), + (0x33EA, 'M', u'11日'), + (0x33EB, 'M', u'12日'), + (0x33EC, 'M', u'13日'), + (0x33ED, 'M', u'14日'), + (0x33EE, 'M', u'15日'), + (0x33EF, 'M', u'16日'), + (0x33F0, 'M', u'17日'), + (0x33F1, 'M', u'18日'), + (0x33F2, 'M', u'19日'), + (0x33F3, 'M', u'20日'), + ] + +def _seg_35(): + return [ + (0x33F4, 'M', u'21日'), + (0x33F5, 'M', u'22日'), + (0x33F6, 'M', u'23日'), + (0x33F7, 'M', u'24日'), + (0x33F8, 'M', u'25日'), + (0x33F9, 'M', u'26日'), + (0x33FA, 'M', u'27日'), + (0x33FB, 'M', u'28日'), + (0x33FC, 'M', u'29日'), + (0x33FD, 'M', u'30日'), + (0x33FE, 'M', u'31日'), + (0x33FF, 'M', u'gal'), + (0x3400, 'V'), + (0x4DB6, 'X'), + (0x4DC0, 'V'), + (0x9FF0, 'X'), + (0xA000, 'V'), + (0xA48D, 'X'), + (0xA490, 'V'), + (0xA4C7, 'X'), + (0xA4D0, 'V'), + (0xA62C, 'X'), + (0xA640, 'M', u'ꙁ'), + (0xA641, 'V'), + (0xA642, 'M', u'ꙃ'), + (0xA643, 'V'), + (0xA644, 'M', u'ꙅ'), + (0xA645, 'V'), + (0xA646, 'M', u'ꙇ'), + (0xA647, 'V'), + (0xA648, 'M', u'ꙉ'), + (0xA649, 'V'), + (0xA64A, 'M', u'ꙋ'), + (0xA64B, 'V'), + (0xA64C, 'M', u'ꙍ'), + (0xA64D, 'V'), + (0xA64E, 'M', u'ꙏ'), + (0xA64F, 'V'), + (0xA650, 'M', u'ꙑ'), + (0xA651, 'V'), + (0xA652, 'M', u'ꙓ'), + (0xA653, 'V'), + (0xA654, 'M', u'ꙕ'), + (0xA655, 'V'), + (0xA656, 'M', u'ꙗ'), + (0xA657, 'V'), + (0xA658, 'M', u'ꙙ'), + (0xA659, 'V'), + (0xA65A, 'M', u'ꙛ'), + (0xA65B, 'V'), + (0xA65C, 'M', u'ꙝ'), + (0xA65D, 'V'), + (0xA65E, 'M', u'ꙟ'), + (0xA65F, 'V'), + (0xA660, 'M', u'ꙡ'), + (0xA661, 'V'), + (0xA662, 'M', u'ꙣ'), + (0xA663, 'V'), + (0xA664, 'M', u'ꙥ'), + (0xA665, 'V'), + (0xA666, 'M', u'ꙧ'), + (0xA667, 'V'), + (0xA668, 'M', u'ꙩ'), + (0xA669, 'V'), + (0xA66A, 'M', u'ꙫ'), + (0xA66B, 'V'), + (0xA66C, 'M', u'ꙭ'), + (0xA66D, 'V'), + (0xA680, 'M', u'ꚁ'), + (0xA681, 'V'), + (0xA682, 'M', u'ꚃ'), + (0xA683, 'V'), + (0xA684, 'M', u'ꚅ'), + (0xA685, 'V'), + (0xA686, 'M', u'ꚇ'), + (0xA687, 'V'), + (0xA688, 'M', u'ꚉ'), + (0xA689, 'V'), + (0xA68A, 'M', u'ꚋ'), + (0xA68B, 'V'), + (0xA68C, 'M', u'ꚍ'), + (0xA68D, 'V'), + (0xA68E, 'M', u'ꚏ'), + (0xA68F, 'V'), + (0xA690, 'M', u'ꚑ'), + (0xA691, 'V'), + (0xA692, 'M', u'ꚓ'), + (0xA693, 'V'), + (0xA694, 'M', u'ꚕ'), + (0xA695, 'V'), + (0xA696, 'M', u'ꚗ'), + (0xA697, 'V'), + (0xA698, 'M', u'ꚙ'), + (0xA699, 'V'), + (0xA69A, 'M', u'ꚛ'), + (0xA69B, 'V'), + (0xA69C, 'M', u'ъ'), + (0xA69D, 'M', u'ь'), + (0xA69E, 'V'), + (0xA6F8, 'X'), + ] + +def _seg_36(): + return [ + (0xA700, 'V'), + (0xA722, 'M', u'ꜣ'), + (0xA723, 'V'), + (0xA724, 'M', u'ꜥ'), + (0xA725, 'V'), + (0xA726, 'M', u'ꜧ'), + (0xA727, 'V'), + (0xA728, 'M', u'ꜩ'), + (0xA729, 'V'), + (0xA72A, 'M', u'ꜫ'), + (0xA72B, 'V'), + (0xA72C, 'M', u'ꜭ'), + (0xA72D, 'V'), + (0xA72E, 'M', u'ꜯ'), + (0xA72F, 'V'), + (0xA732, 'M', u'ꜳ'), + (0xA733, 'V'), + (0xA734, 'M', u'ꜵ'), + (0xA735, 'V'), + (0xA736, 'M', u'ꜷ'), + (0xA737, 'V'), + (0xA738, 'M', u'ꜹ'), + (0xA739, 'V'), + (0xA73A, 'M', u'ꜻ'), + (0xA73B, 'V'), + (0xA73C, 'M', u'ꜽ'), + (0xA73D, 'V'), + (0xA73E, 'M', u'ꜿ'), + (0xA73F, 'V'), + (0xA740, 'M', u'ꝁ'), + (0xA741, 'V'), + (0xA742, 'M', u'ꝃ'), + (0xA743, 'V'), + (0xA744, 'M', u'ꝅ'), + (0xA745, 'V'), + (0xA746, 'M', u'ꝇ'), + (0xA747, 'V'), + (0xA748, 'M', u'ꝉ'), + (0xA749, 'V'), + (0xA74A, 'M', u'ꝋ'), + (0xA74B, 'V'), + (0xA74C, 'M', u'ꝍ'), + (0xA74D, 'V'), + (0xA74E, 'M', u'ꝏ'), + (0xA74F, 'V'), + (0xA750, 'M', u'ꝑ'), + (0xA751, 'V'), + (0xA752, 'M', u'ꝓ'), + (0xA753, 'V'), + (0xA754, 'M', u'ꝕ'), + (0xA755, 'V'), + (0xA756, 'M', u'ꝗ'), + (0xA757, 'V'), + (0xA758, 'M', u'ꝙ'), + (0xA759, 'V'), + (0xA75A, 'M', u'ꝛ'), + (0xA75B, 'V'), + (0xA75C, 'M', u'ꝝ'), + (0xA75D, 'V'), + (0xA75E, 'M', u'ꝟ'), + (0xA75F, 'V'), + (0xA760, 'M', u'ꝡ'), + (0xA761, 'V'), + (0xA762, 'M', u'ꝣ'), + (0xA763, 'V'), + (0xA764, 'M', u'ꝥ'), + (0xA765, 'V'), + (0xA766, 'M', u'ꝧ'), + (0xA767, 'V'), + (0xA768, 'M', u'ꝩ'), + (0xA769, 'V'), + (0xA76A, 'M', u'ꝫ'), + (0xA76B, 'V'), + (0xA76C, 'M', u'ꝭ'), + (0xA76D, 'V'), + (0xA76E, 'M', u'ꝯ'), + (0xA76F, 'V'), + (0xA770, 'M', u'ꝯ'), + (0xA771, 'V'), + (0xA779, 'M', u'ꝺ'), + (0xA77A, 'V'), + (0xA77B, 'M', u'ꝼ'), + (0xA77C, 'V'), + (0xA77D, 'M', u'ᵹ'), + (0xA77E, 'M', u'ꝿ'), + (0xA77F, 'V'), + (0xA780, 'M', u'ꞁ'), + (0xA781, 'V'), + (0xA782, 'M', u'ꞃ'), + (0xA783, 'V'), + (0xA784, 'M', u'ꞅ'), + (0xA785, 'V'), + (0xA786, 'M', u'ꞇ'), + (0xA787, 'V'), + (0xA78B, 'M', u'ꞌ'), + (0xA78C, 'V'), + (0xA78D, 'M', u'ɥ'), + (0xA78E, 'V'), + (0xA790, 'M', u'ꞑ'), + (0xA791, 'V'), + ] + +def _seg_37(): + return [ + (0xA792, 'M', u'ꞓ'), + (0xA793, 'V'), + (0xA796, 'M', u'ꞗ'), + (0xA797, 'V'), + (0xA798, 'M', u'ꞙ'), + (0xA799, 'V'), + (0xA79A, 'M', u'ꞛ'), + (0xA79B, 'V'), + (0xA79C, 'M', u'ꞝ'), + (0xA79D, 'V'), + (0xA79E, 'M', u'ꞟ'), + (0xA79F, 'V'), + (0xA7A0, 'M', u'ꞡ'), + (0xA7A1, 'V'), + (0xA7A2, 'M', u'ꞣ'), + (0xA7A3, 'V'), + (0xA7A4, 'M', u'ꞥ'), + (0xA7A5, 'V'), + (0xA7A6, 'M', u'ꞧ'), + (0xA7A7, 'V'), + (0xA7A8, 'M', u'ꞩ'), + (0xA7A9, 'V'), + (0xA7AA, 'M', u'ɦ'), + (0xA7AB, 'M', u'ɜ'), + (0xA7AC, 'M', u'ɡ'), + (0xA7AD, 'M', u'ɬ'), + (0xA7AE, 'M', u'ɪ'), + (0xA7AF, 'V'), + (0xA7B0, 'M', u'ʞ'), + (0xA7B1, 'M', u'ʇ'), + (0xA7B2, 'M', u'ʝ'), + (0xA7B3, 'M', u'ꭓ'), + (0xA7B4, 'M', u'ꞵ'), + (0xA7B5, 'V'), + (0xA7B6, 'M', u'ꞷ'), + (0xA7B7, 'V'), + (0xA7B8, 'X'), + (0xA7B9, 'V'), + (0xA7BA, 'X'), + (0xA7F7, 'V'), + (0xA7F8, 'M', u'ħ'), + (0xA7F9, 'M', u'œ'), + (0xA7FA, 'V'), + (0xA82C, 'X'), + (0xA830, 'V'), + (0xA83A, 'X'), + (0xA840, 'V'), + (0xA878, 'X'), + (0xA880, 'V'), + (0xA8C6, 'X'), + (0xA8CE, 'V'), + (0xA8DA, 'X'), + (0xA8E0, 'V'), + (0xA954, 'X'), + (0xA95F, 'V'), + (0xA97D, 'X'), + (0xA980, 'V'), + (0xA9CE, 'X'), + (0xA9CF, 'V'), + (0xA9DA, 'X'), + (0xA9DE, 'V'), + (0xA9FF, 'X'), + (0xAA00, 'V'), + (0xAA37, 'X'), + (0xAA40, 'V'), + (0xAA4E, 'X'), + (0xAA50, 'V'), + (0xAA5A, 'X'), + (0xAA5C, 'V'), + (0xAAC3, 'X'), + (0xAADB, 'V'), + (0xAAF7, 'X'), + (0xAB01, 'V'), + (0xAB07, 'X'), + (0xAB09, 'V'), + (0xAB0F, 'X'), + (0xAB11, 'V'), + (0xAB17, 'X'), + (0xAB20, 'V'), + (0xAB27, 'X'), + (0xAB28, 'V'), + (0xAB2F, 'X'), + (0xAB30, 'V'), + (0xAB5C, 'M', u'ꜧ'), + (0xAB5D, 'M', u'ꬷ'), + (0xAB5E, 'M', u'ɫ'), + (0xAB5F, 'M', u'ꭒ'), + (0xAB60, 'V'), + (0xAB66, 'X'), + (0xAB70, 'M', u'Ꭰ'), + (0xAB71, 'M', u'Ꭱ'), + (0xAB72, 'M', u'Ꭲ'), + (0xAB73, 'M', u'Ꭳ'), + (0xAB74, 'M', u'Ꭴ'), + (0xAB75, 'M', u'Ꭵ'), + (0xAB76, 'M', u'Ꭶ'), + (0xAB77, 'M', u'Ꭷ'), + (0xAB78, 'M', u'Ꭸ'), + (0xAB79, 'M', u'Ꭹ'), + (0xAB7A, 'M', u'Ꭺ'), + ] + +def _seg_38(): + return [ + (0xAB7B, 'M', u'Ꭻ'), + (0xAB7C, 'M', u'Ꭼ'), + (0xAB7D, 'M', u'Ꭽ'), + (0xAB7E, 'M', u'Ꭾ'), + (0xAB7F, 'M', u'Ꭿ'), + (0xAB80, 'M', u'Ꮀ'), + (0xAB81, 'M', u'Ꮁ'), + (0xAB82, 'M', u'Ꮂ'), + (0xAB83, 'M', u'Ꮃ'), + (0xAB84, 'M', u'Ꮄ'), + (0xAB85, 'M', u'Ꮅ'), + (0xAB86, 'M', u'Ꮆ'), + (0xAB87, 'M', u'Ꮇ'), + (0xAB88, 'M', u'Ꮈ'), + (0xAB89, 'M', u'Ꮉ'), + (0xAB8A, 'M', u'Ꮊ'), + (0xAB8B, 'M', u'Ꮋ'), + (0xAB8C, 'M', u'Ꮌ'), + (0xAB8D, 'M', u'Ꮍ'), + (0xAB8E, 'M', u'Ꮎ'), + (0xAB8F, 'M', u'Ꮏ'), + (0xAB90, 'M', u'Ꮐ'), + (0xAB91, 'M', u'Ꮑ'), + (0xAB92, 'M', u'Ꮒ'), + (0xAB93, 'M', u'Ꮓ'), + (0xAB94, 'M', u'Ꮔ'), + (0xAB95, 'M', u'Ꮕ'), + (0xAB96, 'M', u'Ꮖ'), + (0xAB97, 'M', u'Ꮗ'), + (0xAB98, 'M', u'Ꮘ'), + (0xAB99, 'M', u'Ꮙ'), + (0xAB9A, 'M', u'Ꮚ'), + (0xAB9B, 'M', u'Ꮛ'), + (0xAB9C, 'M', u'Ꮜ'), + (0xAB9D, 'M', u'Ꮝ'), + (0xAB9E, 'M', u'Ꮞ'), + (0xAB9F, 'M', u'Ꮟ'), + (0xABA0, 'M', u'Ꮠ'), + (0xABA1, 'M', u'Ꮡ'), + (0xABA2, 'M', u'Ꮢ'), + (0xABA3, 'M', u'Ꮣ'), + (0xABA4, 'M', u'Ꮤ'), + (0xABA5, 'M', u'Ꮥ'), + (0xABA6, 'M', u'Ꮦ'), + (0xABA7, 'M', u'Ꮧ'), + (0xABA8, 'M', u'Ꮨ'), + (0xABA9, 'M', u'Ꮩ'), + (0xABAA, 'M', u'Ꮪ'), + (0xABAB, 'M', u'Ꮫ'), + (0xABAC, 'M', u'Ꮬ'), + (0xABAD, 'M', u'Ꮭ'), + (0xABAE, 'M', u'Ꮮ'), + (0xABAF, 'M', u'Ꮯ'), + (0xABB0, 'M', u'Ꮰ'), + (0xABB1, 'M', u'Ꮱ'), + (0xABB2, 'M', u'Ꮲ'), + (0xABB3, 'M', u'Ꮳ'), + (0xABB4, 'M', u'Ꮴ'), + (0xABB5, 'M', u'Ꮵ'), + (0xABB6, 'M', u'Ꮶ'), + (0xABB7, 'M', u'Ꮷ'), + (0xABB8, 'M', u'Ꮸ'), + (0xABB9, 'M', u'Ꮹ'), + (0xABBA, 'M', u'Ꮺ'), + (0xABBB, 'M', u'Ꮻ'), + (0xABBC, 'M', u'Ꮼ'), + (0xABBD, 'M', u'Ꮽ'), + (0xABBE, 'M', u'Ꮾ'), + (0xABBF, 'M', u'Ꮿ'), + (0xABC0, 'V'), + (0xABEE, 'X'), + (0xABF0, 'V'), + (0xABFA, 'X'), + (0xAC00, 'V'), + (0xD7A4, 'X'), + (0xD7B0, 'V'), + (0xD7C7, 'X'), + (0xD7CB, 'V'), + (0xD7FC, 'X'), + (0xF900, 'M', u'豈'), + (0xF901, 'M', u'更'), + (0xF902, 'M', u'車'), + (0xF903, 'M', u'賈'), + (0xF904, 'M', u'滑'), + (0xF905, 'M', u'串'), + (0xF906, 'M', u'句'), + (0xF907, 'M', u'龜'), + (0xF909, 'M', u'契'), + (0xF90A, 'M', u'金'), + (0xF90B, 'M', u'喇'), + (0xF90C, 'M', u'奈'), + (0xF90D, 'M', u'懶'), + (0xF90E, 'M', u'癩'), + (0xF90F, 'M', u'羅'), + (0xF910, 'M', u'蘿'), + (0xF911, 'M', u'螺'), + (0xF912, 'M', u'裸'), + (0xF913, 'M', u'邏'), + (0xF914, 'M', u'樂'), + (0xF915, 'M', u'洛'), + ] + +def _seg_39(): + return [ + (0xF916, 'M', u'烙'), + (0xF917, 'M', u'珞'), + (0xF918, 'M', u'落'), + (0xF919, 'M', u'酪'), + (0xF91A, 'M', u'駱'), + (0xF91B, 'M', u'亂'), + (0xF91C, 'M', u'卵'), + (0xF91D, 'M', u'欄'), + (0xF91E, 'M', u'爛'), + (0xF91F, 'M', u'蘭'), + (0xF920, 'M', u'鸞'), + (0xF921, 'M', u'嵐'), + (0xF922, 'M', u'濫'), + (0xF923, 'M', u'藍'), + (0xF924, 'M', u'襤'), + (0xF925, 'M', u'拉'), + (0xF926, 'M', u'臘'), + (0xF927, 'M', u'蠟'), + (0xF928, 'M', u'廊'), + (0xF929, 'M', u'朗'), + (0xF92A, 'M', u'浪'), + (0xF92B, 'M', u'狼'), + (0xF92C, 'M', u'郎'), + (0xF92D, 'M', u'來'), + (0xF92E, 'M', u'冷'), + (0xF92F, 'M', u'勞'), + (0xF930, 'M', u'擄'), + (0xF931, 'M', u'櫓'), + (0xF932, 'M', u'爐'), + (0xF933, 'M', u'盧'), + (0xF934, 'M', u'老'), + (0xF935, 'M', u'蘆'), + (0xF936, 'M', u'虜'), + (0xF937, 'M', u'路'), + (0xF938, 'M', u'露'), + (0xF939, 'M', u'魯'), + (0xF93A, 'M', u'鷺'), + (0xF93B, 'M', u'碌'), + (0xF93C, 'M', u'祿'), + (0xF93D, 'M', u'綠'), + (0xF93E, 'M', u'菉'), + (0xF93F, 'M', u'錄'), + (0xF940, 'M', u'鹿'), + (0xF941, 'M', u'論'), + (0xF942, 'M', u'壟'), + (0xF943, 'M', u'弄'), + (0xF944, 'M', u'籠'), + (0xF945, 'M', u'聾'), + (0xF946, 'M', u'牢'), + (0xF947, 'M', u'磊'), + (0xF948, 'M', u'賂'), + (0xF949, 'M', u'雷'), + (0xF94A, 'M', u'壘'), + (0xF94B, 'M', u'屢'), + (0xF94C, 'M', u'樓'), + (0xF94D, 'M', u'淚'), + (0xF94E, 'M', u'漏'), + (0xF94F, 'M', u'累'), + (0xF950, 'M', u'縷'), + (0xF951, 'M', u'陋'), + (0xF952, 'M', u'勒'), + (0xF953, 'M', u'肋'), + (0xF954, 'M', u'凜'), + (0xF955, 'M', u'凌'), + (0xF956, 'M', u'稜'), + (0xF957, 'M', u'綾'), + (0xF958, 'M', u'菱'), + (0xF959, 'M', u'陵'), + (0xF95A, 'M', u'讀'), + (0xF95B, 'M', u'拏'), + (0xF95C, 'M', u'樂'), + (0xF95D, 'M', u'諾'), + (0xF95E, 'M', u'丹'), + (0xF95F, 'M', u'寧'), + (0xF960, 'M', u'怒'), + (0xF961, 'M', u'率'), + (0xF962, 'M', u'異'), + (0xF963, 'M', u'北'), + (0xF964, 'M', u'磻'), + (0xF965, 'M', u'便'), + (0xF966, 'M', u'復'), + (0xF967, 'M', u'不'), + (0xF968, 'M', u'泌'), + (0xF969, 'M', u'數'), + (0xF96A, 'M', u'索'), + (0xF96B, 'M', u'參'), + (0xF96C, 'M', u'塞'), + (0xF96D, 'M', u'省'), + (0xF96E, 'M', u'葉'), + (0xF96F, 'M', u'說'), + (0xF970, 'M', u'殺'), + (0xF971, 'M', u'辰'), + (0xF972, 'M', u'沈'), + (0xF973, 'M', u'拾'), + (0xF974, 'M', u'若'), + (0xF975, 'M', u'掠'), + (0xF976, 'M', u'略'), + (0xF977, 'M', u'亮'), + (0xF978, 'M', u'兩'), + (0xF979, 'M', u'凉'), + ] + +def _seg_40(): + return [ + (0xF97A, 'M', u'梁'), + (0xF97B, 'M', u'糧'), + (0xF97C, 'M', u'良'), + (0xF97D, 'M', u'諒'), + (0xF97E, 'M', u'量'), + (0xF97F, 'M', u'勵'), + (0xF980, 'M', u'呂'), + (0xF981, 'M', u'女'), + (0xF982, 'M', u'廬'), + (0xF983, 'M', u'旅'), + (0xF984, 'M', u'濾'), + (0xF985, 'M', u'礪'), + (0xF986, 'M', u'閭'), + (0xF987, 'M', u'驪'), + (0xF988, 'M', u'麗'), + (0xF989, 'M', u'黎'), + (0xF98A, 'M', u'力'), + (0xF98B, 'M', u'曆'), + (0xF98C, 'M', u'歷'), + (0xF98D, 'M', u'轢'), + (0xF98E, 'M', u'年'), + (0xF98F, 'M', u'憐'), + (0xF990, 'M', u'戀'), + (0xF991, 'M', u'撚'), + (0xF992, 'M', u'漣'), + (0xF993, 'M', u'煉'), + (0xF994, 'M', u'璉'), + (0xF995, 'M', u'秊'), + (0xF996, 'M', u'練'), + (0xF997, 'M', u'聯'), + (0xF998, 'M', u'輦'), + (0xF999, 'M', u'蓮'), + (0xF99A, 'M', u'連'), + (0xF99B, 'M', u'鍊'), + (0xF99C, 'M', u'列'), + (0xF99D, 'M', u'劣'), + (0xF99E, 'M', u'咽'), + (0xF99F, 'M', u'烈'), + (0xF9A0, 'M', u'裂'), + (0xF9A1, 'M', u'說'), + (0xF9A2, 'M', u'廉'), + (0xF9A3, 'M', u'念'), + (0xF9A4, 'M', u'捻'), + (0xF9A5, 'M', u'殮'), + (0xF9A6, 'M', u'簾'), + (0xF9A7, 'M', u'獵'), + (0xF9A8, 'M', u'令'), + (0xF9A9, 'M', u'囹'), + (0xF9AA, 'M', u'寧'), + (0xF9AB, 'M', u'嶺'), + (0xF9AC, 'M', u'怜'), + (0xF9AD, 'M', u'玲'), + (0xF9AE, 'M', u'瑩'), + (0xF9AF, 'M', u'羚'), + (0xF9B0, 'M', u'聆'), + (0xF9B1, 'M', u'鈴'), + (0xF9B2, 'M', u'零'), + (0xF9B3, 'M', u'靈'), + (0xF9B4, 'M', u'領'), + (0xF9B5, 'M', u'例'), + (0xF9B6, 'M', u'禮'), + (0xF9B7, 'M', u'醴'), + (0xF9B8, 'M', u'隸'), + (0xF9B9, 'M', u'惡'), + (0xF9BA, 'M', u'了'), + (0xF9BB, 'M', u'僚'), + (0xF9BC, 'M', u'寮'), + (0xF9BD, 'M', u'尿'), + (0xF9BE, 'M', u'料'), + (0xF9BF, 'M', u'樂'), + (0xF9C0, 'M', u'燎'), + (0xF9C1, 'M', u'療'), + (0xF9C2, 'M', u'蓼'), + (0xF9C3, 'M', u'遼'), + (0xF9C4, 'M', u'龍'), + (0xF9C5, 'M', u'暈'), + (0xF9C6, 'M', u'阮'), + (0xF9C7, 'M', u'劉'), + (0xF9C8, 'M', u'杻'), + (0xF9C9, 'M', u'柳'), + (0xF9CA, 'M', u'流'), + (0xF9CB, 'M', u'溜'), + (0xF9CC, 'M', u'琉'), + (0xF9CD, 'M', u'留'), + (0xF9CE, 'M', u'硫'), + (0xF9CF, 'M', u'紐'), + (0xF9D0, 'M', u'類'), + (0xF9D1, 'M', u'六'), + (0xF9D2, 'M', u'戮'), + (0xF9D3, 'M', u'陸'), + (0xF9D4, 'M', u'倫'), + (0xF9D5, 'M', u'崙'), + (0xF9D6, 'M', u'淪'), + (0xF9D7, 'M', u'輪'), + (0xF9D8, 'M', u'律'), + (0xF9D9, 'M', u'慄'), + (0xF9DA, 'M', u'栗'), + (0xF9DB, 'M', u'率'), + (0xF9DC, 'M', u'隆'), + (0xF9DD, 'M', u'利'), + ] + +def _seg_41(): + return [ + (0xF9DE, 'M', u'吏'), + (0xF9DF, 'M', u'履'), + (0xF9E0, 'M', u'易'), + (0xF9E1, 'M', u'李'), + (0xF9E2, 'M', u'梨'), + (0xF9E3, 'M', u'泥'), + (0xF9E4, 'M', u'理'), + (0xF9E5, 'M', u'痢'), + (0xF9E6, 'M', u'罹'), + (0xF9E7, 'M', u'裏'), + (0xF9E8, 'M', u'裡'), + (0xF9E9, 'M', u'里'), + (0xF9EA, 'M', u'離'), + (0xF9EB, 'M', u'匿'), + (0xF9EC, 'M', u'溺'), + (0xF9ED, 'M', u'吝'), + (0xF9EE, 'M', u'燐'), + (0xF9EF, 'M', u'璘'), + (0xF9F0, 'M', u'藺'), + (0xF9F1, 'M', u'隣'), + (0xF9F2, 'M', u'鱗'), + (0xF9F3, 'M', u'麟'), + (0xF9F4, 'M', u'林'), + (0xF9F5, 'M', u'淋'), + (0xF9F6, 'M', u'臨'), + (0xF9F7, 'M', u'立'), + (0xF9F8, 'M', u'笠'), + (0xF9F9, 'M', u'粒'), + (0xF9FA, 'M', u'狀'), + (0xF9FB, 'M', u'炙'), + (0xF9FC, 'M', u'識'), + (0xF9FD, 'M', u'什'), + (0xF9FE, 'M', u'茶'), + (0xF9FF, 'M', u'刺'), + (0xFA00, 'M', u'切'), + (0xFA01, 'M', u'度'), + (0xFA02, 'M', u'拓'), + (0xFA03, 'M', u'糖'), + (0xFA04, 'M', u'宅'), + (0xFA05, 'M', u'洞'), + (0xFA06, 'M', u'暴'), + (0xFA07, 'M', u'輻'), + (0xFA08, 'M', u'行'), + (0xFA09, 'M', u'降'), + (0xFA0A, 'M', u'見'), + (0xFA0B, 'M', u'廓'), + (0xFA0C, 'M', u'兀'), + (0xFA0D, 'M', u'嗀'), + (0xFA0E, 'V'), + (0xFA10, 'M', u'塚'), + (0xFA11, 'V'), + (0xFA12, 'M', u'晴'), + (0xFA13, 'V'), + (0xFA15, 'M', u'凞'), + (0xFA16, 'M', u'猪'), + (0xFA17, 'M', u'益'), + (0xFA18, 'M', u'礼'), + (0xFA19, 'M', u'神'), + (0xFA1A, 'M', u'祥'), + (0xFA1B, 'M', u'福'), + (0xFA1C, 'M', u'靖'), + (0xFA1D, 'M', u'精'), + (0xFA1E, 'M', u'羽'), + (0xFA1F, 'V'), + (0xFA20, 'M', u'蘒'), + (0xFA21, 'V'), + (0xFA22, 'M', u'諸'), + (0xFA23, 'V'), + (0xFA25, 'M', u'逸'), + (0xFA26, 'M', u'都'), + (0xFA27, 'V'), + (0xFA2A, 'M', u'飯'), + (0xFA2B, 'M', u'飼'), + (0xFA2C, 'M', u'館'), + (0xFA2D, 'M', u'鶴'), + (0xFA2E, 'M', u'郞'), + (0xFA2F, 'M', u'隷'), + (0xFA30, 'M', u'侮'), + (0xFA31, 'M', u'僧'), + (0xFA32, 'M', u'免'), + (0xFA33, 'M', u'勉'), + (0xFA34, 'M', u'勤'), + (0xFA35, 'M', u'卑'), + (0xFA36, 'M', u'喝'), + (0xFA37, 'M', u'嘆'), + (0xFA38, 'M', u'器'), + (0xFA39, 'M', u'塀'), + (0xFA3A, 'M', u'墨'), + (0xFA3B, 'M', u'層'), + (0xFA3C, 'M', u'屮'), + (0xFA3D, 'M', u'悔'), + (0xFA3E, 'M', u'慨'), + (0xFA3F, 'M', u'憎'), + (0xFA40, 'M', u'懲'), + (0xFA41, 'M', u'敏'), + (0xFA42, 'M', u'既'), + (0xFA43, 'M', u'暑'), + (0xFA44, 'M', u'梅'), + (0xFA45, 'M', u'海'), + (0xFA46, 'M', u'渚'), + ] + +def _seg_42(): + return [ + (0xFA47, 'M', u'漢'), + (0xFA48, 'M', u'煮'), + (0xFA49, 'M', u'爫'), + (0xFA4A, 'M', u'琢'), + (0xFA4B, 'M', u'碑'), + (0xFA4C, 'M', u'社'), + (0xFA4D, 'M', u'祉'), + (0xFA4E, 'M', u'祈'), + (0xFA4F, 'M', u'祐'), + (0xFA50, 'M', u'祖'), + (0xFA51, 'M', u'祝'), + (0xFA52, 'M', u'禍'), + (0xFA53, 'M', u'禎'), + (0xFA54, 'M', u'穀'), + (0xFA55, 'M', u'突'), + (0xFA56, 'M', u'節'), + (0xFA57, 'M', u'練'), + (0xFA58, 'M', u'縉'), + (0xFA59, 'M', u'繁'), + (0xFA5A, 'M', u'署'), + (0xFA5B, 'M', u'者'), + (0xFA5C, 'M', u'臭'), + (0xFA5D, 'M', u'艹'), + (0xFA5F, 'M', u'著'), + (0xFA60, 'M', u'褐'), + (0xFA61, 'M', u'視'), + (0xFA62, 'M', u'謁'), + (0xFA63, 'M', u'謹'), + (0xFA64, 'M', u'賓'), + (0xFA65, 'M', u'贈'), + (0xFA66, 'M', u'辶'), + (0xFA67, 'M', u'逸'), + (0xFA68, 'M', u'難'), + (0xFA69, 'M', u'響'), + (0xFA6A, 'M', u'頻'), + (0xFA6B, 'M', u'恵'), + (0xFA6C, 'M', u'𤋮'), + (0xFA6D, 'M', u'舘'), + (0xFA6E, 'X'), + (0xFA70, 'M', u'並'), + (0xFA71, 'M', u'况'), + (0xFA72, 'M', u'全'), + (0xFA73, 'M', u'侀'), + (0xFA74, 'M', u'充'), + (0xFA75, 'M', u'冀'), + (0xFA76, 'M', u'勇'), + (0xFA77, 'M', u'勺'), + (0xFA78, 'M', u'喝'), + (0xFA79, 'M', u'啕'), + (0xFA7A, 'M', u'喙'), + (0xFA7B, 'M', u'嗢'), + (0xFA7C, 'M', u'塚'), + (0xFA7D, 'M', u'墳'), + (0xFA7E, 'M', u'奄'), + (0xFA7F, 'M', u'奔'), + (0xFA80, 'M', u'婢'), + (0xFA81, 'M', u'嬨'), + (0xFA82, 'M', u'廒'), + (0xFA83, 'M', u'廙'), + (0xFA84, 'M', u'彩'), + (0xFA85, 'M', u'徭'), + (0xFA86, 'M', u'惘'), + (0xFA87, 'M', u'慎'), + (0xFA88, 'M', u'愈'), + (0xFA89, 'M', u'憎'), + (0xFA8A, 'M', u'慠'), + (0xFA8B, 'M', u'懲'), + (0xFA8C, 'M', u'戴'), + (0xFA8D, 'M', u'揄'), + (0xFA8E, 'M', u'搜'), + (0xFA8F, 'M', u'摒'), + (0xFA90, 'M', u'敖'), + (0xFA91, 'M', u'晴'), + (0xFA92, 'M', u'朗'), + (0xFA93, 'M', u'望'), + (0xFA94, 'M', u'杖'), + (0xFA95, 'M', u'歹'), + (0xFA96, 'M', u'殺'), + (0xFA97, 'M', u'流'), + (0xFA98, 'M', u'滛'), + (0xFA99, 'M', u'滋'), + (0xFA9A, 'M', u'漢'), + (0xFA9B, 'M', u'瀞'), + (0xFA9C, 'M', u'煮'), + (0xFA9D, 'M', u'瞧'), + (0xFA9E, 'M', u'爵'), + (0xFA9F, 'M', u'犯'), + (0xFAA0, 'M', u'猪'), + (0xFAA1, 'M', u'瑱'), + (0xFAA2, 'M', u'甆'), + (0xFAA3, 'M', u'画'), + (0xFAA4, 'M', u'瘝'), + (0xFAA5, 'M', u'瘟'), + (0xFAA6, 'M', u'益'), + (0xFAA7, 'M', u'盛'), + (0xFAA8, 'M', u'直'), + (0xFAA9, 'M', u'睊'), + (0xFAAA, 'M', u'着'), + (0xFAAB, 'M', u'磌'), + (0xFAAC, 'M', u'窱'), + ] + +def _seg_43(): + return [ + (0xFAAD, 'M', u'節'), + (0xFAAE, 'M', u'类'), + (0xFAAF, 'M', u'絛'), + (0xFAB0, 'M', u'練'), + (0xFAB1, 'M', u'缾'), + (0xFAB2, 'M', u'者'), + (0xFAB3, 'M', u'荒'), + (0xFAB4, 'M', u'華'), + (0xFAB5, 'M', u'蝹'), + (0xFAB6, 'M', u'襁'), + (0xFAB7, 'M', u'覆'), + (0xFAB8, 'M', u'視'), + (0xFAB9, 'M', u'調'), + (0xFABA, 'M', u'諸'), + (0xFABB, 'M', u'請'), + (0xFABC, 'M', u'謁'), + (0xFABD, 'M', u'諾'), + (0xFABE, 'M', u'諭'), + (0xFABF, 'M', u'謹'), + (0xFAC0, 'M', u'變'), + (0xFAC1, 'M', u'贈'), + (0xFAC2, 'M', u'輸'), + (0xFAC3, 'M', u'遲'), + (0xFAC4, 'M', u'醙'), + (0xFAC5, 'M', u'鉶'), + (0xFAC6, 'M', u'陼'), + (0xFAC7, 'M', u'難'), + (0xFAC8, 'M', u'靖'), + (0xFAC9, 'M', u'韛'), + (0xFACA, 'M', u'響'), + (0xFACB, 'M', u'頋'), + (0xFACC, 'M', u'頻'), + (0xFACD, 'M', u'鬒'), + (0xFACE, 'M', u'龜'), + (0xFACF, 'M', u'𢡊'), + (0xFAD0, 'M', u'𢡄'), + (0xFAD1, 'M', u'𣏕'), + (0xFAD2, 'M', u'㮝'), + (0xFAD3, 'M', u'䀘'), + (0xFAD4, 'M', u'䀹'), + (0xFAD5, 'M', u'𥉉'), + (0xFAD6, 'M', u'𥳐'), + (0xFAD7, 'M', u'𧻓'), + (0xFAD8, 'M', u'齃'), + (0xFAD9, 'M', u'龎'), + (0xFADA, 'X'), + (0xFB00, 'M', u'ff'), + (0xFB01, 'M', u'fi'), + (0xFB02, 'M', u'fl'), + (0xFB03, 'M', u'ffi'), + (0xFB04, 'M', u'ffl'), + (0xFB05, 'M', u'st'), + (0xFB07, 'X'), + (0xFB13, 'M', u'մն'), + (0xFB14, 'M', u'մե'), + (0xFB15, 'M', u'մի'), + (0xFB16, 'M', u'վն'), + (0xFB17, 'M', u'մխ'), + (0xFB18, 'X'), + (0xFB1D, 'M', u'יִ'), + (0xFB1E, 'V'), + (0xFB1F, 'M', u'ײַ'), + (0xFB20, 'M', u'ע'), + (0xFB21, 'M', u'א'), + (0xFB22, 'M', u'ד'), + (0xFB23, 'M', u'ה'), + (0xFB24, 'M', u'כ'), + (0xFB25, 'M', u'ל'), + (0xFB26, 'M', u'ם'), + (0xFB27, 'M', u'ר'), + (0xFB28, 'M', u'ת'), + (0xFB29, '3', u'+'), + (0xFB2A, 'M', u'שׁ'), + (0xFB2B, 'M', u'שׂ'), + (0xFB2C, 'M', u'שּׁ'), + (0xFB2D, 'M', u'שּׂ'), + (0xFB2E, 'M', u'אַ'), + (0xFB2F, 'M', u'אָ'), + (0xFB30, 'M', u'אּ'), + (0xFB31, 'M', u'בּ'), + (0xFB32, 'M', u'גּ'), + (0xFB33, 'M', u'דּ'), + (0xFB34, 'M', u'הּ'), + (0xFB35, 'M', u'וּ'), + (0xFB36, 'M', u'זּ'), + (0xFB37, 'X'), + (0xFB38, 'M', u'טּ'), + (0xFB39, 'M', u'יּ'), + (0xFB3A, 'M', u'ךּ'), + (0xFB3B, 'M', u'כּ'), + (0xFB3C, 'M', u'לּ'), + (0xFB3D, 'X'), + (0xFB3E, 'M', u'מּ'), + (0xFB3F, 'X'), + (0xFB40, 'M', u'נּ'), + (0xFB41, 'M', u'סּ'), + (0xFB42, 'X'), + (0xFB43, 'M', u'ףּ'), + (0xFB44, 'M', u'פּ'), + (0xFB45, 'X'), + ] + +def _seg_44(): + return [ + (0xFB46, 'M', u'צּ'), + (0xFB47, 'M', u'קּ'), + (0xFB48, 'M', u'רּ'), + (0xFB49, 'M', u'שּ'), + (0xFB4A, 'M', u'תּ'), + (0xFB4B, 'M', u'וֹ'), + (0xFB4C, 'M', u'בֿ'), + (0xFB4D, 'M', u'כֿ'), + (0xFB4E, 'M', u'פֿ'), + (0xFB4F, 'M', u'אל'), + (0xFB50, 'M', u'ٱ'), + (0xFB52, 'M', u'ٻ'), + (0xFB56, 'M', u'پ'), + (0xFB5A, 'M', u'ڀ'), + (0xFB5E, 'M', u'ٺ'), + (0xFB62, 'M', u'ٿ'), + (0xFB66, 'M', u'ٹ'), + (0xFB6A, 'M', u'ڤ'), + (0xFB6E, 'M', u'ڦ'), + (0xFB72, 'M', u'ڄ'), + (0xFB76, 'M', u'ڃ'), + (0xFB7A, 'M', u'چ'), + (0xFB7E, 'M', u'ڇ'), + (0xFB82, 'M', u'ڍ'), + (0xFB84, 'M', u'ڌ'), + (0xFB86, 'M', u'ڎ'), + (0xFB88, 'M', u'ڈ'), + (0xFB8A, 'M', u'ژ'), + (0xFB8C, 'M', u'ڑ'), + (0xFB8E, 'M', u'ک'), + (0xFB92, 'M', u'گ'), + (0xFB96, 'M', u'ڳ'), + (0xFB9A, 'M', u'ڱ'), + (0xFB9E, 'M', u'ں'), + (0xFBA0, 'M', u'ڻ'), + (0xFBA4, 'M', u'ۀ'), + (0xFBA6, 'M', u'ہ'), + (0xFBAA, 'M', u'ھ'), + (0xFBAE, 'M', u'ے'), + (0xFBB0, 'M', u'ۓ'), + (0xFBB2, 'V'), + (0xFBC2, 'X'), + (0xFBD3, 'M', u'ڭ'), + (0xFBD7, 'M', u'ۇ'), + (0xFBD9, 'M', u'ۆ'), + (0xFBDB, 'M', u'ۈ'), + (0xFBDD, 'M', u'ۇٴ'), + (0xFBDE, 'M', u'ۋ'), + (0xFBE0, 'M', u'ۅ'), + (0xFBE2, 'M', u'ۉ'), + (0xFBE4, 'M', u'ې'), + (0xFBE8, 'M', u'ى'), + (0xFBEA, 'M', u'ئا'), + (0xFBEC, 'M', u'ئە'), + (0xFBEE, 'M', u'ئو'), + (0xFBF0, 'M', u'ئۇ'), + (0xFBF2, 'M', u'ئۆ'), + (0xFBF4, 'M', u'ئۈ'), + (0xFBF6, 'M', u'ئې'), + (0xFBF9, 'M', u'ئى'), + (0xFBFC, 'M', u'ی'), + (0xFC00, 'M', u'ئج'), + (0xFC01, 'M', u'ئح'), + (0xFC02, 'M', u'ئم'), + (0xFC03, 'M', u'ئى'), + (0xFC04, 'M', u'ئي'), + (0xFC05, 'M', u'بج'), + (0xFC06, 'M', u'بح'), + (0xFC07, 'M', u'بخ'), + (0xFC08, 'M', u'بم'), + (0xFC09, 'M', u'بى'), + (0xFC0A, 'M', u'بي'), + (0xFC0B, 'M', u'تج'), + (0xFC0C, 'M', u'تح'), + (0xFC0D, 'M', u'تخ'), + (0xFC0E, 'M', u'تم'), + (0xFC0F, 'M', u'تى'), + (0xFC10, 'M', u'تي'), + (0xFC11, 'M', u'ثج'), + (0xFC12, 'M', u'ثم'), + (0xFC13, 'M', u'ثى'), + (0xFC14, 'M', u'ثي'), + (0xFC15, 'M', u'جح'), + (0xFC16, 'M', u'جم'), + (0xFC17, 'M', u'حج'), + (0xFC18, 'M', u'حم'), + (0xFC19, 'M', u'خج'), + (0xFC1A, 'M', u'خح'), + (0xFC1B, 'M', u'خم'), + (0xFC1C, 'M', u'سج'), + (0xFC1D, 'M', u'سح'), + (0xFC1E, 'M', u'سخ'), + (0xFC1F, 'M', u'سم'), + (0xFC20, 'M', u'صح'), + (0xFC21, 'M', u'صم'), + (0xFC22, 'M', u'ضج'), + (0xFC23, 'M', u'ضح'), + (0xFC24, 'M', u'ضخ'), + (0xFC25, 'M', u'ضم'), + (0xFC26, 'M', u'طح'), + ] + +def _seg_45(): + return [ + (0xFC27, 'M', u'طم'), + (0xFC28, 'M', u'ظم'), + (0xFC29, 'M', u'عج'), + (0xFC2A, 'M', u'عم'), + (0xFC2B, 'M', u'غج'), + (0xFC2C, 'M', u'غم'), + (0xFC2D, 'M', u'فج'), + (0xFC2E, 'M', u'فح'), + (0xFC2F, 'M', u'فخ'), + (0xFC30, 'M', u'فم'), + (0xFC31, 'M', u'فى'), + (0xFC32, 'M', u'في'), + (0xFC33, 'M', u'قح'), + (0xFC34, 'M', u'قم'), + (0xFC35, 'M', u'قى'), + (0xFC36, 'M', u'قي'), + (0xFC37, 'M', u'كا'), + (0xFC38, 'M', u'كج'), + (0xFC39, 'M', u'كح'), + (0xFC3A, 'M', u'كخ'), + (0xFC3B, 'M', u'كل'), + (0xFC3C, 'M', u'كم'), + (0xFC3D, 'M', u'كى'), + (0xFC3E, 'M', u'كي'), + (0xFC3F, 'M', u'لج'), + (0xFC40, 'M', u'لح'), + (0xFC41, 'M', u'لخ'), + (0xFC42, 'M', u'لم'), + (0xFC43, 'M', u'لى'), + (0xFC44, 'M', u'لي'), + (0xFC45, 'M', u'مج'), + (0xFC46, 'M', u'مح'), + (0xFC47, 'M', u'مخ'), + (0xFC48, 'M', u'مم'), + (0xFC49, 'M', u'مى'), + (0xFC4A, 'M', u'مي'), + (0xFC4B, 'M', u'نج'), + (0xFC4C, 'M', u'نح'), + (0xFC4D, 'M', u'نخ'), + (0xFC4E, 'M', u'نم'), + (0xFC4F, 'M', u'نى'), + (0xFC50, 'M', u'ني'), + (0xFC51, 'M', u'هج'), + (0xFC52, 'M', u'هم'), + (0xFC53, 'M', u'هى'), + (0xFC54, 'M', u'هي'), + (0xFC55, 'M', u'يج'), + (0xFC56, 'M', u'يح'), + (0xFC57, 'M', u'يخ'), + (0xFC58, 'M', u'يم'), + (0xFC59, 'M', u'يى'), + (0xFC5A, 'M', u'يي'), + (0xFC5B, 'M', u'ذٰ'), + (0xFC5C, 'M', u'رٰ'), + (0xFC5D, 'M', u'ىٰ'), + (0xFC5E, '3', u' ٌّ'), + (0xFC5F, '3', u' ٍّ'), + (0xFC60, '3', u' َّ'), + (0xFC61, '3', u' ُّ'), + (0xFC62, '3', u' ِّ'), + (0xFC63, '3', u' ّٰ'), + (0xFC64, 'M', u'ئر'), + (0xFC65, 'M', u'ئز'), + (0xFC66, 'M', u'ئم'), + (0xFC67, 'M', u'ئن'), + (0xFC68, 'M', u'ئى'), + (0xFC69, 'M', u'ئي'), + (0xFC6A, 'M', u'بر'), + (0xFC6B, 'M', u'بز'), + (0xFC6C, 'M', u'بم'), + (0xFC6D, 'M', u'بن'), + (0xFC6E, 'M', u'بى'), + (0xFC6F, 'M', u'بي'), + (0xFC70, 'M', u'تر'), + (0xFC71, 'M', u'تز'), + (0xFC72, 'M', u'تم'), + (0xFC73, 'M', u'تن'), + (0xFC74, 'M', u'تى'), + (0xFC75, 'M', u'تي'), + (0xFC76, 'M', u'ثر'), + (0xFC77, 'M', u'ثز'), + (0xFC78, 'M', u'ثم'), + (0xFC79, 'M', u'ثن'), + (0xFC7A, 'M', u'ثى'), + (0xFC7B, 'M', u'ثي'), + (0xFC7C, 'M', u'فى'), + (0xFC7D, 'M', u'في'), + (0xFC7E, 'M', u'قى'), + (0xFC7F, 'M', u'قي'), + (0xFC80, 'M', u'كا'), + (0xFC81, 'M', u'كل'), + (0xFC82, 'M', u'كم'), + (0xFC83, 'M', u'كى'), + (0xFC84, 'M', u'كي'), + (0xFC85, 'M', u'لم'), + (0xFC86, 'M', u'لى'), + (0xFC87, 'M', u'لي'), + (0xFC88, 'M', u'ما'), + (0xFC89, 'M', u'مم'), + (0xFC8A, 'M', u'نر'), + ] + +def _seg_46(): + return [ + (0xFC8B, 'M', u'نز'), + (0xFC8C, 'M', u'نم'), + (0xFC8D, 'M', u'نن'), + (0xFC8E, 'M', u'نى'), + (0xFC8F, 'M', u'ني'), + (0xFC90, 'M', u'ىٰ'), + (0xFC91, 'M', u'ير'), + (0xFC92, 'M', u'يز'), + (0xFC93, 'M', u'يم'), + (0xFC94, 'M', u'ين'), + (0xFC95, 'M', u'يى'), + (0xFC96, 'M', u'يي'), + (0xFC97, 'M', u'ئج'), + (0xFC98, 'M', u'ئح'), + (0xFC99, 'M', u'ئخ'), + (0xFC9A, 'M', u'ئم'), + (0xFC9B, 'M', u'ئه'), + (0xFC9C, 'M', u'بج'), + (0xFC9D, 'M', u'بح'), + (0xFC9E, 'M', u'بخ'), + (0xFC9F, 'M', u'بم'), + (0xFCA0, 'M', u'به'), + (0xFCA1, 'M', u'تج'), + (0xFCA2, 'M', u'تح'), + (0xFCA3, 'M', u'تخ'), + (0xFCA4, 'M', u'تم'), + (0xFCA5, 'M', u'ته'), + (0xFCA6, 'M', u'ثم'), + (0xFCA7, 'M', u'جح'), + (0xFCA8, 'M', u'جم'), + (0xFCA9, 'M', u'حج'), + (0xFCAA, 'M', u'حم'), + (0xFCAB, 'M', u'خج'), + (0xFCAC, 'M', u'خم'), + (0xFCAD, 'M', u'سج'), + (0xFCAE, 'M', u'سح'), + (0xFCAF, 'M', u'سخ'), + (0xFCB0, 'M', u'سم'), + (0xFCB1, 'M', u'صح'), + (0xFCB2, 'M', u'صخ'), + (0xFCB3, 'M', u'صم'), + (0xFCB4, 'M', u'ضج'), + (0xFCB5, 'M', u'ضح'), + (0xFCB6, 'M', u'ضخ'), + (0xFCB7, 'M', u'ضم'), + (0xFCB8, 'M', u'طح'), + (0xFCB9, 'M', u'ظم'), + (0xFCBA, 'M', u'عج'), + (0xFCBB, 'M', u'عم'), + (0xFCBC, 'M', u'غج'), + (0xFCBD, 'M', u'غم'), + (0xFCBE, 'M', u'فج'), + (0xFCBF, 'M', u'فح'), + (0xFCC0, 'M', u'فخ'), + (0xFCC1, 'M', u'فم'), + (0xFCC2, 'M', u'قح'), + (0xFCC3, 'M', u'قم'), + (0xFCC4, 'M', u'كج'), + (0xFCC5, 'M', u'كح'), + (0xFCC6, 'M', u'كخ'), + (0xFCC7, 'M', u'كل'), + (0xFCC8, 'M', u'كم'), + (0xFCC9, 'M', u'لج'), + (0xFCCA, 'M', u'لح'), + (0xFCCB, 'M', u'لخ'), + (0xFCCC, 'M', u'لم'), + (0xFCCD, 'M', u'له'), + (0xFCCE, 'M', u'مج'), + (0xFCCF, 'M', u'مح'), + (0xFCD0, 'M', u'مخ'), + (0xFCD1, 'M', u'مم'), + (0xFCD2, 'M', u'نج'), + (0xFCD3, 'M', u'نح'), + (0xFCD4, 'M', u'نخ'), + (0xFCD5, 'M', u'نم'), + (0xFCD6, 'M', u'نه'), + (0xFCD7, 'M', u'هج'), + (0xFCD8, 'M', u'هم'), + (0xFCD9, 'M', u'هٰ'), + (0xFCDA, 'M', u'يج'), + (0xFCDB, 'M', u'يح'), + (0xFCDC, 'M', u'يخ'), + (0xFCDD, 'M', u'يم'), + (0xFCDE, 'M', u'يه'), + (0xFCDF, 'M', u'ئم'), + (0xFCE0, 'M', u'ئه'), + (0xFCE1, 'M', u'بم'), + (0xFCE2, 'M', u'به'), + (0xFCE3, 'M', u'تم'), + (0xFCE4, 'M', u'ته'), + (0xFCE5, 'M', u'ثم'), + (0xFCE6, 'M', u'ثه'), + (0xFCE7, 'M', u'سم'), + (0xFCE8, 'M', u'سه'), + (0xFCE9, 'M', u'شم'), + (0xFCEA, 'M', u'شه'), + (0xFCEB, 'M', u'كل'), + (0xFCEC, 'M', u'كم'), + (0xFCED, 'M', u'لم'), + (0xFCEE, 'M', u'نم'), + ] + +def _seg_47(): + return [ + (0xFCEF, 'M', u'نه'), + (0xFCF0, 'M', u'يم'), + (0xFCF1, 'M', u'يه'), + (0xFCF2, 'M', u'ـَّ'), + (0xFCF3, 'M', u'ـُّ'), + (0xFCF4, 'M', u'ـِّ'), + (0xFCF5, 'M', u'طى'), + (0xFCF6, 'M', u'طي'), + (0xFCF7, 'M', u'عى'), + (0xFCF8, 'M', u'عي'), + (0xFCF9, 'M', u'غى'), + (0xFCFA, 'M', u'غي'), + (0xFCFB, 'M', u'سى'), + (0xFCFC, 'M', u'سي'), + (0xFCFD, 'M', u'شى'), + (0xFCFE, 'M', u'شي'), + (0xFCFF, 'M', u'حى'), + (0xFD00, 'M', u'حي'), + (0xFD01, 'M', u'جى'), + (0xFD02, 'M', u'جي'), + (0xFD03, 'M', u'خى'), + (0xFD04, 'M', u'خي'), + (0xFD05, 'M', u'صى'), + (0xFD06, 'M', u'صي'), + (0xFD07, 'M', u'ضى'), + (0xFD08, 'M', u'ضي'), + (0xFD09, 'M', u'شج'), + (0xFD0A, 'M', u'شح'), + (0xFD0B, 'M', u'شخ'), + (0xFD0C, 'M', u'شم'), + (0xFD0D, 'M', u'شر'), + (0xFD0E, 'M', u'سر'), + (0xFD0F, 'M', u'صر'), + (0xFD10, 'M', u'ضر'), + (0xFD11, 'M', u'طى'), + (0xFD12, 'M', u'طي'), + (0xFD13, 'M', u'عى'), + (0xFD14, 'M', u'عي'), + (0xFD15, 'M', u'غى'), + (0xFD16, 'M', u'غي'), + (0xFD17, 'M', u'سى'), + (0xFD18, 'M', u'سي'), + (0xFD19, 'M', u'شى'), + (0xFD1A, 'M', u'شي'), + (0xFD1B, 'M', u'حى'), + (0xFD1C, 'M', u'حي'), + (0xFD1D, 'M', u'جى'), + (0xFD1E, 'M', u'جي'), + (0xFD1F, 'M', u'خى'), + (0xFD20, 'M', u'خي'), + (0xFD21, 'M', u'صى'), + (0xFD22, 'M', u'صي'), + (0xFD23, 'M', u'ضى'), + (0xFD24, 'M', u'ضي'), + (0xFD25, 'M', u'شج'), + (0xFD26, 'M', u'شح'), + (0xFD27, 'M', u'شخ'), + (0xFD28, 'M', u'شم'), + (0xFD29, 'M', u'شر'), + (0xFD2A, 'M', u'سر'), + (0xFD2B, 'M', u'صر'), + (0xFD2C, 'M', u'ضر'), + (0xFD2D, 'M', u'شج'), + (0xFD2E, 'M', u'شح'), + (0xFD2F, 'M', u'شخ'), + (0xFD30, 'M', u'شم'), + (0xFD31, 'M', u'سه'), + (0xFD32, 'M', u'شه'), + (0xFD33, 'M', u'طم'), + (0xFD34, 'M', u'سج'), + (0xFD35, 'M', u'سح'), + (0xFD36, 'M', u'سخ'), + (0xFD37, 'M', u'شج'), + (0xFD38, 'M', u'شح'), + (0xFD39, 'M', u'شخ'), + (0xFD3A, 'M', u'طم'), + (0xFD3B, 'M', u'ظم'), + (0xFD3C, 'M', u'اً'), + (0xFD3E, 'V'), + (0xFD40, 'X'), + (0xFD50, 'M', u'تجم'), + (0xFD51, 'M', u'تحج'), + (0xFD53, 'M', u'تحم'), + (0xFD54, 'M', u'تخم'), + (0xFD55, 'M', u'تمج'), + (0xFD56, 'M', u'تمح'), + (0xFD57, 'M', u'تمخ'), + (0xFD58, 'M', u'جمح'), + (0xFD5A, 'M', u'حمي'), + (0xFD5B, 'M', u'حمى'), + (0xFD5C, 'M', u'سحج'), + (0xFD5D, 'M', u'سجح'), + (0xFD5E, 'M', u'سجى'), + (0xFD5F, 'M', u'سمح'), + (0xFD61, 'M', u'سمج'), + (0xFD62, 'M', u'سمم'), + (0xFD64, 'M', u'صحح'), + (0xFD66, 'M', u'صمم'), + (0xFD67, 'M', u'شحم'), + (0xFD69, 'M', u'شجي'), + ] + +def _seg_48(): + return [ + (0xFD6A, 'M', u'شمخ'), + (0xFD6C, 'M', u'شمم'), + (0xFD6E, 'M', u'ضحى'), + (0xFD6F, 'M', u'ضخم'), + (0xFD71, 'M', u'طمح'), + (0xFD73, 'M', u'طمم'), + (0xFD74, 'M', u'طمي'), + (0xFD75, 'M', u'عجم'), + (0xFD76, 'M', u'عمم'), + (0xFD78, 'M', u'عمى'), + (0xFD79, 'M', u'غمم'), + (0xFD7A, 'M', u'غمي'), + (0xFD7B, 'M', u'غمى'), + (0xFD7C, 'M', u'فخم'), + (0xFD7E, 'M', u'قمح'), + (0xFD7F, 'M', u'قمم'), + (0xFD80, 'M', u'لحم'), + (0xFD81, 'M', u'لحي'), + (0xFD82, 'M', u'لحى'), + (0xFD83, 'M', u'لجج'), + (0xFD85, 'M', u'لخم'), + (0xFD87, 'M', u'لمح'), + (0xFD89, 'M', u'محج'), + (0xFD8A, 'M', u'محم'), + (0xFD8B, 'M', u'محي'), + (0xFD8C, 'M', u'مجح'), + (0xFD8D, 'M', u'مجم'), + (0xFD8E, 'M', u'مخج'), + (0xFD8F, 'M', u'مخم'), + (0xFD90, 'X'), + (0xFD92, 'M', u'مجخ'), + (0xFD93, 'M', u'همج'), + (0xFD94, 'M', u'همم'), + (0xFD95, 'M', u'نحم'), + (0xFD96, 'M', u'نحى'), + (0xFD97, 'M', u'نجم'), + (0xFD99, 'M', u'نجى'), + (0xFD9A, 'M', u'نمي'), + (0xFD9B, 'M', u'نمى'), + (0xFD9C, 'M', u'يمم'), + (0xFD9E, 'M', u'بخي'), + (0xFD9F, 'M', u'تجي'), + (0xFDA0, 'M', u'تجى'), + (0xFDA1, 'M', u'تخي'), + (0xFDA2, 'M', u'تخى'), + (0xFDA3, 'M', u'تمي'), + (0xFDA4, 'M', u'تمى'), + (0xFDA5, 'M', u'جمي'), + (0xFDA6, 'M', u'جحى'), + (0xFDA7, 'M', u'جمى'), + (0xFDA8, 'M', u'سخى'), + (0xFDA9, 'M', u'صحي'), + (0xFDAA, 'M', u'شحي'), + (0xFDAB, 'M', u'ضحي'), + (0xFDAC, 'M', u'لجي'), + (0xFDAD, 'M', u'لمي'), + (0xFDAE, 'M', u'يحي'), + (0xFDAF, 'M', u'يجي'), + (0xFDB0, 'M', u'يمي'), + (0xFDB1, 'M', u'ممي'), + (0xFDB2, 'M', u'قمي'), + (0xFDB3, 'M', u'نحي'), + (0xFDB4, 'M', u'قمح'), + (0xFDB5, 'M', u'لحم'), + (0xFDB6, 'M', u'عمي'), + (0xFDB7, 'M', u'كمي'), + (0xFDB8, 'M', u'نجح'), + (0xFDB9, 'M', u'مخي'), + (0xFDBA, 'M', u'لجم'), + (0xFDBB, 'M', u'كمم'), + (0xFDBC, 'M', u'لجم'), + (0xFDBD, 'M', u'نجح'), + (0xFDBE, 'M', u'جحي'), + (0xFDBF, 'M', u'حجي'), + (0xFDC0, 'M', u'مجي'), + (0xFDC1, 'M', u'فمي'), + (0xFDC2, 'M', u'بحي'), + (0xFDC3, 'M', u'كمم'), + (0xFDC4, 'M', u'عجم'), + (0xFDC5, 'M', u'صمم'), + (0xFDC6, 'M', u'سخي'), + (0xFDC7, 'M', u'نجي'), + (0xFDC8, 'X'), + (0xFDF0, 'M', u'صلے'), + (0xFDF1, 'M', u'قلے'), + (0xFDF2, 'M', u'الله'), + (0xFDF3, 'M', u'اكبر'), + (0xFDF4, 'M', u'محمد'), + (0xFDF5, 'M', u'صلعم'), + (0xFDF6, 'M', u'رسول'), + (0xFDF7, 'M', u'عليه'), + (0xFDF8, 'M', u'وسلم'), + (0xFDF9, 'M', u'صلى'), + (0xFDFA, '3', u'صلى الله عليه وسلم'), + (0xFDFB, '3', u'جل جلاله'), + (0xFDFC, 'M', u'ریال'), + (0xFDFD, 'V'), + (0xFDFE, 'X'), + (0xFE00, 'I'), + (0xFE10, '3', u','), + ] + +def _seg_49(): + return [ + (0xFE11, 'M', u'、'), + (0xFE12, 'X'), + (0xFE13, '3', u':'), + (0xFE14, '3', u';'), + (0xFE15, '3', u'!'), + (0xFE16, '3', u'?'), + (0xFE17, 'M', u'〖'), + (0xFE18, 'M', u'〗'), + (0xFE19, 'X'), + (0xFE20, 'V'), + (0xFE30, 'X'), + (0xFE31, 'M', u'—'), + (0xFE32, 'M', u'–'), + (0xFE33, '3', u'_'), + (0xFE35, '3', u'('), + (0xFE36, '3', u')'), + (0xFE37, '3', u'{'), + (0xFE38, '3', u'}'), + (0xFE39, 'M', u'〔'), + (0xFE3A, 'M', u'〕'), + (0xFE3B, 'M', u'【'), + (0xFE3C, 'M', u'】'), + (0xFE3D, 'M', u'《'), + (0xFE3E, 'M', u'》'), + (0xFE3F, 'M', u'〈'), + (0xFE40, 'M', u'〉'), + (0xFE41, 'M', u'「'), + (0xFE42, 'M', u'」'), + (0xFE43, 'M', u'『'), + (0xFE44, 'M', u'』'), + (0xFE45, 'V'), + (0xFE47, '3', u'['), + (0xFE48, '3', u']'), + (0xFE49, '3', u' ̅'), + (0xFE4D, '3', u'_'), + (0xFE50, '3', u','), + (0xFE51, 'M', u'、'), + (0xFE52, 'X'), + (0xFE54, '3', u';'), + (0xFE55, '3', u':'), + (0xFE56, '3', u'?'), + (0xFE57, '3', u'!'), + (0xFE58, 'M', u'—'), + (0xFE59, '3', u'('), + (0xFE5A, '3', u')'), + (0xFE5B, '3', u'{'), + (0xFE5C, '3', u'}'), + (0xFE5D, 'M', u'〔'), + (0xFE5E, 'M', u'〕'), + (0xFE5F, '3', u'#'), + (0xFE60, '3', u'&'), + (0xFE61, '3', u'*'), + (0xFE62, '3', u'+'), + (0xFE63, 'M', u'-'), + (0xFE64, '3', u'<'), + (0xFE65, '3', u'>'), + (0xFE66, '3', u'='), + (0xFE67, 'X'), + (0xFE68, '3', u'\\'), + (0xFE69, '3', u'$'), + (0xFE6A, '3', u'%'), + (0xFE6B, '3', u'@'), + (0xFE6C, 'X'), + (0xFE70, '3', u' ً'), + (0xFE71, 'M', u'ـً'), + (0xFE72, '3', u' ٌ'), + (0xFE73, 'V'), + (0xFE74, '3', u' ٍ'), + (0xFE75, 'X'), + (0xFE76, '3', u' َ'), + (0xFE77, 'M', u'ـَ'), + (0xFE78, '3', u' ُ'), + (0xFE79, 'M', u'ـُ'), + (0xFE7A, '3', u' ِ'), + (0xFE7B, 'M', u'ـِ'), + (0xFE7C, '3', u' ّ'), + (0xFE7D, 'M', u'ـّ'), + (0xFE7E, '3', u' ْ'), + (0xFE7F, 'M', u'ـْ'), + (0xFE80, 'M', u'ء'), + (0xFE81, 'M', u'آ'), + (0xFE83, 'M', u'أ'), + (0xFE85, 'M', u'ؤ'), + (0xFE87, 'M', u'إ'), + (0xFE89, 'M', u'ئ'), + (0xFE8D, 'M', u'ا'), + (0xFE8F, 'M', u'ب'), + (0xFE93, 'M', u'ة'), + (0xFE95, 'M', u'ت'), + (0xFE99, 'M', u'ث'), + (0xFE9D, 'M', u'ج'), + (0xFEA1, 'M', u'ح'), + (0xFEA5, 'M', u'خ'), + (0xFEA9, 'M', u'د'), + (0xFEAB, 'M', u'ذ'), + (0xFEAD, 'M', u'ر'), + (0xFEAF, 'M', u'ز'), + (0xFEB1, 'M', u'س'), + (0xFEB5, 'M', u'ش'), + (0xFEB9, 'M', u'ص'), + ] + +def _seg_50(): + return [ + (0xFEBD, 'M', u'ض'), + (0xFEC1, 'M', u'ط'), + (0xFEC5, 'M', u'ظ'), + (0xFEC9, 'M', u'ع'), + (0xFECD, 'M', u'غ'), + (0xFED1, 'M', u'ف'), + (0xFED5, 'M', u'ق'), + (0xFED9, 'M', u'ك'), + (0xFEDD, 'M', u'ل'), + (0xFEE1, 'M', u'م'), + (0xFEE5, 'M', u'ن'), + (0xFEE9, 'M', u'ه'), + (0xFEED, 'M', u'و'), + (0xFEEF, 'M', u'ى'), + (0xFEF1, 'M', u'ي'), + (0xFEF5, 'M', u'لآ'), + (0xFEF7, 'M', u'لأ'), + (0xFEF9, 'M', u'لإ'), + (0xFEFB, 'M', u'لا'), + (0xFEFD, 'X'), + (0xFEFF, 'I'), + (0xFF00, 'X'), + (0xFF01, '3', u'!'), + (0xFF02, '3', u'"'), + (0xFF03, '3', u'#'), + (0xFF04, '3', u'$'), + (0xFF05, '3', u'%'), + (0xFF06, '3', u'&'), + (0xFF07, '3', u'\''), + (0xFF08, '3', u'('), + (0xFF09, '3', u')'), + (0xFF0A, '3', u'*'), + (0xFF0B, '3', u'+'), + (0xFF0C, '3', u','), + (0xFF0D, 'M', u'-'), + (0xFF0E, 'M', u'.'), + (0xFF0F, '3', u'/'), + (0xFF10, 'M', u'0'), + (0xFF11, 'M', u'1'), + (0xFF12, 'M', u'2'), + (0xFF13, 'M', u'3'), + (0xFF14, 'M', u'4'), + (0xFF15, 'M', u'5'), + (0xFF16, 'M', u'6'), + (0xFF17, 'M', u'7'), + (0xFF18, 'M', u'8'), + (0xFF19, 'M', u'9'), + (0xFF1A, '3', u':'), + (0xFF1B, '3', u';'), + (0xFF1C, '3', u'<'), + (0xFF1D, '3', u'='), + (0xFF1E, '3', u'>'), + (0xFF1F, '3', u'?'), + (0xFF20, '3', u'@'), + (0xFF21, 'M', u'a'), + (0xFF22, 'M', u'b'), + (0xFF23, 'M', u'c'), + (0xFF24, 'M', u'd'), + (0xFF25, 'M', u'e'), + (0xFF26, 'M', u'f'), + (0xFF27, 'M', u'g'), + (0xFF28, 'M', u'h'), + (0xFF29, 'M', u'i'), + (0xFF2A, 'M', u'j'), + (0xFF2B, 'M', u'k'), + (0xFF2C, 'M', u'l'), + (0xFF2D, 'M', u'm'), + (0xFF2E, 'M', u'n'), + (0xFF2F, 'M', u'o'), + (0xFF30, 'M', u'p'), + (0xFF31, 'M', u'q'), + (0xFF32, 'M', u'r'), + (0xFF33, 'M', u's'), + (0xFF34, 'M', u't'), + (0xFF35, 'M', u'u'), + (0xFF36, 'M', u'v'), + (0xFF37, 'M', u'w'), + (0xFF38, 'M', u'x'), + (0xFF39, 'M', u'y'), + (0xFF3A, 'M', u'z'), + (0xFF3B, '3', u'['), + (0xFF3C, '3', u'\\'), + (0xFF3D, '3', u']'), + (0xFF3E, '3', u'^'), + (0xFF3F, '3', u'_'), + (0xFF40, '3', u'`'), + (0xFF41, 'M', u'a'), + (0xFF42, 'M', u'b'), + (0xFF43, 'M', u'c'), + (0xFF44, 'M', u'd'), + (0xFF45, 'M', u'e'), + (0xFF46, 'M', u'f'), + (0xFF47, 'M', u'g'), + (0xFF48, 'M', u'h'), + (0xFF49, 'M', u'i'), + (0xFF4A, 'M', u'j'), + (0xFF4B, 'M', u'k'), + (0xFF4C, 'M', u'l'), + (0xFF4D, 'M', u'm'), + (0xFF4E, 'M', u'n'), + ] + +def _seg_51(): + return [ + (0xFF4F, 'M', u'o'), + (0xFF50, 'M', u'p'), + (0xFF51, 'M', u'q'), + (0xFF52, 'M', u'r'), + (0xFF53, 'M', u's'), + (0xFF54, 'M', u't'), + (0xFF55, 'M', u'u'), + (0xFF56, 'M', u'v'), + (0xFF57, 'M', u'w'), + (0xFF58, 'M', u'x'), + (0xFF59, 'M', u'y'), + (0xFF5A, 'M', u'z'), + (0xFF5B, '3', u'{'), + (0xFF5C, '3', u'|'), + (0xFF5D, '3', u'}'), + (0xFF5E, '3', u'~'), + (0xFF5F, 'M', u'⦅'), + (0xFF60, 'M', u'⦆'), + (0xFF61, 'M', u'.'), + (0xFF62, 'M', u'「'), + (0xFF63, 'M', u'」'), + (0xFF64, 'M', u'、'), + (0xFF65, 'M', u'・'), + (0xFF66, 'M', u'ヲ'), + (0xFF67, 'M', u'ァ'), + (0xFF68, 'M', u'ィ'), + (0xFF69, 'M', u'ゥ'), + (0xFF6A, 'M', u'ェ'), + (0xFF6B, 'M', u'ォ'), + (0xFF6C, 'M', u'ャ'), + (0xFF6D, 'M', u'ュ'), + (0xFF6E, 'M', u'ョ'), + (0xFF6F, 'M', u'ッ'), + (0xFF70, 'M', u'ー'), + (0xFF71, 'M', u'ア'), + (0xFF72, 'M', u'イ'), + (0xFF73, 'M', u'ウ'), + (0xFF74, 'M', u'エ'), + (0xFF75, 'M', u'オ'), + (0xFF76, 'M', u'カ'), + (0xFF77, 'M', u'キ'), + (0xFF78, 'M', u'ク'), + (0xFF79, 'M', u'ケ'), + (0xFF7A, 'M', u'コ'), + (0xFF7B, 'M', u'サ'), + (0xFF7C, 'M', u'シ'), + (0xFF7D, 'M', u'ス'), + (0xFF7E, 'M', u'セ'), + (0xFF7F, 'M', u'ソ'), + (0xFF80, 'M', u'タ'), + (0xFF81, 'M', u'チ'), + (0xFF82, 'M', u'ツ'), + (0xFF83, 'M', u'テ'), + (0xFF84, 'M', u'ト'), + (0xFF85, 'M', u'ナ'), + (0xFF86, 'M', u'ニ'), + (0xFF87, 'M', u'ヌ'), + (0xFF88, 'M', u'ネ'), + (0xFF89, 'M', u'ノ'), + (0xFF8A, 'M', u'ハ'), + (0xFF8B, 'M', u'ヒ'), + (0xFF8C, 'M', u'フ'), + (0xFF8D, 'M', u'ヘ'), + (0xFF8E, 'M', u'ホ'), + (0xFF8F, 'M', u'マ'), + (0xFF90, 'M', u'ミ'), + (0xFF91, 'M', u'ム'), + (0xFF92, 'M', u'メ'), + (0xFF93, 'M', u'モ'), + (0xFF94, 'M', u'ヤ'), + (0xFF95, 'M', u'ユ'), + (0xFF96, 'M', u'ヨ'), + (0xFF97, 'M', u'ラ'), + (0xFF98, 'M', u'リ'), + (0xFF99, 'M', u'ル'), + (0xFF9A, 'M', u'レ'), + (0xFF9B, 'M', u'ロ'), + (0xFF9C, 'M', u'ワ'), + (0xFF9D, 'M', u'ン'), + (0xFF9E, 'M', u'゙'), + (0xFF9F, 'M', u'゚'), + (0xFFA0, 'X'), + (0xFFA1, 'M', u'ᄀ'), + (0xFFA2, 'M', u'ᄁ'), + (0xFFA3, 'M', u'ᆪ'), + (0xFFA4, 'M', u'ᄂ'), + (0xFFA5, 'M', u'ᆬ'), + (0xFFA6, 'M', u'ᆭ'), + (0xFFA7, 'M', u'ᄃ'), + (0xFFA8, 'M', u'ᄄ'), + (0xFFA9, 'M', u'ᄅ'), + (0xFFAA, 'M', u'ᆰ'), + (0xFFAB, 'M', u'ᆱ'), + (0xFFAC, 'M', u'ᆲ'), + (0xFFAD, 'M', u'ᆳ'), + (0xFFAE, 'M', u'ᆴ'), + (0xFFAF, 'M', u'ᆵ'), + (0xFFB0, 'M', u'ᄚ'), + (0xFFB1, 'M', u'ᄆ'), + (0xFFB2, 'M', u'ᄇ'), + ] + +def _seg_52(): + return [ + (0xFFB3, 'M', u'ᄈ'), + (0xFFB4, 'M', u'ᄡ'), + (0xFFB5, 'M', u'ᄉ'), + (0xFFB6, 'M', u'ᄊ'), + (0xFFB7, 'M', u'ᄋ'), + (0xFFB8, 'M', u'ᄌ'), + (0xFFB9, 'M', u'ᄍ'), + (0xFFBA, 'M', u'ᄎ'), + (0xFFBB, 'M', u'ᄏ'), + (0xFFBC, 'M', u'ᄐ'), + (0xFFBD, 'M', u'ᄑ'), + (0xFFBE, 'M', u'ᄒ'), + (0xFFBF, 'X'), + (0xFFC2, 'M', u'ᅡ'), + (0xFFC3, 'M', u'ᅢ'), + (0xFFC4, 'M', u'ᅣ'), + (0xFFC5, 'M', u'ᅤ'), + (0xFFC6, 'M', u'ᅥ'), + (0xFFC7, 'M', u'ᅦ'), + (0xFFC8, 'X'), + (0xFFCA, 'M', u'ᅧ'), + (0xFFCB, 'M', u'ᅨ'), + (0xFFCC, 'M', u'ᅩ'), + (0xFFCD, 'M', u'ᅪ'), + (0xFFCE, 'M', u'ᅫ'), + (0xFFCF, 'M', u'ᅬ'), + (0xFFD0, 'X'), + (0xFFD2, 'M', u'ᅭ'), + (0xFFD3, 'M', u'ᅮ'), + (0xFFD4, 'M', u'ᅯ'), + (0xFFD5, 'M', u'ᅰ'), + (0xFFD6, 'M', u'ᅱ'), + (0xFFD7, 'M', u'ᅲ'), + (0xFFD8, 'X'), + (0xFFDA, 'M', u'ᅳ'), + (0xFFDB, 'M', u'ᅴ'), + (0xFFDC, 'M', u'ᅵ'), + (0xFFDD, 'X'), + (0xFFE0, 'M', u'¢'), + (0xFFE1, 'M', u'£'), + (0xFFE2, 'M', u'¬'), + (0xFFE3, '3', u' ̄'), + (0xFFE4, 'M', u'¦'), + (0xFFE5, 'M', u'¥'), + (0xFFE6, 'M', u'₩'), + (0xFFE7, 'X'), + (0xFFE8, 'M', u'│'), + (0xFFE9, 'M', u'←'), + (0xFFEA, 'M', u'↑'), + (0xFFEB, 'M', u'→'), + (0xFFEC, 'M', u'↓'), + (0xFFED, 'M', u'■'), + (0xFFEE, 'M', u'○'), + (0xFFEF, 'X'), + (0x10000, 'V'), + (0x1000C, 'X'), + (0x1000D, 'V'), + (0x10027, 'X'), + (0x10028, 'V'), + (0x1003B, 'X'), + (0x1003C, 'V'), + (0x1003E, 'X'), + (0x1003F, 'V'), + (0x1004E, 'X'), + (0x10050, 'V'), + (0x1005E, 'X'), + (0x10080, 'V'), + (0x100FB, 'X'), + (0x10100, 'V'), + (0x10103, 'X'), + (0x10107, 'V'), + (0x10134, 'X'), + (0x10137, 'V'), + (0x1018F, 'X'), + (0x10190, 'V'), + (0x1019C, 'X'), + (0x101A0, 'V'), + (0x101A1, 'X'), + (0x101D0, 'V'), + (0x101FE, 'X'), + (0x10280, 'V'), + (0x1029D, 'X'), + (0x102A0, 'V'), + (0x102D1, 'X'), + (0x102E0, 'V'), + (0x102FC, 'X'), + (0x10300, 'V'), + (0x10324, 'X'), + (0x1032D, 'V'), + (0x1034B, 'X'), + (0x10350, 'V'), + (0x1037B, 'X'), + (0x10380, 'V'), + (0x1039E, 'X'), + (0x1039F, 'V'), + (0x103C4, 'X'), + (0x103C8, 'V'), + (0x103D6, 'X'), + (0x10400, 'M', u'𐐨'), + (0x10401, 'M', u'𐐩'), + ] + +def _seg_53(): + return [ + (0x10402, 'M', u'𐐪'), + (0x10403, 'M', u'𐐫'), + (0x10404, 'M', u'𐐬'), + (0x10405, 'M', u'𐐭'), + (0x10406, 'M', u'𐐮'), + (0x10407, 'M', u'𐐯'), + (0x10408, 'M', u'𐐰'), + (0x10409, 'M', u'𐐱'), + (0x1040A, 'M', u'𐐲'), + (0x1040B, 'M', u'𐐳'), + (0x1040C, 'M', u'𐐴'), + (0x1040D, 'M', u'𐐵'), + (0x1040E, 'M', u'𐐶'), + (0x1040F, 'M', u'𐐷'), + (0x10410, 'M', u'𐐸'), + (0x10411, 'M', u'𐐹'), + (0x10412, 'M', u'𐐺'), + (0x10413, 'M', u'𐐻'), + (0x10414, 'M', u'𐐼'), + (0x10415, 'M', u'𐐽'), + (0x10416, 'M', u'𐐾'), + (0x10417, 'M', u'𐐿'), + (0x10418, 'M', u'𐑀'), + (0x10419, 'M', u'𐑁'), + (0x1041A, 'M', u'𐑂'), + (0x1041B, 'M', u'𐑃'), + (0x1041C, 'M', u'𐑄'), + (0x1041D, 'M', u'𐑅'), + (0x1041E, 'M', u'𐑆'), + (0x1041F, 'M', u'𐑇'), + (0x10420, 'M', u'𐑈'), + (0x10421, 'M', u'𐑉'), + (0x10422, 'M', u'𐑊'), + (0x10423, 'M', u'𐑋'), + (0x10424, 'M', u'𐑌'), + (0x10425, 'M', u'𐑍'), + (0x10426, 'M', u'𐑎'), + (0x10427, 'M', u'𐑏'), + (0x10428, 'V'), + (0x1049E, 'X'), + (0x104A0, 'V'), + (0x104AA, 'X'), + (0x104B0, 'M', u'𐓘'), + (0x104B1, 'M', u'𐓙'), + (0x104B2, 'M', u'𐓚'), + (0x104B3, 'M', u'𐓛'), + (0x104B4, 'M', u'𐓜'), + (0x104B5, 'M', u'𐓝'), + (0x104B6, 'M', u'𐓞'), + (0x104B7, 'M', u'𐓟'), + (0x104B8, 'M', u'𐓠'), + (0x104B9, 'M', u'𐓡'), + (0x104BA, 'M', u'𐓢'), + (0x104BB, 'M', u'𐓣'), + (0x104BC, 'M', u'𐓤'), + (0x104BD, 'M', u'𐓥'), + (0x104BE, 'M', u'𐓦'), + (0x104BF, 'M', u'𐓧'), + (0x104C0, 'M', u'𐓨'), + (0x104C1, 'M', u'𐓩'), + (0x104C2, 'M', u'𐓪'), + (0x104C3, 'M', u'𐓫'), + (0x104C4, 'M', u'𐓬'), + (0x104C5, 'M', u'𐓭'), + (0x104C6, 'M', u'𐓮'), + (0x104C7, 'M', u'𐓯'), + (0x104C8, 'M', u'𐓰'), + (0x104C9, 'M', u'𐓱'), + (0x104CA, 'M', u'𐓲'), + (0x104CB, 'M', u'𐓳'), + (0x104CC, 'M', u'𐓴'), + (0x104CD, 'M', u'𐓵'), + (0x104CE, 'M', u'𐓶'), + (0x104CF, 'M', u'𐓷'), + (0x104D0, 'M', u'𐓸'), + (0x104D1, 'M', u'𐓹'), + (0x104D2, 'M', u'𐓺'), + (0x104D3, 'M', u'𐓻'), + (0x104D4, 'X'), + (0x104D8, 'V'), + (0x104FC, 'X'), + (0x10500, 'V'), + (0x10528, 'X'), + (0x10530, 'V'), + (0x10564, 'X'), + (0x1056F, 'V'), + (0x10570, 'X'), + (0x10600, 'V'), + (0x10737, 'X'), + (0x10740, 'V'), + (0x10756, 'X'), + (0x10760, 'V'), + (0x10768, 'X'), + (0x10800, 'V'), + (0x10806, 'X'), + (0x10808, 'V'), + (0x10809, 'X'), + (0x1080A, 'V'), + (0x10836, 'X'), + (0x10837, 'V'), + ] + +def _seg_54(): + return [ + (0x10839, 'X'), + (0x1083C, 'V'), + (0x1083D, 'X'), + (0x1083F, 'V'), + (0x10856, 'X'), + (0x10857, 'V'), + (0x1089F, 'X'), + (0x108A7, 'V'), + (0x108B0, 'X'), + (0x108E0, 'V'), + (0x108F3, 'X'), + (0x108F4, 'V'), + (0x108F6, 'X'), + (0x108FB, 'V'), + (0x1091C, 'X'), + (0x1091F, 'V'), + (0x1093A, 'X'), + (0x1093F, 'V'), + (0x10940, 'X'), + (0x10980, 'V'), + (0x109B8, 'X'), + (0x109BC, 'V'), + (0x109D0, 'X'), + (0x109D2, 'V'), + (0x10A04, 'X'), + (0x10A05, 'V'), + (0x10A07, 'X'), + (0x10A0C, 'V'), + (0x10A14, 'X'), + (0x10A15, 'V'), + (0x10A18, 'X'), + (0x10A19, 'V'), + (0x10A36, 'X'), + (0x10A38, 'V'), + (0x10A3B, 'X'), + (0x10A3F, 'V'), + (0x10A49, 'X'), + (0x10A50, 'V'), + (0x10A59, 'X'), + (0x10A60, 'V'), + (0x10AA0, 'X'), + (0x10AC0, 'V'), + (0x10AE7, 'X'), + (0x10AEB, 'V'), + (0x10AF7, 'X'), + (0x10B00, 'V'), + (0x10B36, 'X'), + (0x10B39, 'V'), + (0x10B56, 'X'), + (0x10B58, 'V'), + (0x10B73, 'X'), + (0x10B78, 'V'), + (0x10B92, 'X'), + (0x10B99, 'V'), + (0x10B9D, 'X'), + (0x10BA9, 'V'), + (0x10BB0, 'X'), + (0x10C00, 'V'), + (0x10C49, 'X'), + (0x10C80, 'M', u'𐳀'), + (0x10C81, 'M', u'𐳁'), + (0x10C82, 'M', u'𐳂'), + (0x10C83, 'M', u'𐳃'), + (0x10C84, 'M', u'𐳄'), + (0x10C85, 'M', u'𐳅'), + (0x10C86, 'M', u'𐳆'), + (0x10C87, 'M', u'𐳇'), + (0x10C88, 'M', u'𐳈'), + (0x10C89, 'M', u'𐳉'), + (0x10C8A, 'M', u'𐳊'), + (0x10C8B, 'M', u'𐳋'), + (0x10C8C, 'M', u'𐳌'), + (0x10C8D, 'M', u'𐳍'), + (0x10C8E, 'M', u'𐳎'), + (0x10C8F, 'M', u'𐳏'), + (0x10C90, 'M', u'𐳐'), + (0x10C91, 'M', u'𐳑'), + (0x10C92, 'M', u'𐳒'), + (0x10C93, 'M', u'𐳓'), + (0x10C94, 'M', u'𐳔'), + (0x10C95, 'M', u'𐳕'), + (0x10C96, 'M', u'𐳖'), + (0x10C97, 'M', u'𐳗'), + (0x10C98, 'M', u'𐳘'), + (0x10C99, 'M', u'𐳙'), + (0x10C9A, 'M', u'𐳚'), + (0x10C9B, 'M', u'𐳛'), + (0x10C9C, 'M', u'𐳜'), + (0x10C9D, 'M', u'𐳝'), + (0x10C9E, 'M', u'𐳞'), + (0x10C9F, 'M', u'𐳟'), + (0x10CA0, 'M', u'𐳠'), + (0x10CA1, 'M', u'𐳡'), + (0x10CA2, 'M', u'𐳢'), + (0x10CA3, 'M', u'𐳣'), + (0x10CA4, 'M', u'𐳤'), + (0x10CA5, 'M', u'𐳥'), + (0x10CA6, 'M', u'𐳦'), + (0x10CA7, 'M', u'𐳧'), + (0x10CA8, 'M', u'𐳨'), + ] + +def _seg_55(): + return [ + (0x10CA9, 'M', u'𐳩'), + (0x10CAA, 'M', u'𐳪'), + (0x10CAB, 'M', u'𐳫'), + (0x10CAC, 'M', u'𐳬'), + (0x10CAD, 'M', u'𐳭'), + (0x10CAE, 'M', u'𐳮'), + (0x10CAF, 'M', u'𐳯'), + (0x10CB0, 'M', u'𐳰'), + (0x10CB1, 'M', u'𐳱'), + (0x10CB2, 'M', u'𐳲'), + (0x10CB3, 'X'), + (0x10CC0, 'V'), + (0x10CF3, 'X'), + (0x10CFA, 'V'), + (0x10D28, 'X'), + (0x10D30, 'V'), + (0x10D3A, 'X'), + (0x10E60, 'V'), + (0x10E7F, 'X'), + (0x10F00, 'V'), + (0x10F28, 'X'), + (0x10F30, 'V'), + (0x10F5A, 'X'), + (0x11000, 'V'), + (0x1104E, 'X'), + (0x11052, 'V'), + (0x11070, 'X'), + (0x1107F, 'V'), + (0x110BD, 'X'), + (0x110BE, 'V'), + (0x110C2, 'X'), + (0x110D0, 'V'), + (0x110E9, 'X'), + (0x110F0, 'V'), + (0x110FA, 'X'), + (0x11100, 'V'), + (0x11135, 'X'), + (0x11136, 'V'), + (0x11147, 'X'), + (0x11150, 'V'), + (0x11177, 'X'), + (0x11180, 'V'), + (0x111CE, 'X'), + (0x111D0, 'V'), + (0x111E0, 'X'), + (0x111E1, 'V'), + (0x111F5, 'X'), + (0x11200, 'V'), + (0x11212, 'X'), + (0x11213, 'V'), + (0x1123F, 'X'), + (0x11280, 'V'), + (0x11287, 'X'), + (0x11288, 'V'), + (0x11289, 'X'), + (0x1128A, 'V'), + (0x1128E, 'X'), + (0x1128F, 'V'), + (0x1129E, 'X'), + (0x1129F, 'V'), + (0x112AA, 'X'), + (0x112B0, 'V'), + (0x112EB, 'X'), + (0x112F0, 'V'), + (0x112FA, 'X'), + (0x11300, 'V'), + (0x11304, 'X'), + (0x11305, 'V'), + (0x1130D, 'X'), + (0x1130F, 'V'), + (0x11311, 'X'), + (0x11313, 'V'), + (0x11329, 'X'), + (0x1132A, 'V'), + (0x11331, 'X'), + (0x11332, 'V'), + (0x11334, 'X'), + (0x11335, 'V'), + (0x1133A, 'X'), + (0x1133B, 'V'), + (0x11345, 'X'), + (0x11347, 'V'), + (0x11349, 'X'), + (0x1134B, 'V'), + (0x1134E, 'X'), + (0x11350, 'V'), + (0x11351, 'X'), + (0x11357, 'V'), + (0x11358, 'X'), + (0x1135D, 'V'), + (0x11364, 'X'), + (0x11366, 'V'), + (0x1136D, 'X'), + (0x11370, 'V'), + (0x11375, 'X'), + (0x11400, 'V'), + (0x1145A, 'X'), + (0x1145B, 'V'), + (0x1145C, 'X'), + (0x1145D, 'V'), + ] + +def _seg_56(): + return [ + (0x1145F, 'X'), + (0x11480, 'V'), + (0x114C8, 'X'), + (0x114D0, 'V'), + (0x114DA, 'X'), + (0x11580, 'V'), + (0x115B6, 'X'), + (0x115B8, 'V'), + (0x115DE, 'X'), + (0x11600, 'V'), + (0x11645, 'X'), + (0x11650, 'V'), + (0x1165A, 'X'), + (0x11660, 'V'), + (0x1166D, 'X'), + (0x11680, 'V'), + (0x116B8, 'X'), + (0x116C0, 'V'), + (0x116CA, 'X'), + (0x11700, 'V'), + (0x1171B, 'X'), + (0x1171D, 'V'), + (0x1172C, 'X'), + (0x11730, 'V'), + (0x11740, 'X'), + (0x11800, 'V'), + (0x1183C, 'X'), + (0x118A0, 'M', u'𑣀'), + (0x118A1, 'M', u'𑣁'), + (0x118A2, 'M', u'𑣂'), + (0x118A3, 'M', u'𑣃'), + (0x118A4, 'M', u'𑣄'), + (0x118A5, 'M', u'𑣅'), + (0x118A6, 'M', u'𑣆'), + (0x118A7, 'M', u'𑣇'), + (0x118A8, 'M', u'𑣈'), + (0x118A9, 'M', u'𑣉'), + (0x118AA, 'M', u'𑣊'), + (0x118AB, 'M', u'𑣋'), + (0x118AC, 'M', u'𑣌'), + (0x118AD, 'M', u'𑣍'), + (0x118AE, 'M', u'𑣎'), + (0x118AF, 'M', u'𑣏'), + (0x118B0, 'M', u'𑣐'), + (0x118B1, 'M', u'𑣑'), + (0x118B2, 'M', u'𑣒'), + (0x118B3, 'M', u'𑣓'), + (0x118B4, 'M', u'𑣔'), + (0x118B5, 'M', u'𑣕'), + (0x118B6, 'M', u'𑣖'), + (0x118B7, 'M', u'𑣗'), + (0x118B8, 'M', u'𑣘'), + (0x118B9, 'M', u'𑣙'), + (0x118BA, 'M', u'𑣚'), + (0x118BB, 'M', u'𑣛'), + (0x118BC, 'M', u'𑣜'), + (0x118BD, 'M', u'𑣝'), + (0x118BE, 'M', u'𑣞'), + (0x118BF, 'M', u'𑣟'), + (0x118C0, 'V'), + (0x118F3, 'X'), + (0x118FF, 'V'), + (0x11900, 'X'), + (0x11A00, 'V'), + (0x11A48, 'X'), + (0x11A50, 'V'), + (0x11A84, 'X'), + (0x11A86, 'V'), + (0x11AA3, 'X'), + (0x11AC0, 'V'), + (0x11AF9, 'X'), + (0x11C00, 'V'), + (0x11C09, 'X'), + (0x11C0A, 'V'), + (0x11C37, 'X'), + (0x11C38, 'V'), + (0x11C46, 'X'), + (0x11C50, 'V'), + (0x11C6D, 'X'), + (0x11C70, 'V'), + (0x11C90, 'X'), + (0x11C92, 'V'), + (0x11CA8, 'X'), + (0x11CA9, 'V'), + (0x11CB7, 'X'), + (0x11D00, 'V'), + (0x11D07, 'X'), + (0x11D08, 'V'), + (0x11D0A, 'X'), + (0x11D0B, 'V'), + (0x11D37, 'X'), + (0x11D3A, 'V'), + (0x11D3B, 'X'), + (0x11D3C, 'V'), + (0x11D3E, 'X'), + (0x11D3F, 'V'), + (0x11D48, 'X'), + (0x11D50, 'V'), + (0x11D5A, 'X'), + (0x11D60, 'V'), + ] + +def _seg_57(): + return [ + (0x11D66, 'X'), + (0x11D67, 'V'), + (0x11D69, 'X'), + (0x11D6A, 'V'), + (0x11D8F, 'X'), + (0x11D90, 'V'), + (0x11D92, 'X'), + (0x11D93, 'V'), + (0x11D99, 'X'), + (0x11DA0, 'V'), + (0x11DAA, 'X'), + (0x11EE0, 'V'), + (0x11EF9, 'X'), + (0x12000, 'V'), + (0x1239A, 'X'), + (0x12400, 'V'), + (0x1246F, 'X'), + (0x12470, 'V'), + (0x12475, 'X'), + (0x12480, 'V'), + (0x12544, 'X'), + (0x13000, 'V'), + (0x1342F, 'X'), + (0x14400, 'V'), + (0x14647, 'X'), + (0x16800, 'V'), + (0x16A39, 'X'), + (0x16A40, 'V'), + (0x16A5F, 'X'), + (0x16A60, 'V'), + (0x16A6A, 'X'), + (0x16A6E, 'V'), + (0x16A70, 'X'), + (0x16AD0, 'V'), + (0x16AEE, 'X'), + (0x16AF0, 'V'), + (0x16AF6, 'X'), + (0x16B00, 'V'), + (0x16B46, 'X'), + (0x16B50, 'V'), + (0x16B5A, 'X'), + (0x16B5B, 'V'), + (0x16B62, 'X'), + (0x16B63, 'V'), + (0x16B78, 'X'), + (0x16B7D, 'V'), + (0x16B90, 'X'), + (0x16E60, 'V'), + (0x16E9B, 'X'), + (0x16F00, 'V'), + (0x16F45, 'X'), + (0x16F50, 'V'), + (0x16F7F, 'X'), + (0x16F8F, 'V'), + (0x16FA0, 'X'), + (0x16FE0, 'V'), + (0x16FE2, 'X'), + (0x17000, 'V'), + (0x187F2, 'X'), + (0x18800, 'V'), + (0x18AF3, 'X'), + (0x1B000, 'V'), + (0x1B11F, 'X'), + (0x1B170, 'V'), + (0x1B2FC, 'X'), + (0x1BC00, 'V'), + (0x1BC6B, 'X'), + (0x1BC70, 'V'), + (0x1BC7D, 'X'), + (0x1BC80, 'V'), + (0x1BC89, 'X'), + (0x1BC90, 'V'), + (0x1BC9A, 'X'), + (0x1BC9C, 'V'), + (0x1BCA0, 'I'), + (0x1BCA4, 'X'), + (0x1D000, 'V'), + (0x1D0F6, 'X'), + (0x1D100, 'V'), + (0x1D127, 'X'), + (0x1D129, 'V'), + (0x1D15E, 'M', u'𝅗𝅥'), + (0x1D15F, 'M', u'𝅘𝅥'), + (0x1D160, 'M', u'𝅘𝅥𝅮'), + (0x1D161, 'M', u'𝅘𝅥𝅯'), + (0x1D162, 'M', u'𝅘𝅥𝅰'), + (0x1D163, 'M', u'𝅘𝅥𝅱'), + (0x1D164, 'M', u'𝅘𝅥𝅲'), + (0x1D165, 'V'), + (0x1D173, 'X'), + (0x1D17B, 'V'), + (0x1D1BB, 'M', u'𝆹𝅥'), + (0x1D1BC, 'M', u'𝆺𝅥'), + (0x1D1BD, 'M', u'𝆹𝅥𝅮'), + (0x1D1BE, 'M', u'𝆺𝅥𝅮'), + (0x1D1BF, 'M', u'𝆹𝅥𝅯'), + (0x1D1C0, 'M', u'𝆺𝅥𝅯'), + (0x1D1C1, 'V'), + (0x1D1E9, 'X'), + (0x1D200, 'V'), + ] + +def _seg_58(): + return [ + (0x1D246, 'X'), + (0x1D2E0, 'V'), + (0x1D2F4, 'X'), + (0x1D300, 'V'), + (0x1D357, 'X'), + (0x1D360, 'V'), + (0x1D379, 'X'), + (0x1D400, 'M', u'a'), + (0x1D401, 'M', u'b'), + (0x1D402, 'M', u'c'), + (0x1D403, 'M', u'd'), + (0x1D404, 'M', u'e'), + (0x1D405, 'M', u'f'), + (0x1D406, 'M', u'g'), + (0x1D407, 'M', u'h'), + (0x1D408, 'M', u'i'), + (0x1D409, 'M', u'j'), + (0x1D40A, 'M', u'k'), + (0x1D40B, 'M', u'l'), + (0x1D40C, 'M', u'm'), + (0x1D40D, 'M', u'n'), + (0x1D40E, 'M', u'o'), + (0x1D40F, 'M', u'p'), + (0x1D410, 'M', u'q'), + (0x1D411, 'M', u'r'), + (0x1D412, 'M', u's'), + (0x1D413, 'M', u't'), + (0x1D414, 'M', u'u'), + (0x1D415, 'M', u'v'), + (0x1D416, 'M', u'w'), + (0x1D417, 'M', u'x'), + (0x1D418, 'M', u'y'), + (0x1D419, 'M', u'z'), + (0x1D41A, 'M', u'a'), + (0x1D41B, 'M', u'b'), + (0x1D41C, 'M', u'c'), + (0x1D41D, 'M', u'd'), + (0x1D41E, 'M', u'e'), + (0x1D41F, 'M', u'f'), + (0x1D420, 'M', u'g'), + (0x1D421, 'M', u'h'), + (0x1D422, 'M', u'i'), + (0x1D423, 'M', u'j'), + (0x1D424, 'M', u'k'), + (0x1D425, 'M', u'l'), + (0x1D426, 'M', u'm'), + (0x1D427, 'M', u'n'), + (0x1D428, 'M', u'o'), + (0x1D429, 'M', u'p'), + (0x1D42A, 'M', u'q'), + (0x1D42B, 'M', u'r'), + (0x1D42C, 'M', u's'), + (0x1D42D, 'M', u't'), + (0x1D42E, 'M', u'u'), + (0x1D42F, 'M', u'v'), + (0x1D430, 'M', u'w'), + (0x1D431, 'M', u'x'), + (0x1D432, 'M', u'y'), + (0x1D433, 'M', u'z'), + (0x1D434, 'M', u'a'), + (0x1D435, 'M', u'b'), + (0x1D436, 'M', u'c'), + (0x1D437, 'M', u'd'), + (0x1D438, 'M', u'e'), + (0x1D439, 'M', u'f'), + (0x1D43A, 'M', u'g'), + (0x1D43B, 'M', u'h'), + (0x1D43C, 'M', u'i'), + (0x1D43D, 'M', u'j'), + (0x1D43E, 'M', u'k'), + (0x1D43F, 'M', u'l'), + (0x1D440, 'M', u'm'), + (0x1D441, 'M', u'n'), + (0x1D442, 'M', u'o'), + (0x1D443, 'M', u'p'), + (0x1D444, 'M', u'q'), + (0x1D445, 'M', u'r'), + (0x1D446, 'M', u's'), + (0x1D447, 'M', u't'), + (0x1D448, 'M', u'u'), + (0x1D449, 'M', u'v'), + (0x1D44A, 'M', u'w'), + (0x1D44B, 'M', u'x'), + (0x1D44C, 'M', u'y'), + (0x1D44D, 'M', u'z'), + (0x1D44E, 'M', u'a'), + (0x1D44F, 'M', u'b'), + (0x1D450, 'M', u'c'), + (0x1D451, 'M', u'd'), + (0x1D452, 'M', u'e'), + (0x1D453, 'M', u'f'), + (0x1D454, 'M', u'g'), + (0x1D455, 'X'), + (0x1D456, 'M', u'i'), + (0x1D457, 'M', u'j'), + (0x1D458, 'M', u'k'), + (0x1D459, 'M', u'l'), + (0x1D45A, 'M', u'm'), + (0x1D45B, 'M', u'n'), + (0x1D45C, 'M', u'o'), + ] + +def _seg_59(): + return [ + (0x1D45D, 'M', u'p'), + (0x1D45E, 'M', u'q'), + (0x1D45F, 'M', u'r'), + (0x1D460, 'M', u's'), + (0x1D461, 'M', u't'), + (0x1D462, 'M', u'u'), + (0x1D463, 'M', u'v'), + (0x1D464, 'M', u'w'), + (0x1D465, 'M', u'x'), + (0x1D466, 'M', u'y'), + (0x1D467, 'M', u'z'), + (0x1D468, 'M', u'a'), + (0x1D469, 'M', u'b'), + (0x1D46A, 'M', u'c'), + (0x1D46B, 'M', u'd'), + (0x1D46C, 'M', u'e'), + (0x1D46D, 'M', u'f'), + (0x1D46E, 'M', u'g'), + (0x1D46F, 'M', u'h'), + (0x1D470, 'M', u'i'), + (0x1D471, 'M', u'j'), + (0x1D472, 'M', u'k'), + (0x1D473, 'M', u'l'), + (0x1D474, 'M', u'm'), + (0x1D475, 'M', u'n'), + (0x1D476, 'M', u'o'), + (0x1D477, 'M', u'p'), + (0x1D478, 'M', u'q'), + (0x1D479, 'M', u'r'), + (0x1D47A, 'M', u's'), + (0x1D47B, 'M', u't'), + (0x1D47C, 'M', u'u'), + (0x1D47D, 'M', u'v'), + (0x1D47E, 'M', u'w'), + (0x1D47F, 'M', u'x'), + (0x1D480, 'M', u'y'), + (0x1D481, 'M', u'z'), + (0x1D482, 'M', u'a'), + (0x1D483, 'M', u'b'), + (0x1D484, 'M', u'c'), + (0x1D485, 'M', u'd'), + (0x1D486, 'M', u'e'), + (0x1D487, 'M', u'f'), + (0x1D488, 'M', u'g'), + (0x1D489, 'M', u'h'), + (0x1D48A, 'M', u'i'), + (0x1D48B, 'M', u'j'), + (0x1D48C, 'M', u'k'), + (0x1D48D, 'M', u'l'), + (0x1D48E, 'M', u'm'), + (0x1D48F, 'M', u'n'), + (0x1D490, 'M', u'o'), + (0x1D491, 'M', u'p'), + (0x1D492, 'M', u'q'), + (0x1D493, 'M', u'r'), + (0x1D494, 'M', u's'), + (0x1D495, 'M', u't'), + (0x1D496, 'M', u'u'), + (0x1D497, 'M', u'v'), + (0x1D498, 'M', u'w'), + (0x1D499, 'M', u'x'), + (0x1D49A, 'M', u'y'), + (0x1D49B, 'M', u'z'), + (0x1D49C, 'M', u'a'), + (0x1D49D, 'X'), + (0x1D49E, 'M', u'c'), + (0x1D49F, 'M', u'd'), + (0x1D4A0, 'X'), + (0x1D4A2, 'M', u'g'), + (0x1D4A3, 'X'), + (0x1D4A5, 'M', u'j'), + (0x1D4A6, 'M', u'k'), + (0x1D4A7, 'X'), + (0x1D4A9, 'M', u'n'), + (0x1D4AA, 'M', u'o'), + (0x1D4AB, 'M', u'p'), + (0x1D4AC, 'M', u'q'), + (0x1D4AD, 'X'), + (0x1D4AE, 'M', u's'), + (0x1D4AF, 'M', u't'), + (0x1D4B0, 'M', u'u'), + (0x1D4B1, 'M', u'v'), + (0x1D4B2, 'M', u'w'), + (0x1D4B3, 'M', u'x'), + (0x1D4B4, 'M', u'y'), + (0x1D4B5, 'M', u'z'), + (0x1D4B6, 'M', u'a'), + (0x1D4B7, 'M', u'b'), + (0x1D4B8, 'M', u'c'), + (0x1D4B9, 'M', u'd'), + (0x1D4BA, 'X'), + (0x1D4BB, 'M', u'f'), + (0x1D4BC, 'X'), + (0x1D4BD, 'M', u'h'), + (0x1D4BE, 'M', u'i'), + (0x1D4BF, 'M', u'j'), + (0x1D4C0, 'M', u'k'), + (0x1D4C1, 'M', u'l'), + (0x1D4C2, 'M', u'm'), + (0x1D4C3, 'M', u'n'), + ] + +def _seg_60(): + return [ + (0x1D4C4, 'X'), + (0x1D4C5, 'M', u'p'), + (0x1D4C6, 'M', u'q'), + (0x1D4C7, 'M', u'r'), + (0x1D4C8, 'M', u's'), + (0x1D4C9, 'M', u't'), + (0x1D4CA, 'M', u'u'), + (0x1D4CB, 'M', u'v'), + (0x1D4CC, 'M', u'w'), + (0x1D4CD, 'M', u'x'), + (0x1D4CE, 'M', u'y'), + (0x1D4CF, 'M', u'z'), + (0x1D4D0, 'M', u'a'), + (0x1D4D1, 'M', u'b'), + (0x1D4D2, 'M', u'c'), + (0x1D4D3, 'M', u'd'), + (0x1D4D4, 'M', u'e'), + (0x1D4D5, 'M', u'f'), + (0x1D4D6, 'M', u'g'), + (0x1D4D7, 'M', u'h'), + (0x1D4D8, 'M', u'i'), + (0x1D4D9, 'M', u'j'), + (0x1D4DA, 'M', u'k'), + (0x1D4DB, 'M', u'l'), + (0x1D4DC, 'M', u'm'), + (0x1D4DD, 'M', u'n'), + (0x1D4DE, 'M', u'o'), + (0x1D4DF, 'M', u'p'), + (0x1D4E0, 'M', u'q'), + (0x1D4E1, 'M', u'r'), + (0x1D4E2, 'M', u's'), + (0x1D4E3, 'M', u't'), + (0x1D4E4, 'M', u'u'), + (0x1D4E5, 'M', u'v'), + (0x1D4E6, 'M', u'w'), + (0x1D4E7, 'M', u'x'), + (0x1D4E8, 'M', u'y'), + (0x1D4E9, 'M', u'z'), + (0x1D4EA, 'M', u'a'), + (0x1D4EB, 'M', u'b'), + (0x1D4EC, 'M', u'c'), + (0x1D4ED, 'M', u'd'), + (0x1D4EE, 'M', u'e'), + (0x1D4EF, 'M', u'f'), + (0x1D4F0, 'M', u'g'), + (0x1D4F1, 'M', u'h'), + (0x1D4F2, 'M', u'i'), + (0x1D4F3, 'M', u'j'), + (0x1D4F4, 'M', u'k'), + (0x1D4F5, 'M', u'l'), + (0x1D4F6, 'M', u'm'), + (0x1D4F7, 'M', u'n'), + (0x1D4F8, 'M', u'o'), + (0x1D4F9, 'M', u'p'), + (0x1D4FA, 'M', u'q'), + (0x1D4FB, 'M', u'r'), + (0x1D4FC, 'M', u's'), + (0x1D4FD, 'M', u't'), + (0x1D4FE, 'M', u'u'), + (0x1D4FF, 'M', u'v'), + (0x1D500, 'M', u'w'), + (0x1D501, 'M', u'x'), + (0x1D502, 'M', u'y'), + (0x1D503, 'M', u'z'), + (0x1D504, 'M', u'a'), + (0x1D505, 'M', u'b'), + (0x1D506, 'X'), + (0x1D507, 'M', u'd'), + (0x1D508, 'M', u'e'), + (0x1D509, 'M', u'f'), + (0x1D50A, 'M', u'g'), + (0x1D50B, 'X'), + (0x1D50D, 'M', u'j'), + (0x1D50E, 'M', u'k'), + (0x1D50F, 'M', u'l'), + (0x1D510, 'M', u'm'), + (0x1D511, 'M', u'n'), + (0x1D512, 'M', u'o'), + (0x1D513, 'M', u'p'), + (0x1D514, 'M', u'q'), + (0x1D515, 'X'), + (0x1D516, 'M', u's'), + (0x1D517, 'M', u't'), + (0x1D518, 'M', u'u'), + (0x1D519, 'M', u'v'), + (0x1D51A, 'M', u'w'), + (0x1D51B, 'M', u'x'), + (0x1D51C, 'M', u'y'), + (0x1D51D, 'X'), + (0x1D51E, 'M', u'a'), + (0x1D51F, 'M', u'b'), + (0x1D520, 'M', u'c'), + (0x1D521, 'M', u'd'), + (0x1D522, 'M', u'e'), + (0x1D523, 'M', u'f'), + (0x1D524, 'M', u'g'), + (0x1D525, 'M', u'h'), + (0x1D526, 'M', u'i'), + (0x1D527, 'M', u'j'), + (0x1D528, 'M', u'k'), + ] + +def _seg_61(): + return [ + (0x1D529, 'M', u'l'), + (0x1D52A, 'M', u'm'), + (0x1D52B, 'M', u'n'), + (0x1D52C, 'M', u'o'), + (0x1D52D, 'M', u'p'), + (0x1D52E, 'M', u'q'), + (0x1D52F, 'M', u'r'), + (0x1D530, 'M', u's'), + (0x1D531, 'M', u't'), + (0x1D532, 'M', u'u'), + (0x1D533, 'M', u'v'), + (0x1D534, 'M', u'w'), + (0x1D535, 'M', u'x'), + (0x1D536, 'M', u'y'), + (0x1D537, 'M', u'z'), + (0x1D538, 'M', u'a'), + (0x1D539, 'M', u'b'), + (0x1D53A, 'X'), + (0x1D53B, 'M', u'd'), + (0x1D53C, 'M', u'e'), + (0x1D53D, 'M', u'f'), + (0x1D53E, 'M', u'g'), + (0x1D53F, 'X'), + (0x1D540, 'M', u'i'), + (0x1D541, 'M', u'j'), + (0x1D542, 'M', u'k'), + (0x1D543, 'M', u'l'), + (0x1D544, 'M', u'm'), + (0x1D545, 'X'), + (0x1D546, 'M', u'o'), + (0x1D547, 'X'), + (0x1D54A, 'M', u's'), + (0x1D54B, 'M', u't'), + (0x1D54C, 'M', u'u'), + (0x1D54D, 'M', u'v'), + (0x1D54E, 'M', u'w'), + (0x1D54F, 'M', u'x'), + (0x1D550, 'M', u'y'), + (0x1D551, 'X'), + (0x1D552, 'M', u'a'), + (0x1D553, 'M', u'b'), + (0x1D554, 'M', u'c'), + (0x1D555, 'M', u'd'), + (0x1D556, 'M', u'e'), + (0x1D557, 'M', u'f'), + (0x1D558, 'M', u'g'), + (0x1D559, 'M', u'h'), + (0x1D55A, 'M', u'i'), + (0x1D55B, 'M', u'j'), + (0x1D55C, 'M', u'k'), + (0x1D55D, 'M', u'l'), + (0x1D55E, 'M', u'm'), + (0x1D55F, 'M', u'n'), + (0x1D560, 'M', u'o'), + (0x1D561, 'M', u'p'), + (0x1D562, 'M', u'q'), + (0x1D563, 'M', u'r'), + (0x1D564, 'M', u's'), + (0x1D565, 'M', u't'), + (0x1D566, 'M', u'u'), + (0x1D567, 'M', u'v'), + (0x1D568, 'M', u'w'), + (0x1D569, 'M', u'x'), + (0x1D56A, 'M', u'y'), + (0x1D56B, 'M', u'z'), + (0x1D56C, 'M', u'a'), + (0x1D56D, 'M', u'b'), + (0x1D56E, 'M', u'c'), + (0x1D56F, 'M', u'd'), + (0x1D570, 'M', u'e'), + (0x1D571, 'M', u'f'), + (0x1D572, 'M', u'g'), + (0x1D573, 'M', u'h'), + (0x1D574, 'M', u'i'), + (0x1D575, 'M', u'j'), + (0x1D576, 'M', u'k'), + (0x1D577, 'M', u'l'), + (0x1D578, 'M', u'm'), + (0x1D579, 'M', u'n'), + (0x1D57A, 'M', u'o'), + (0x1D57B, 'M', u'p'), + (0x1D57C, 'M', u'q'), + (0x1D57D, 'M', u'r'), + (0x1D57E, 'M', u's'), + (0x1D57F, 'M', u't'), + (0x1D580, 'M', u'u'), + (0x1D581, 'M', u'v'), + (0x1D582, 'M', u'w'), + (0x1D583, 'M', u'x'), + (0x1D584, 'M', u'y'), + (0x1D585, 'M', u'z'), + (0x1D586, 'M', u'a'), + (0x1D587, 'M', u'b'), + (0x1D588, 'M', u'c'), + (0x1D589, 'M', u'd'), + (0x1D58A, 'M', u'e'), + (0x1D58B, 'M', u'f'), + (0x1D58C, 'M', u'g'), + (0x1D58D, 'M', u'h'), + (0x1D58E, 'M', u'i'), + ] + +def _seg_62(): + return [ + (0x1D58F, 'M', u'j'), + (0x1D590, 'M', u'k'), + (0x1D591, 'M', u'l'), + (0x1D592, 'M', u'm'), + (0x1D593, 'M', u'n'), + (0x1D594, 'M', u'o'), + (0x1D595, 'M', u'p'), + (0x1D596, 'M', u'q'), + (0x1D597, 'M', u'r'), + (0x1D598, 'M', u's'), + (0x1D599, 'M', u't'), + (0x1D59A, 'M', u'u'), + (0x1D59B, 'M', u'v'), + (0x1D59C, 'M', u'w'), + (0x1D59D, 'M', u'x'), + (0x1D59E, 'M', u'y'), + (0x1D59F, 'M', u'z'), + (0x1D5A0, 'M', u'a'), + (0x1D5A1, 'M', u'b'), + (0x1D5A2, 'M', u'c'), + (0x1D5A3, 'M', u'd'), + (0x1D5A4, 'M', u'e'), + (0x1D5A5, 'M', u'f'), + (0x1D5A6, 'M', u'g'), + (0x1D5A7, 'M', u'h'), + (0x1D5A8, 'M', u'i'), + (0x1D5A9, 'M', u'j'), + (0x1D5AA, 'M', u'k'), + (0x1D5AB, 'M', u'l'), + (0x1D5AC, 'M', u'm'), + (0x1D5AD, 'M', u'n'), + (0x1D5AE, 'M', u'o'), + (0x1D5AF, 'M', u'p'), + (0x1D5B0, 'M', u'q'), + (0x1D5B1, 'M', u'r'), + (0x1D5B2, 'M', u's'), + (0x1D5B3, 'M', u't'), + (0x1D5B4, 'M', u'u'), + (0x1D5B5, 'M', u'v'), + (0x1D5B6, 'M', u'w'), + (0x1D5B7, 'M', u'x'), + (0x1D5B8, 'M', u'y'), + (0x1D5B9, 'M', u'z'), + (0x1D5BA, 'M', u'a'), + (0x1D5BB, 'M', u'b'), + (0x1D5BC, 'M', u'c'), + (0x1D5BD, 'M', u'd'), + (0x1D5BE, 'M', u'e'), + (0x1D5BF, 'M', u'f'), + (0x1D5C0, 'M', u'g'), + (0x1D5C1, 'M', u'h'), + (0x1D5C2, 'M', u'i'), + (0x1D5C3, 'M', u'j'), + (0x1D5C4, 'M', u'k'), + (0x1D5C5, 'M', u'l'), + (0x1D5C6, 'M', u'm'), + (0x1D5C7, 'M', u'n'), + (0x1D5C8, 'M', u'o'), + (0x1D5C9, 'M', u'p'), + (0x1D5CA, 'M', u'q'), + (0x1D5CB, 'M', u'r'), + (0x1D5CC, 'M', u's'), + (0x1D5CD, 'M', u't'), + (0x1D5CE, 'M', u'u'), + (0x1D5CF, 'M', u'v'), + (0x1D5D0, 'M', u'w'), + (0x1D5D1, 'M', u'x'), + (0x1D5D2, 'M', u'y'), + (0x1D5D3, 'M', u'z'), + (0x1D5D4, 'M', u'a'), + (0x1D5D5, 'M', u'b'), + (0x1D5D6, 'M', u'c'), + (0x1D5D7, 'M', u'd'), + (0x1D5D8, 'M', u'e'), + (0x1D5D9, 'M', u'f'), + (0x1D5DA, 'M', u'g'), + (0x1D5DB, 'M', u'h'), + (0x1D5DC, 'M', u'i'), + (0x1D5DD, 'M', u'j'), + (0x1D5DE, 'M', u'k'), + (0x1D5DF, 'M', u'l'), + (0x1D5E0, 'M', u'm'), + (0x1D5E1, 'M', u'n'), + (0x1D5E2, 'M', u'o'), + (0x1D5E3, 'M', u'p'), + (0x1D5E4, 'M', u'q'), + (0x1D5E5, 'M', u'r'), + (0x1D5E6, 'M', u's'), + (0x1D5E7, 'M', u't'), + (0x1D5E8, 'M', u'u'), + (0x1D5E9, 'M', u'v'), + (0x1D5EA, 'M', u'w'), + (0x1D5EB, 'M', u'x'), + (0x1D5EC, 'M', u'y'), + (0x1D5ED, 'M', u'z'), + (0x1D5EE, 'M', u'a'), + (0x1D5EF, 'M', u'b'), + (0x1D5F0, 'M', u'c'), + (0x1D5F1, 'M', u'd'), + (0x1D5F2, 'M', u'e'), + ] + +def _seg_63(): + return [ + (0x1D5F3, 'M', u'f'), + (0x1D5F4, 'M', u'g'), + (0x1D5F5, 'M', u'h'), + (0x1D5F6, 'M', u'i'), + (0x1D5F7, 'M', u'j'), + (0x1D5F8, 'M', u'k'), + (0x1D5F9, 'M', u'l'), + (0x1D5FA, 'M', u'm'), + (0x1D5FB, 'M', u'n'), + (0x1D5FC, 'M', u'o'), + (0x1D5FD, 'M', u'p'), + (0x1D5FE, 'M', u'q'), + (0x1D5FF, 'M', u'r'), + (0x1D600, 'M', u's'), + (0x1D601, 'M', u't'), + (0x1D602, 'M', u'u'), + (0x1D603, 'M', u'v'), + (0x1D604, 'M', u'w'), + (0x1D605, 'M', u'x'), + (0x1D606, 'M', u'y'), + (0x1D607, 'M', u'z'), + (0x1D608, 'M', u'a'), + (0x1D609, 'M', u'b'), + (0x1D60A, 'M', u'c'), + (0x1D60B, 'M', u'd'), + (0x1D60C, 'M', u'e'), + (0x1D60D, 'M', u'f'), + (0x1D60E, 'M', u'g'), + (0x1D60F, 'M', u'h'), + (0x1D610, 'M', u'i'), + (0x1D611, 'M', u'j'), + (0x1D612, 'M', u'k'), + (0x1D613, 'M', u'l'), + (0x1D614, 'M', u'm'), + (0x1D615, 'M', u'n'), + (0x1D616, 'M', u'o'), + (0x1D617, 'M', u'p'), + (0x1D618, 'M', u'q'), + (0x1D619, 'M', u'r'), + (0x1D61A, 'M', u's'), + (0x1D61B, 'M', u't'), + (0x1D61C, 'M', u'u'), + (0x1D61D, 'M', u'v'), + (0x1D61E, 'M', u'w'), + (0x1D61F, 'M', u'x'), + (0x1D620, 'M', u'y'), + (0x1D621, 'M', u'z'), + (0x1D622, 'M', u'a'), + (0x1D623, 'M', u'b'), + (0x1D624, 'M', u'c'), + (0x1D625, 'M', u'd'), + (0x1D626, 'M', u'e'), + (0x1D627, 'M', u'f'), + (0x1D628, 'M', u'g'), + (0x1D629, 'M', u'h'), + (0x1D62A, 'M', u'i'), + (0x1D62B, 'M', u'j'), + (0x1D62C, 'M', u'k'), + (0x1D62D, 'M', u'l'), + (0x1D62E, 'M', u'm'), + (0x1D62F, 'M', u'n'), + (0x1D630, 'M', u'o'), + (0x1D631, 'M', u'p'), + (0x1D632, 'M', u'q'), + (0x1D633, 'M', u'r'), + (0x1D634, 'M', u's'), + (0x1D635, 'M', u't'), + (0x1D636, 'M', u'u'), + (0x1D637, 'M', u'v'), + (0x1D638, 'M', u'w'), + (0x1D639, 'M', u'x'), + (0x1D63A, 'M', u'y'), + (0x1D63B, 'M', u'z'), + (0x1D63C, 'M', u'a'), + (0x1D63D, 'M', u'b'), + (0x1D63E, 'M', u'c'), + (0x1D63F, 'M', u'd'), + (0x1D640, 'M', u'e'), + (0x1D641, 'M', u'f'), + (0x1D642, 'M', u'g'), + (0x1D643, 'M', u'h'), + (0x1D644, 'M', u'i'), + (0x1D645, 'M', u'j'), + (0x1D646, 'M', u'k'), + (0x1D647, 'M', u'l'), + (0x1D648, 'M', u'm'), + (0x1D649, 'M', u'n'), + (0x1D64A, 'M', u'o'), + (0x1D64B, 'M', u'p'), + (0x1D64C, 'M', u'q'), + (0x1D64D, 'M', u'r'), + (0x1D64E, 'M', u's'), + (0x1D64F, 'M', u't'), + (0x1D650, 'M', u'u'), + (0x1D651, 'M', u'v'), + (0x1D652, 'M', u'w'), + (0x1D653, 'M', u'x'), + (0x1D654, 'M', u'y'), + (0x1D655, 'M', u'z'), + (0x1D656, 'M', u'a'), + ] + +def _seg_64(): + return [ + (0x1D657, 'M', u'b'), + (0x1D658, 'M', u'c'), + (0x1D659, 'M', u'd'), + (0x1D65A, 'M', u'e'), + (0x1D65B, 'M', u'f'), + (0x1D65C, 'M', u'g'), + (0x1D65D, 'M', u'h'), + (0x1D65E, 'M', u'i'), + (0x1D65F, 'M', u'j'), + (0x1D660, 'M', u'k'), + (0x1D661, 'M', u'l'), + (0x1D662, 'M', u'm'), + (0x1D663, 'M', u'n'), + (0x1D664, 'M', u'o'), + (0x1D665, 'M', u'p'), + (0x1D666, 'M', u'q'), + (0x1D667, 'M', u'r'), + (0x1D668, 'M', u's'), + (0x1D669, 'M', u't'), + (0x1D66A, 'M', u'u'), + (0x1D66B, 'M', u'v'), + (0x1D66C, 'M', u'w'), + (0x1D66D, 'M', u'x'), + (0x1D66E, 'M', u'y'), + (0x1D66F, 'M', u'z'), + (0x1D670, 'M', u'a'), + (0x1D671, 'M', u'b'), + (0x1D672, 'M', u'c'), + (0x1D673, 'M', u'd'), + (0x1D674, 'M', u'e'), + (0x1D675, 'M', u'f'), + (0x1D676, 'M', u'g'), + (0x1D677, 'M', u'h'), + (0x1D678, 'M', u'i'), + (0x1D679, 'M', u'j'), + (0x1D67A, 'M', u'k'), + (0x1D67B, 'M', u'l'), + (0x1D67C, 'M', u'm'), + (0x1D67D, 'M', u'n'), + (0x1D67E, 'M', u'o'), + (0x1D67F, 'M', u'p'), + (0x1D680, 'M', u'q'), + (0x1D681, 'M', u'r'), + (0x1D682, 'M', u's'), + (0x1D683, 'M', u't'), + (0x1D684, 'M', u'u'), + (0x1D685, 'M', u'v'), + (0x1D686, 'M', u'w'), + (0x1D687, 'M', u'x'), + (0x1D688, 'M', u'y'), + (0x1D689, 'M', u'z'), + (0x1D68A, 'M', u'a'), + (0x1D68B, 'M', u'b'), + (0x1D68C, 'M', u'c'), + (0x1D68D, 'M', u'd'), + (0x1D68E, 'M', u'e'), + (0x1D68F, 'M', u'f'), + (0x1D690, 'M', u'g'), + (0x1D691, 'M', u'h'), + (0x1D692, 'M', u'i'), + (0x1D693, 'M', u'j'), + (0x1D694, 'M', u'k'), + (0x1D695, 'M', u'l'), + (0x1D696, 'M', u'm'), + (0x1D697, 'M', u'n'), + (0x1D698, 'M', u'o'), + (0x1D699, 'M', u'p'), + (0x1D69A, 'M', u'q'), + (0x1D69B, 'M', u'r'), + (0x1D69C, 'M', u's'), + (0x1D69D, 'M', u't'), + (0x1D69E, 'M', u'u'), + (0x1D69F, 'M', u'v'), + (0x1D6A0, 'M', u'w'), + (0x1D6A1, 'M', u'x'), + (0x1D6A2, 'M', u'y'), + (0x1D6A3, 'M', u'z'), + (0x1D6A4, 'M', u'ı'), + (0x1D6A5, 'M', u'ȷ'), + (0x1D6A6, 'X'), + (0x1D6A8, 'M', u'α'), + (0x1D6A9, 'M', u'β'), + (0x1D6AA, 'M', u'γ'), + (0x1D6AB, 'M', u'δ'), + (0x1D6AC, 'M', u'ε'), + (0x1D6AD, 'M', u'ζ'), + (0x1D6AE, 'M', u'η'), + (0x1D6AF, 'M', u'θ'), + (0x1D6B0, 'M', u'ι'), + (0x1D6B1, 'M', u'κ'), + (0x1D6B2, 'M', u'λ'), + (0x1D6B3, 'M', u'μ'), + (0x1D6B4, 'M', u'ν'), + (0x1D6B5, 'M', u'ξ'), + (0x1D6B6, 'M', u'ο'), + (0x1D6B7, 'M', u'π'), + (0x1D6B8, 'M', u'ρ'), + (0x1D6B9, 'M', u'θ'), + (0x1D6BA, 'M', u'σ'), + (0x1D6BB, 'M', u'τ'), + ] + +def _seg_65(): + return [ + (0x1D6BC, 'M', u'υ'), + (0x1D6BD, 'M', u'φ'), + (0x1D6BE, 'M', u'χ'), + (0x1D6BF, 'M', u'ψ'), + (0x1D6C0, 'M', u'ω'), + (0x1D6C1, 'M', u'∇'), + (0x1D6C2, 'M', u'α'), + (0x1D6C3, 'M', u'β'), + (0x1D6C4, 'M', u'γ'), + (0x1D6C5, 'M', u'δ'), + (0x1D6C6, 'M', u'ε'), + (0x1D6C7, 'M', u'ζ'), + (0x1D6C8, 'M', u'η'), + (0x1D6C9, 'M', u'θ'), + (0x1D6CA, 'M', u'ι'), + (0x1D6CB, 'M', u'κ'), + (0x1D6CC, 'M', u'λ'), + (0x1D6CD, 'M', u'μ'), + (0x1D6CE, 'M', u'ν'), + (0x1D6CF, 'M', u'ξ'), + (0x1D6D0, 'M', u'ο'), + (0x1D6D1, 'M', u'π'), + (0x1D6D2, 'M', u'ρ'), + (0x1D6D3, 'M', u'σ'), + (0x1D6D5, 'M', u'τ'), + (0x1D6D6, 'M', u'υ'), + (0x1D6D7, 'M', u'φ'), + (0x1D6D8, 'M', u'χ'), + (0x1D6D9, 'M', u'ψ'), + (0x1D6DA, 'M', u'ω'), + (0x1D6DB, 'M', u'∂'), + (0x1D6DC, 'M', u'ε'), + (0x1D6DD, 'M', u'θ'), + (0x1D6DE, 'M', u'κ'), + (0x1D6DF, 'M', u'φ'), + (0x1D6E0, 'M', u'ρ'), + (0x1D6E1, 'M', u'π'), + (0x1D6E2, 'M', u'α'), + (0x1D6E3, 'M', u'β'), + (0x1D6E4, 'M', u'γ'), + (0x1D6E5, 'M', u'δ'), + (0x1D6E6, 'M', u'ε'), + (0x1D6E7, 'M', u'ζ'), + (0x1D6E8, 'M', u'η'), + (0x1D6E9, 'M', u'θ'), + (0x1D6EA, 'M', u'ι'), + (0x1D6EB, 'M', u'κ'), + (0x1D6EC, 'M', u'λ'), + (0x1D6ED, 'M', u'μ'), + (0x1D6EE, 'M', u'ν'), + (0x1D6EF, 'M', u'ξ'), + (0x1D6F0, 'M', u'ο'), + (0x1D6F1, 'M', u'π'), + (0x1D6F2, 'M', u'ρ'), + (0x1D6F3, 'M', u'θ'), + (0x1D6F4, 'M', u'σ'), + (0x1D6F5, 'M', u'τ'), + (0x1D6F6, 'M', u'υ'), + (0x1D6F7, 'M', u'φ'), + (0x1D6F8, 'M', u'χ'), + (0x1D6F9, 'M', u'ψ'), + (0x1D6FA, 'M', u'ω'), + (0x1D6FB, 'M', u'∇'), + (0x1D6FC, 'M', u'α'), + (0x1D6FD, 'M', u'β'), + (0x1D6FE, 'M', u'γ'), + (0x1D6FF, 'M', u'δ'), + (0x1D700, 'M', u'ε'), + (0x1D701, 'M', u'ζ'), + (0x1D702, 'M', u'η'), + (0x1D703, 'M', u'θ'), + (0x1D704, 'M', u'ι'), + (0x1D705, 'M', u'κ'), + (0x1D706, 'M', u'λ'), + (0x1D707, 'M', u'μ'), + (0x1D708, 'M', u'ν'), + (0x1D709, 'M', u'ξ'), + (0x1D70A, 'M', u'ο'), + (0x1D70B, 'M', u'π'), + (0x1D70C, 'M', u'ρ'), + (0x1D70D, 'M', u'σ'), + (0x1D70F, 'M', u'τ'), + (0x1D710, 'M', u'υ'), + (0x1D711, 'M', u'φ'), + (0x1D712, 'M', u'χ'), + (0x1D713, 'M', u'ψ'), + (0x1D714, 'M', u'ω'), + (0x1D715, 'M', u'∂'), + (0x1D716, 'M', u'ε'), + (0x1D717, 'M', u'θ'), + (0x1D718, 'M', u'κ'), + (0x1D719, 'M', u'φ'), + (0x1D71A, 'M', u'ρ'), + (0x1D71B, 'M', u'π'), + (0x1D71C, 'M', u'α'), + (0x1D71D, 'M', u'β'), + (0x1D71E, 'M', u'γ'), + (0x1D71F, 'M', u'δ'), + (0x1D720, 'M', u'ε'), + (0x1D721, 'M', u'ζ'), + ] + +def _seg_66(): + return [ + (0x1D722, 'M', u'η'), + (0x1D723, 'M', u'θ'), + (0x1D724, 'M', u'ι'), + (0x1D725, 'M', u'κ'), + (0x1D726, 'M', u'λ'), + (0x1D727, 'M', u'μ'), + (0x1D728, 'M', u'ν'), + (0x1D729, 'M', u'ξ'), + (0x1D72A, 'M', u'ο'), + (0x1D72B, 'M', u'π'), + (0x1D72C, 'M', u'ρ'), + (0x1D72D, 'M', u'θ'), + (0x1D72E, 'M', u'σ'), + (0x1D72F, 'M', u'τ'), + (0x1D730, 'M', u'υ'), + (0x1D731, 'M', u'φ'), + (0x1D732, 'M', u'χ'), + (0x1D733, 'M', u'ψ'), + (0x1D734, 'M', u'ω'), + (0x1D735, 'M', u'∇'), + (0x1D736, 'M', u'α'), + (0x1D737, 'M', u'β'), + (0x1D738, 'M', u'γ'), + (0x1D739, 'M', u'δ'), + (0x1D73A, 'M', u'ε'), + (0x1D73B, 'M', u'ζ'), + (0x1D73C, 'M', u'η'), + (0x1D73D, 'M', u'θ'), + (0x1D73E, 'M', u'ι'), + (0x1D73F, 'M', u'κ'), + (0x1D740, 'M', u'λ'), + (0x1D741, 'M', u'μ'), + (0x1D742, 'M', u'ν'), + (0x1D743, 'M', u'ξ'), + (0x1D744, 'M', u'ο'), + (0x1D745, 'M', u'π'), + (0x1D746, 'M', u'ρ'), + (0x1D747, 'M', u'σ'), + (0x1D749, 'M', u'τ'), + (0x1D74A, 'M', u'υ'), + (0x1D74B, 'M', u'φ'), + (0x1D74C, 'M', u'χ'), + (0x1D74D, 'M', u'ψ'), + (0x1D74E, 'M', u'ω'), + (0x1D74F, 'M', u'∂'), + (0x1D750, 'M', u'ε'), + (0x1D751, 'M', u'θ'), + (0x1D752, 'M', u'κ'), + (0x1D753, 'M', u'φ'), + (0x1D754, 'M', u'ρ'), + (0x1D755, 'M', u'π'), + (0x1D756, 'M', u'α'), + (0x1D757, 'M', u'β'), + (0x1D758, 'M', u'γ'), + (0x1D759, 'M', u'δ'), + (0x1D75A, 'M', u'ε'), + (0x1D75B, 'M', u'ζ'), + (0x1D75C, 'M', u'η'), + (0x1D75D, 'M', u'θ'), + (0x1D75E, 'M', u'ι'), + (0x1D75F, 'M', u'κ'), + (0x1D760, 'M', u'λ'), + (0x1D761, 'M', u'μ'), + (0x1D762, 'M', u'ν'), + (0x1D763, 'M', u'ξ'), + (0x1D764, 'M', u'ο'), + (0x1D765, 'M', u'π'), + (0x1D766, 'M', u'ρ'), + (0x1D767, 'M', u'θ'), + (0x1D768, 'M', u'σ'), + (0x1D769, 'M', u'τ'), + (0x1D76A, 'M', u'υ'), + (0x1D76B, 'M', u'φ'), + (0x1D76C, 'M', u'χ'), + (0x1D76D, 'M', u'ψ'), + (0x1D76E, 'M', u'ω'), + (0x1D76F, 'M', u'∇'), + (0x1D770, 'M', u'α'), + (0x1D771, 'M', u'β'), + (0x1D772, 'M', u'γ'), + (0x1D773, 'M', u'δ'), + (0x1D774, 'M', u'ε'), + (0x1D775, 'M', u'ζ'), + (0x1D776, 'M', u'η'), + (0x1D777, 'M', u'θ'), + (0x1D778, 'M', u'ι'), + (0x1D779, 'M', u'κ'), + (0x1D77A, 'M', u'λ'), + (0x1D77B, 'M', u'μ'), + (0x1D77C, 'M', u'ν'), + (0x1D77D, 'M', u'ξ'), + (0x1D77E, 'M', u'ο'), + (0x1D77F, 'M', u'π'), + (0x1D780, 'M', u'ρ'), + (0x1D781, 'M', u'σ'), + (0x1D783, 'M', u'τ'), + (0x1D784, 'M', u'υ'), + (0x1D785, 'M', u'φ'), + (0x1D786, 'M', u'χ'), + (0x1D787, 'M', u'ψ'), + ] + +def _seg_67(): + return [ + (0x1D788, 'M', u'ω'), + (0x1D789, 'M', u'∂'), + (0x1D78A, 'M', u'ε'), + (0x1D78B, 'M', u'θ'), + (0x1D78C, 'M', u'κ'), + (0x1D78D, 'M', u'φ'), + (0x1D78E, 'M', u'ρ'), + (0x1D78F, 'M', u'π'), + (0x1D790, 'M', u'α'), + (0x1D791, 'M', u'β'), + (0x1D792, 'M', u'γ'), + (0x1D793, 'M', u'δ'), + (0x1D794, 'M', u'ε'), + (0x1D795, 'M', u'ζ'), + (0x1D796, 'M', u'η'), + (0x1D797, 'M', u'θ'), + (0x1D798, 'M', u'ι'), + (0x1D799, 'M', u'κ'), + (0x1D79A, 'M', u'λ'), + (0x1D79B, 'M', u'μ'), + (0x1D79C, 'M', u'ν'), + (0x1D79D, 'M', u'ξ'), + (0x1D79E, 'M', u'ο'), + (0x1D79F, 'M', u'π'), + (0x1D7A0, 'M', u'ρ'), + (0x1D7A1, 'M', u'θ'), + (0x1D7A2, 'M', u'σ'), + (0x1D7A3, 'M', u'τ'), + (0x1D7A4, 'M', u'υ'), + (0x1D7A5, 'M', u'φ'), + (0x1D7A6, 'M', u'χ'), + (0x1D7A7, 'M', u'ψ'), + (0x1D7A8, 'M', u'ω'), + (0x1D7A9, 'M', u'∇'), + (0x1D7AA, 'M', u'α'), + (0x1D7AB, 'M', u'β'), + (0x1D7AC, 'M', u'γ'), + (0x1D7AD, 'M', u'δ'), + (0x1D7AE, 'M', u'ε'), + (0x1D7AF, 'M', u'ζ'), + (0x1D7B0, 'M', u'η'), + (0x1D7B1, 'M', u'θ'), + (0x1D7B2, 'M', u'ι'), + (0x1D7B3, 'M', u'κ'), + (0x1D7B4, 'M', u'λ'), + (0x1D7B5, 'M', u'μ'), + (0x1D7B6, 'M', u'ν'), + (0x1D7B7, 'M', u'ξ'), + (0x1D7B8, 'M', u'ο'), + (0x1D7B9, 'M', u'π'), + (0x1D7BA, 'M', u'ρ'), + (0x1D7BB, 'M', u'σ'), + (0x1D7BD, 'M', u'τ'), + (0x1D7BE, 'M', u'υ'), + (0x1D7BF, 'M', u'φ'), + (0x1D7C0, 'M', u'χ'), + (0x1D7C1, 'M', u'ψ'), + (0x1D7C2, 'M', u'ω'), + (0x1D7C3, 'M', u'∂'), + (0x1D7C4, 'M', u'ε'), + (0x1D7C5, 'M', u'θ'), + (0x1D7C6, 'M', u'κ'), + (0x1D7C7, 'M', u'φ'), + (0x1D7C8, 'M', u'ρ'), + (0x1D7C9, 'M', u'π'), + (0x1D7CA, 'M', u'ϝ'), + (0x1D7CC, 'X'), + (0x1D7CE, 'M', u'0'), + (0x1D7CF, 'M', u'1'), + (0x1D7D0, 'M', u'2'), + (0x1D7D1, 'M', u'3'), + (0x1D7D2, 'M', u'4'), + (0x1D7D3, 'M', u'5'), + (0x1D7D4, 'M', u'6'), + (0x1D7D5, 'M', u'7'), + (0x1D7D6, 'M', u'8'), + (0x1D7D7, 'M', u'9'), + (0x1D7D8, 'M', u'0'), + (0x1D7D9, 'M', u'1'), + (0x1D7DA, 'M', u'2'), + (0x1D7DB, 'M', u'3'), + (0x1D7DC, 'M', u'4'), + (0x1D7DD, 'M', u'5'), + (0x1D7DE, 'M', u'6'), + (0x1D7DF, 'M', u'7'), + (0x1D7E0, 'M', u'8'), + (0x1D7E1, 'M', u'9'), + (0x1D7E2, 'M', u'0'), + (0x1D7E3, 'M', u'1'), + (0x1D7E4, 'M', u'2'), + (0x1D7E5, 'M', u'3'), + (0x1D7E6, 'M', u'4'), + (0x1D7E7, 'M', u'5'), + (0x1D7E8, 'M', u'6'), + (0x1D7E9, 'M', u'7'), + (0x1D7EA, 'M', u'8'), + (0x1D7EB, 'M', u'9'), + (0x1D7EC, 'M', u'0'), + (0x1D7ED, 'M', u'1'), + (0x1D7EE, 'M', u'2'), + ] + +def _seg_68(): + return [ + (0x1D7EF, 'M', u'3'), + (0x1D7F0, 'M', u'4'), + (0x1D7F1, 'M', u'5'), + (0x1D7F2, 'M', u'6'), + (0x1D7F3, 'M', u'7'), + (0x1D7F4, 'M', u'8'), + (0x1D7F5, 'M', u'9'), + (0x1D7F6, 'M', u'0'), + (0x1D7F7, 'M', u'1'), + (0x1D7F8, 'M', u'2'), + (0x1D7F9, 'M', u'3'), + (0x1D7FA, 'M', u'4'), + (0x1D7FB, 'M', u'5'), + (0x1D7FC, 'M', u'6'), + (0x1D7FD, 'M', u'7'), + (0x1D7FE, 'M', u'8'), + (0x1D7FF, 'M', u'9'), + (0x1D800, 'V'), + (0x1DA8C, 'X'), + (0x1DA9B, 'V'), + (0x1DAA0, 'X'), + (0x1DAA1, 'V'), + (0x1DAB0, 'X'), + (0x1E000, 'V'), + (0x1E007, 'X'), + (0x1E008, 'V'), + (0x1E019, 'X'), + (0x1E01B, 'V'), + (0x1E022, 'X'), + (0x1E023, 'V'), + (0x1E025, 'X'), + (0x1E026, 'V'), + (0x1E02B, 'X'), + (0x1E800, 'V'), + (0x1E8C5, 'X'), + (0x1E8C7, 'V'), + (0x1E8D7, 'X'), + (0x1E900, 'M', u'𞤢'), + (0x1E901, 'M', u'𞤣'), + (0x1E902, 'M', u'𞤤'), + (0x1E903, 'M', u'𞤥'), + (0x1E904, 'M', u'𞤦'), + (0x1E905, 'M', u'𞤧'), + (0x1E906, 'M', u'𞤨'), + (0x1E907, 'M', u'𞤩'), + (0x1E908, 'M', u'𞤪'), + (0x1E909, 'M', u'𞤫'), + (0x1E90A, 'M', u'𞤬'), + (0x1E90B, 'M', u'𞤭'), + (0x1E90C, 'M', u'𞤮'), + (0x1E90D, 'M', u'𞤯'), + (0x1E90E, 'M', u'𞤰'), + (0x1E90F, 'M', u'𞤱'), + (0x1E910, 'M', u'𞤲'), + (0x1E911, 'M', u'𞤳'), + (0x1E912, 'M', u'𞤴'), + (0x1E913, 'M', u'𞤵'), + (0x1E914, 'M', u'𞤶'), + (0x1E915, 'M', u'𞤷'), + (0x1E916, 'M', u'𞤸'), + (0x1E917, 'M', u'𞤹'), + (0x1E918, 'M', u'𞤺'), + (0x1E919, 'M', u'𞤻'), + (0x1E91A, 'M', u'𞤼'), + (0x1E91B, 'M', u'𞤽'), + (0x1E91C, 'M', u'𞤾'), + (0x1E91D, 'M', u'𞤿'), + (0x1E91E, 'M', u'𞥀'), + (0x1E91F, 'M', u'𞥁'), + (0x1E920, 'M', u'𞥂'), + (0x1E921, 'M', u'𞥃'), + (0x1E922, 'V'), + (0x1E94B, 'X'), + (0x1E950, 'V'), + (0x1E95A, 'X'), + (0x1E95E, 'V'), + (0x1E960, 'X'), + (0x1EC71, 'V'), + (0x1ECB5, 'X'), + (0x1EE00, 'M', u'ا'), + (0x1EE01, 'M', u'ب'), + (0x1EE02, 'M', u'ج'), + (0x1EE03, 'M', u'د'), + (0x1EE04, 'X'), + (0x1EE05, 'M', u'و'), + (0x1EE06, 'M', u'ز'), + (0x1EE07, 'M', u'ح'), + (0x1EE08, 'M', u'ط'), + (0x1EE09, 'M', u'ي'), + (0x1EE0A, 'M', u'ك'), + (0x1EE0B, 'M', u'ل'), + (0x1EE0C, 'M', u'م'), + (0x1EE0D, 'M', u'ن'), + (0x1EE0E, 'M', u'س'), + (0x1EE0F, 'M', u'ع'), + (0x1EE10, 'M', u'ف'), + (0x1EE11, 'M', u'ص'), + (0x1EE12, 'M', u'ق'), + (0x1EE13, 'M', u'ر'), + (0x1EE14, 'M', u'ش'), + ] + +def _seg_69(): + return [ + (0x1EE15, 'M', u'ت'), + (0x1EE16, 'M', u'ث'), + (0x1EE17, 'M', u'خ'), + (0x1EE18, 'M', u'ذ'), + (0x1EE19, 'M', u'ض'), + (0x1EE1A, 'M', u'ظ'), + (0x1EE1B, 'M', u'غ'), + (0x1EE1C, 'M', u'ٮ'), + (0x1EE1D, 'M', u'ں'), + (0x1EE1E, 'M', u'ڡ'), + (0x1EE1F, 'M', u'ٯ'), + (0x1EE20, 'X'), + (0x1EE21, 'M', u'ب'), + (0x1EE22, 'M', u'ج'), + (0x1EE23, 'X'), + (0x1EE24, 'M', u'ه'), + (0x1EE25, 'X'), + (0x1EE27, 'M', u'ح'), + (0x1EE28, 'X'), + (0x1EE29, 'M', u'ي'), + (0x1EE2A, 'M', u'ك'), + (0x1EE2B, 'M', u'ل'), + (0x1EE2C, 'M', u'م'), + (0x1EE2D, 'M', u'ن'), + (0x1EE2E, 'M', u'س'), + (0x1EE2F, 'M', u'ع'), + (0x1EE30, 'M', u'ف'), + (0x1EE31, 'M', u'ص'), + (0x1EE32, 'M', u'ق'), + (0x1EE33, 'X'), + (0x1EE34, 'M', u'ش'), + (0x1EE35, 'M', u'ت'), + (0x1EE36, 'M', u'ث'), + (0x1EE37, 'M', u'خ'), + (0x1EE38, 'X'), + (0x1EE39, 'M', u'ض'), + (0x1EE3A, 'X'), + (0x1EE3B, 'M', u'غ'), + (0x1EE3C, 'X'), + (0x1EE42, 'M', u'ج'), + (0x1EE43, 'X'), + (0x1EE47, 'M', u'ح'), + (0x1EE48, 'X'), + (0x1EE49, 'M', u'ي'), + (0x1EE4A, 'X'), + (0x1EE4B, 'M', u'ل'), + (0x1EE4C, 'X'), + (0x1EE4D, 'M', u'ن'), + (0x1EE4E, 'M', u'س'), + (0x1EE4F, 'M', u'ع'), + (0x1EE50, 'X'), + (0x1EE51, 'M', u'ص'), + (0x1EE52, 'M', u'ق'), + (0x1EE53, 'X'), + (0x1EE54, 'M', u'ش'), + (0x1EE55, 'X'), + (0x1EE57, 'M', u'خ'), + (0x1EE58, 'X'), + (0x1EE59, 'M', u'ض'), + (0x1EE5A, 'X'), + (0x1EE5B, 'M', u'غ'), + (0x1EE5C, 'X'), + (0x1EE5D, 'M', u'ں'), + (0x1EE5E, 'X'), + (0x1EE5F, 'M', u'ٯ'), + (0x1EE60, 'X'), + (0x1EE61, 'M', u'ب'), + (0x1EE62, 'M', u'ج'), + (0x1EE63, 'X'), + (0x1EE64, 'M', u'ه'), + (0x1EE65, 'X'), + (0x1EE67, 'M', u'ح'), + (0x1EE68, 'M', u'ط'), + (0x1EE69, 'M', u'ي'), + (0x1EE6A, 'M', u'ك'), + (0x1EE6B, 'X'), + (0x1EE6C, 'M', u'م'), + (0x1EE6D, 'M', u'ن'), + (0x1EE6E, 'M', u'س'), + (0x1EE6F, 'M', u'ع'), + (0x1EE70, 'M', u'ف'), + (0x1EE71, 'M', u'ص'), + (0x1EE72, 'M', u'ق'), + (0x1EE73, 'X'), + (0x1EE74, 'M', u'ش'), + (0x1EE75, 'M', u'ت'), + (0x1EE76, 'M', u'ث'), + (0x1EE77, 'M', u'خ'), + (0x1EE78, 'X'), + (0x1EE79, 'M', u'ض'), + (0x1EE7A, 'M', u'ظ'), + (0x1EE7B, 'M', u'غ'), + (0x1EE7C, 'M', u'ٮ'), + (0x1EE7D, 'X'), + (0x1EE7E, 'M', u'ڡ'), + (0x1EE7F, 'X'), + (0x1EE80, 'M', u'ا'), + (0x1EE81, 'M', u'ب'), + (0x1EE82, 'M', u'ج'), + (0x1EE83, 'M', u'د'), + ] + +def _seg_70(): + return [ + (0x1EE84, 'M', u'ه'), + (0x1EE85, 'M', u'و'), + (0x1EE86, 'M', u'ز'), + (0x1EE87, 'M', u'ح'), + (0x1EE88, 'M', u'ط'), + (0x1EE89, 'M', u'ي'), + (0x1EE8A, 'X'), + (0x1EE8B, 'M', u'ل'), + (0x1EE8C, 'M', u'م'), + (0x1EE8D, 'M', u'ن'), + (0x1EE8E, 'M', u'س'), + (0x1EE8F, 'M', u'ع'), + (0x1EE90, 'M', u'ف'), + (0x1EE91, 'M', u'ص'), + (0x1EE92, 'M', u'ق'), + (0x1EE93, 'M', u'ر'), + (0x1EE94, 'M', u'ش'), + (0x1EE95, 'M', u'ت'), + (0x1EE96, 'M', u'ث'), + (0x1EE97, 'M', u'خ'), + (0x1EE98, 'M', u'ذ'), + (0x1EE99, 'M', u'ض'), + (0x1EE9A, 'M', u'ظ'), + (0x1EE9B, 'M', u'غ'), + (0x1EE9C, 'X'), + (0x1EEA1, 'M', u'ب'), + (0x1EEA2, 'M', u'ج'), + (0x1EEA3, 'M', u'د'), + (0x1EEA4, 'X'), + (0x1EEA5, 'M', u'و'), + (0x1EEA6, 'M', u'ز'), + (0x1EEA7, 'M', u'ح'), + (0x1EEA8, 'M', u'ط'), + (0x1EEA9, 'M', u'ي'), + (0x1EEAA, 'X'), + (0x1EEAB, 'M', u'ل'), + (0x1EEAC, 'M', u'م'), + (0x1EEAD, 'M', u'ن'), + (0x1EEAE, 'M', u'س'), + (0x1EEAF, 'M', u'ع'), + (0x1EEB0, 'M', u'ف'), + (0x1EEB1, 'M', u'ص'), + (0x1EEB2, 'M', u'ق'), + (0x1EEB3, 'M', u'ر'), + (0x1EEB4, 'M', u'ش'), + (0x1EEB5, 'M', u'ت'), + (0x1EEB6, 'M', u'ث'), + (0x1EEB7, 'M', u'خ'), + (0x1EEB8, 'M', u'ذ'), + (0x1EEB9, 'M', u'ض'), + (0x1EEBA, 'M', u'ظ'), + (0x1EEBB, 'M', u'غ'), + (0x1EEBC, 'X'), + (0x1EEF0, 'V'), + (0x1EEF2, 'X'), + (0x1F000, 'V'), + (0x1F02C, 'X'), + (0x1F030, 'V'), + (0x1F094, 'X'), + (0x1F0A0, 'V'), + (0x1F0AF, 'X'), + (0x1F0B1, 'V'), + (0x1F0C0, 'X'), + (0x1F0C1, 'V'), + (0x1F0D0, 'X'), + (0x1F0D1, 'V'), + (0x1F0F6, 'X'), + (0x1F101, '3', u'0,'), + (0x1F102, '3', u'1,'), + (0x1F103, '3', u'2,'), + (0x1F104, '3', u'3,'), + (0x1F105, '3', u'4,'), + (0x1F106, '3', u'5,'), + (0x1F107, '3', u'6,'), + (0x1F108, '3', u'7,'), + (0x1F109, '3', u'8,'), + (0x1F10A, '3', u'9,'), + (0x1F10B, 'V'), + (0x1F10D, 'X'), + (0x1F110, '3', u'(a)'), + (0x1F111, '3', u'(b)'), + (0x1F112, '3', u'(c)'), + (0x1F113, '3', u'(d)'), + (0x1F114, '3', u'(e)'), + (0x1F115, '3', u'(f)'), + (0x1F116, '3', u'(g)'), + (0x1F117, '3', u'(h)'), + (0x1F118, '3', u'(i)'), + (0x1F119, '3', u'(j)'), + (0x1F11A, '3', u'(k)'), + (0x1F11B, '3', u'(l)'), + (0x1F11C, '3', u'(m)'), + (0x1F11D, '3', u'(n)'), + (0x1F11E, '3', u'(o)'), + (0x1F11F, '3', u'(p)'), + (0x1F120, '3', u'(q)'), + (0x1F121, '3', u'(r)'), + (0x1F122, '3', u'(s)'), + (0x1F123, '3', u'(t)'), + (0x1F124, '3', u'(u)'), + ] + +def _seg_71(): + return [ + (0x1F125, '3', u'(v)'), + (0x1F126, '3', u'(w)'), + (0x1F127, '3', u'(x)'), + (0x1F128, '3', u'(y)'), + (0x1F129, '3', u'(z)'), + (0x1F12A, 'M', u'〔s〕'), + (0x1F12B, 'M', u'c'), + (0x1F12C, 'M', u'r'), + (0x1F12D, 'M', u'cd'), + (0x1F12E, 'M', u'wz'), + (0x1F12F, 'V'), + (0x1F130, 'M', u'a'), + (0x1F131, 'M', u'b'), + (0x1F132, 'M', u'c'), + (0x1F133, 'M', u'd'), + (0x1F134, 'M', u'e'), + (0x1F135, 'M', u'f'), + (0x1F136, 'M', u'g'), + (0x1F137, 'M', u'h'), + (0x1F138, 'M', u'i'), + (0x1F139, 'M', u'j'), + (0x1F13A, 'M', u'k'), + (0x1F13B, 'M', u'l'), + (0x1F13C, 'M', u'm'), + (0x1F13D, 'M', u'n'), + (0x1F13E, 'M', u'o'), + (0x1F13F, 'M', u'p'), + (0x1F140, 'M', u'q'), + (0x1F141, 'M', u'r'), + (0x1F142, 'M', u's'), + (0x1F143, 'M', u't'), + (0x1F144, 'M', u'u'), + (0x1F145, 'M', u'v'), + (0x1F146, 'M', u'w'), + (0x1F147, 'M', u'x'), + (0x1F148, 'M', u'y'), + (0x1F149, 'M', u'z'), + (0x1F14A, 'M', u'hv'), + (0x1F14B, 'M', u'mv'), + (0x1F14C, 'M', u'sd'), + (0x1F14D, 'M', u'ss'), + (0x1F14E, 'M', u'ppv'), + (0x1F14F, 'M', u'wc'), + (0x1F150, 'V'), + (0x1F16A, 'M', u'mc'), + (0x1F16B, 'M', u'md'), + (0x1F16C, 'X'), + (0x1F170, 'V'), + (0x1F190, 'M', u'dj'), + (0x1F191, 'V'), + (0x1F1AD, 'X'), + (0x1F1E6, 'V'), + (0x1F200, 'M', u'ほか'), + (0x1F201, 'M', u'ココ'), + (0x1F202, 'M', u'サ'), + (0x1F203, 'X'), + (0x1F210, 'M', u'手'), + (0x1F211, 'M', u'字'), + (0x1F212, 'M', u'双'), + (0x1F213, 'M', u'デ'), + (0x1F214, 'M', u'二'), + (0x1F215, 'M', u'多'), + (0x1F216, 'M', u'解'), + (0x1F217, 'M', u'天'), + (0x1F218, 'M', u'交'), + (0x1F219, 'M', u'映'), + (0x1F21A, 'M', u'無'), + (0x1F21B, 'M', u'料'), + (0x1F21C, 'M', u'前'), + (0x1F21D, 'M', u'後'), + (0x1F21E, 'M', u'再'), + (0x1F21F, 'M', u'新'), + (0x1F220, 'M', u'初'), + (0x1F221, 'M', u'終'), + (0x1F222, 'M', u'生'), + (0x1F223, 'M', u'販'), + (0x1F224, 'M', u'声'), + (0x1F225, 'M', u'吹'), + (0x1F226, 'M', u'演'), + (0x1F227, 'M', u'投'), + (0x1F228, 'M', u'捕'), + (0x1F229, 'M', u'一'), + (0x1F22A, 'M', u'三'), + (0x1F22B, 'M', u'遊'), + (0x1F22C, 'M', u'左'), + (0x1F22D, 'M', u'中'), + (0x1F22E, 'M', u'右'), + (0x1F22F, 'M', u'指'), + (0x1F230, 'M', u'走'), + (0x1F231, 'M', u'打'), + (0x1F232, 'M', u'禁'), + (0x1F233, 'M', u'空'), + (0x1F234, 'M', u'合'), + (0x1F235, 'M', u'満'), + (0x1F236, 'M', u'有'), + (0x1F237, 'M', u'月'), + (0x1F238, 'M', u'申'), + (0x1F239, 'M', u'割'), + (0x1F23A, 'M', u'営'), + (0x1F23B, 'M', u'配'), + ] + +def _seg_72(): + return [ + (0x1F23C, 'X'), + (0x1F240, 'M', u'〔本〕'), + (0x1F241, 'M', u'〔三〕'), + (0x1F242, 'M', u'〔二〕'), + (0x1F243, 'M', u'〔安〕'), + (0x1F244, 'M', u'〔点〕'), + (0x1F245, 'M', u'〔打〕'), + (0x1F246, 'M', u'〔盗〕'), + (0x1F247, 'M', u'〔勝〕'), + (0x1F248, 'M', u'〔敗〕'), + (0x1F249, 'X'), + (0x1F250, 'M', u'得'), + (0x1F251, 'M', u'可'), + (0x1F252, 'X'), + (0x1F260, 'V'), + (0x1F266, 'X'), + (0x1F300, 'V'), + (0x1F6D5, 'X'), + (0x1F6E0, 'V'), + (0x1F6ED, 'X'), + (0x1F6F0, 'V'), + (0x1F6FA, 'X'), + (0x1F700, 'V'), + (0x1F774, 'X'), + (0x1F780, 'V'), + (0x1F7D9, 'X'), + (0x1F800, 'V'), + (0x1F80C, 'X'), + (0x1F810, 'V'), + (0x1F848, 'X'), + (0x1F850, 'V'), + (0x1F85A, 'X'), + (0x1F860, 'V'), + (0x1F888, 'X'), + (0x1F890, 'V'), + (0x1F8AE, 'X'), + (0x1F900, 'V'), + (0x1F90C, 'X'), + (0x1F910, 'V'), + (0x1F93F, 'X'), + (0x1F940, 'V'), + (0x1F971, 'X'), + (0x1F973, 'V'), + (0x1F977, 'X'), + (0x1F97A, 'V'), + (0x1F97B, 'X'), + (0x1F97C, 'V'), + (0x1F9A3, 'X'), + (0x1F9B0, 'V'), + (0x1F9BA, 'X'), + (0x1F9C0, 'V'), + (0x1F9C3, 'X'), + (0x1F9D0, 'V'), + (0x1FA00, 'X'), + (0x1FA60, 'V'), + (0x1FA6E, 'X'), + (0x20000, 'V'), + (0x2A6D7, 'X'), + (0x2A700, 'V'), + (0x2B735, 'X'), + (0x2B740, 'V'), + (0x2B81E, 'X'), + (0x2B820, 'V'), + (0x2CEA2, 'X'), + (0x2CEB0, 'V'), + (0x2EBE1, 'X'), + (0x2F800, 'M', u'丽'), + (0x2F801, 'M', u'丸'), + (0x2F802, 'M', u'乁'), + (0x2F803, 'M', u'𠄢'), + (0x2F804, 'M', u'你'), + (0x2F805, 'M', u'侮'), + (0x2F806, 'M', u'侻'), + (0x2F807, 'M', u'倂'), + (0x2F808, 'M', u'偺'), + (0x2F809, 'M', u'備'), + (0x2F80A, 'M', u'僧'), + (0x2F80B, 'M', u'像'), + (0x2F80C, 'M', u'㒞'), + (0x2F80D, 'M', u'𠘺'), + (0x2F80E, 'M', u'免'), + (0x2F80F, 'M', u'兔'), + (0x2F810, 'M', u'兤'), + (0x2F811, 'M', u'具'), + (0x2F812, 'M', u'𠔜'), + (0x2F813, 'M', u'㒹'), + (0x2F814, 'M', u'內'), + (0x2F815, 'M', u'再'), + (0x2F816, 'M', u'𠕋'), + (0x2F817, 'M', u'冗'), + (0x2F818, 'M', u'冤'), + (0x2F819, 'M', u'仌'), + (0x2F81A, 'M', u'冬'), + (0x2F81B, 'M', u'况'), + (0x2F81C, 'M', u'𩇟'), + (0x2F81D, 'M', u'凵'), + (0x2F81E, 'M', u'刃'), + (0x2F81F, 'M', u'㓟'), + (0x2F820, 'M', u'刻'), + (0x2F821, 'M', u'剆'), + ] + +def _seg_73(): + return [ + (0x2F822, 'M', u'割'), + (0x2F823, 'M', u'剷'), + (0x2F824, 'M', u'㔕'), + (0x2F825, 'M', u'勇'), + (0x2F826, 'M', u'勉'), + (0x2F827, 'M', u'勤'), + (0x2F828, 'M', u'勺'), + (0x2F829, 'M', u'包'), + (0x2F82A, 'M', u'匆'), + (0x2F82B, 'M', u'北'), + (0x2F82C, 'M', u'卉'), + (0x2F82D, 'M', u'卑'), + (0x2F82E, 'M', u'博'), + (0x2F82F, 'M', u'即'), + (0x2F830, 'M', u'卽'), + (0x2F831, 'M', u'卿'), + (0x2F834, 'M', u'𠨬'), + (0x2F835, 'M', u'灰'), + (0x2F836, 'M', u'及'), + (0x2F837, 'M', u'叟'), + (0x2F838, 'M', u'𠭣'), + (0x2F839, 'M', u'叫'), + (0x2F83A, 'M', u'叱'), + (0x2F83B, 'M', u'吆'), + (0x2F83C, 'M', u'咞'), + (0x2F83D, 'M', u'吸'), + (0x2F83E, 'M', u'呈'), + (0x2F83F, 'M', u'周'), + (0x2F840, 'M', u'咢'), + (0x2F841, 'M', u'哶'), + (0x2F842, 'M', u'唐'), + (0x2F843, 'M', u'啓'), + (0x2F844, 'M', u'啣'), + (0x2F845, 'M', u'善'), + (0x2F847, 'M', u'喙'), + (0x2F848, 'M', u'喫'), + (0x2F849, 'M', u'喳'), + (0x2F84A, 'M', u'嗂'), + (0x2F84B, 'M', u'圖'), + (0x2F84C, 'M', u'嘆'), + (0x2F84D, 'M', u'圗'), + (0x2F84E, 'M', u'噑'), + (0x2F84F, 'M', u'噴'), + (0x2F850, 'M', u'切'), + (0x2F851, 'M', u'壮'), + (0x2F852, 'M', u'城'), + (0x2F853, 'M', u'埴'), + (0x2F854, 'M', u'堍'), + (0x2F855, 'M', u'型'), + (0x2F856, 'M', u'堲'), + (0x2F857, 'M', u'報'), + (0x2F858, 'M', u'墬'), + (0x2F859, 'M', u'𡓤'), + (0x2F85A, 'M', u'売'), + (0x2F85B, 'M', u'壷'), + (0x2F85C, 'M', u'夆'), + (0x2F85D, 'M', u'多'), + (0x2F85E, 'M', u'夢'), + (0x2F85F, 'M', u'奢'), + (0x2F860, 'M', u'𡚨'), + (0x2F861, 'M', u'𡛪'), + (0x2F862, 'M', u'姬'), + (0x2F863, 'M', u'娛'), + (0x2F864, 'M', u'娧'), + (0x2F865, 'M', u'姘'), + (0x2F866, 'M', u'婦'), + (0x2F867, 'M', u'㛮'), + (0x2F868, 'X'), + (0x2F869, 'M', u'嬈'), + (0x2F86A, 'M', u'嬾'), + (0x2F86C, 'M', u'𡧈'), + (0x2F86D, 'M', u'寃'), + (0x2F86E, 'M', u'寘'), + (0x2F86F, 'M', u'寧'), + (0x2F870, 'M', u'寳'), + (0x2F871, 'M', u'𡬘'), + (0x2F872, 'M', u'寿'), + (0x2F873, 'M', u'将'), + (0x2F874, 'X'), + (0x2F875, 'M', u'尢'), + (0x2F876, 'M', u'㞁'), + (0x2F877, 'M', u'屠'), + (0x2F878, 'M', u'屮'), + (0x2F879, 'M', u'峀'), + (0x2F87A, 'M', u'岍'), + (0x2F87B, 'M', u'𡷤'), + (0x2F87C, 'M', u'嵃'), + (0x2F87D, 'M', u'𡷦'), + (0x2F87E, 'M', u'嵮'), + (0x2F87F, 'M', u'嵫'), + (0x2F880, 'M', u'嵼'), + (0x2F881, 'M', u'巡'), + (0x2F882, 'M', u'巢'), + (0x2F883, 'M', u'㠯'), + (0x2F884, 'M', u'巽'), + (0x2F885, 'M', u'帨'), + (0x2F886, 'M', u'帽'), + (0x2F887, 'M', u'幩'), + (0x2F888, 'M', u'㡢'), + (0x2F889, 'M', u'𢆃'), + ] + +def _seg_74(): + return [ + (0x2F88A, 'M', u'㡼'), + (0x2F88B, 'M', u'庰'), + (0x2F88C, 'M', u'庳'), + (0x2F88D, 'M', u'庶'), + (0x2F88E, 'M', u'廊'), + (0x2F88F, 'M', u'𪎒'), + (0x2F890, 'M', u'廾'), + (0x2F891, 'M', u'𢌱'), + (0x2F893, 'M', u'舁'), + (0x2F894, 'M', u'弢'), + (0x2F896, 'M', u'㣇'), + (0x2F897, 'M', u'𣊸'), + (0x2F898, 'M', u'𦇚'), + (0x2F899, 'M', u'形'), + (0x2F89A, 'M', u'彫'), + (0x2F89B, 'M', u'㣣'), + (0x2F89C, 'M', u'徚'), + (0x2F89D, 'M', u'忍'), + (0x2F89E, 'M', u'志'), + (0x2F89F, 'M', u'忹'), + (0x2F8A0, 'M', u'悁'), + (0x2F8A1, 'M', u'㤺'), + (0x2F8A2, 'M', u'㤜'), + (0x2F8A3, 'M', u'悔'), + (0x2F8A4, 'M', u'𢛔'), + (0x2F8A5, 'M', u'惇'), + (0x2F8A6, 'M', u'慈'), + (0x2F8A7, 'M', u'慌'), + (0x2F8A8, 'M', u'慎'), + (0x2F8A9, 'M', u'慌'), + (0x2F8AA, 'M', u'慺'), + (0x2F8AB, 'M', u'憎'), + (0x2F8AC, 'M', u'憲'), + (0x2F8AD, 'M', u'憤'), + (0x2F8AE, 'M', u'憯'), + (0x2F8AF, 'M', u'懞'), + (0x2F8B0, 'M', u'懲'), + (0x2F8B1, 'M', u'懶'), + (0x2F8B2, 'M', u'成'), + (0x2F8B3, 'M', u'戛'), + (0x2F8B4, 'M', u'扝'), + (0x2F8B5, 'M', u'抱'), + (0x2F8B6, 'M', u'拔'), + (0x2F8B7, 'M', u'捐'), + (0x2F8B8, 'M', u'𢬌'), + (0x2F8B9, 'M', u'挽'), + (0x2F8BA, 'M', u'拼'), + (0x2F8BB, 'M', u'捨'), + (0x2F8BC, 'M', u'掃'), + (0x2F8BD, 'M', u'揤'), + (0x2F8BE, 'M', u'𢯱'), + (0x2F8BF, 'M', u'搢'), + (0x2F8C0, 'M', u'揅'), + (0x2F8C1, 'M', u'掩'), + (0x2F8C2, 'M', u'㨮'), + (0x2F8C3, 'M', u'摩'), + (0x2F8C4, 'M', u'摾'), + (0x2F8C5, 'M', u'撝'), + (0x2F8C6, 'M', u'摷'), + (0x2F8C7, 'M', u'㩬'), + (0x2F8C8, 'M', u'敏'), + (0x2F8C9, 'M', u'敬'), + (0x2F8CA, 'M', u'𣀊'), + (0x2F8CB, 'M', u'旣'), + (0x2F8CC, 'M', u'書'), + (0x2F8CD, 'M', u'晉'), + (0x2F8CE, 'M', u'㬙'), + (0x2F8CF, 'M', u'暑'), + (0x2F8D0, 'M', u'㬈'), + (0x2F8D1, 'M', u'㫤'), + (0x2F8D2, 'M', u'冒'), + (0x2F8D3, 'M', u'冕'), + (0x2F8D4, 'M', u'最'), + (0x2F8D5, 'M', u'暜'), + (0x2F8D6, 'M', u'肭'), + (0x2F8D7, 'M', u'䏙'), + (0x2F8D8, 'M', u'朗'), + (0x2F8D9, 'M', u'望'), + (0x2F8DA, 'M', u'朡'), + (0x2F8DB, 'M', u'杞'), + (0x2F8DC, 'M', u'杓'), + (0x2F8DD, 'M', u'𣏃'), + (0x2F8DE, 'M', u'㭉'), + (0x2F8DF, 'M', u'柺'), + (0x2F8E0, 'M', u'枅'), + (0x2F8E1, 'M', u'桒'), + (0x2F8E2, 'M', u'梅'), + (0x2F8E3, 'M', u'𣑭'), + (0x2F8E4, 'M', u'梎'), + (0x2F8E5, 'M', u'栟'), + (0x2F8E6, 'M', u'椔'), + (0x2F8E7, 'M', u'㮝'), + (0x2F8E8, 'M', u'楂'), + (0x2F8E9, 'M', u'榣'), + (0x2F8EA, 'M', u'槪'), + (0x2F8EB, 'M', u'檨'), + (0x2F8EC, 'M', u'𣚣'), + (0x2F8ED, 'M', u'櫛'), + (0x2F8EE, 'M', u'㰘'), + (0x2F8EF, 'M', u'次'), + ] + +def _seg_75(): + return [ + (0x2F8F0, 'M', u'𣢧'), + (0x2F8F1, 'M', u'歔'), + (0x2F8F2, 'M', u'㱎'), + (0x2F8F3, 'M', u'歲'), + (0x2F8F4, 'M', u'殟'), + (0x2F8F5, 'M', u'殺'), + (0x2F8F6, 'M', u'殻'), + (0x2F8F7, 'M', u'𣪍'), + (0x2F8F8, 'M', u'𡴋'), + (0x2F8F9, 'M', u'𣫺'), + (0x2F8FA, 'M', u'汎'), + (0x2F8FB, 'M', u'𣲼'), + (0x2F8FC, 'M', u'沿'), + (0x2F8FD, 'M', u'泍'), + (0x2F8FE, 'M', u'汧'), + (0x2F8FF, 'M', u'洖'), + (0x2F900, 'M', u'派'), + (0x2F901, 'M', u'海'), + (0x2F902, 'M', u'流'), + (0x2F903, 'M', u'浩'), + (0x2F904, 'M', u'浸'), + (0x2F905, 'M', u'涅'), + (0x2F906, 'M', u'𣴞'), + (0x2F907, 'M', u'洴'), + (0x2F908, 'M', u'港'), + (0x2F909, 'M', u'湮'), + (0x2F90A, 'M', u'㴳'), + (0x2F90B, 'M', u'滋'), + (0x2F90C, 'M', u'滇'), + (0x2F90D, 'M', u'𣻑'), + (0x2F90E, 'M', u'淹'), + (0x2F90F, 'M', u'潮'), + (0x2F910, 'M', u'𣽞'), + (0x2F911, 'M', u'𣾎'), + (0x2F912, 'M', u'濆'), + (0x2F913, 'M', u'瀹'), + (0x2F914, 'M', u'瀞'), + (0x2F915, 'M', u'瀛'), + (0x2F916, 'M', u'㶖'), + (0x2F917, 'M', u'灊'), + (0x2F918, 'M', u'災'), + (0x2F919, 'M', u'灷'), + (0x2F91A, 'M', u'炭'), + (0x2F91B, 'M', u'𠔥'), + (0x2F91C, 'M', u'煅'), + (0x2F91D, 'M', u'𤉣'), + (0x2F91E, 'M', u'熜'), + (0x2F91F, 'X'), + (0x2F920, 'M', u'爨'), + (0x2F921, 'M', u'爵'), + (0x2F922, 'M', u'牐'), + (0x2F923, 'M', u'𤘈'), + (0x2F924, 'M', u'犀'), + (0x2F925, 'M', u'犕'), + (0x2F926, 'M', u'𤜵'), + (0x2F927, 'M', u'𤠔'), + (0x2F928, 'M', u'獺'), + (0x2F929, 'M', u'王'), + (0x2F92A, 'M', u'㺬'), + (0x2F92B, 'M', u'玥'), + (0x2F92C, 'M', u'㺸'), + (0x2F92E, 'M', u'瑇'), + (0x2F92F, 'M', u'瑜'), + (0x2F930, 'M', u'瑱'), + (0x2F931, 'M', u'璅'), + (0x2F932, 'M', u'瓊'), + (0x2F933, 'M', u'㼛'), + (0x2F934, 'M', u'甤'), + (0x2F935, 'M', u'𤰶'), + (0x2F936, 'M', u'甾'), + (0x2F937, 'M', u'𤲒'), + (0x2F938, 'M', u'異'), + (0x2F939, 'M', u'𢆟'), + (0x2F93A, 'M', u'瘐'), + (0x2F93B, 'M', u'𤾡'), + (0x2F93C, 'M', u'𤾸'), + (0x2F93D, 'M', u'𥁄'), + (0x2F93E, 'M', u'㿼'), + (0x2F93F, 'M', u'䀈'), + (0x2F940, 'M', u'直'), + (0x2F941, 'M', u'𥃳'), + (0x2F942, 'M', u'𥃲'), + (0x2F943, 'M', u'𥄙'), + (0x2F944, 'M', u'𥄳'), + (0x2F945, 'M', u'眞'), + (0x2F946, 'M', u'真'), + (0x2F948, 'M', u'睊'), + (0x2F949, 'M', u'䀹'), + (0x2F94A, 'M', u'瞋'), + (0x2F94B, 'M', u'䁆'), + (0x2F94C, 'M', u'䂖'), + (0x2F94D, 'M', u'𥐝'), + (0x2F94E, 'M', u'硎'), + (0x2F94F, 'M', u'碌'), + (0x2F950, 'M', u'磌'), + (0x2F951, 'M', u'䃣'), + (0x2F952, 'M', u'𥘦'), + (0x2F953, 'M', u'祖'), + (0x2F954, 'M', u'𥚚'), + (0x2F955, 'M', u'𥛅'), + ] + +def _seg_76(): + return [ + (0x2F956, 'M', u'福'), + (0x2F957, 'M', u'秫'), + (0x2F958, 'M', u'䄯'), + (0x2F959, 'M', u'穀'), + (0x2F95A, 'M', u'穊'), + (0x2F95B, 'M', u'穏'), + (0x2F95C, 'M', u'𥥼'), + (0x2F95D, 'M', u'𥪧'), + (0x2F95F, 'X'), + (0x2F960, 'M', u'䈂'), + (0x2F961, 'M', u'𥮫'), + (0x2F962, 'M', u'篆'), + (0x2F963, 'M', u'築'), + (0x2F964, 'M', u'䈧'), + (0x2F965, 'M', u'𥲀'), + (0x2F966, 'M', u'糒'), + (0x2F967, 'M', u'䊠'), + (0x2F968, 'M', u'糨'), + (0x2F969, 'M', u'糣'), + (0x2F96A, 'M', u'紀'), + (0x2F96B, 'M', u'𥾆'), + (0x2F96C, 'M', u'絣'), + (0x2F96D, 'M', u'䌁'), + (0x2F96E, 'M', u'緇'), + (0x2F96F, 'M', u'縂'), + (0x2F970, 'M', u'繅'), + (0x2F971, 'M', u'䌴'), + (0x2F972, 'M', u'𦈨'), + (0x2F973, 'M', u'𦉇'), + (0x2F974, 'M', u'䍙'), + (0x2F975, 'M', u'𦋙'), + (0x2F976, 'M', u'罺'), + (0x2F977, 'M', u'𦌾'), + (0x2F978, 'M', u'羕'), + (0x2F979, 'M', u'翺'), + (0x2F97A, 'M', u'者'), + (0x2F97B, 'M', u'𦓚'), + (0x2F97C, 'M', u'𦔣'), + (0x2F97D, 'M', u'聠'), + (0x2F97E, 'M', u'𦖨'), + (0x2F97F, 'M', u'聰'), + (0x2F980, 'M', u'𣍟'), + (0x2F981, 'M', u'䏕'), + (0x2F982, 'M', u'育'), + (0x2F983, 'M', u'脃'), + (0x2F984, 'M', u'䐋'), + (0x2F985, 'M', u'脾'), + (0x2F986, 'M', u'媵'), + (0x2F987, 'M', u'𦞧'), + (0x2F988, 'M', u'𦞵'), + (0x2F989, 'M', u'𣎓'), + (0x2F98A, 'M', u'𣎜'), + (0x2F98B, 'M', u'舁'), + (0x2F98C, 'M', u'舄'), + (0x2F98D, 'M', u'辞'), + (0x2F98E, 'M', u'䑫'), + (0x2F98F, 'M', u'芑'), + (0x2F990, 'M', u'芋'), + (0x2F991, 'M', u'芝'), + (0x2F992, 'M', u'劳'), + (0x2F993, 'M', u'花'), + (0x2F994, 'M', u'芳'), + (0x2F995, 'M', u'芽'), + (0x2F996, 'M', u'苦'), + (0x2F997, 'M', u'𦬼'), + (0x2F998, 'M', u'若'), + (0x2F999, 'M', u'茝'), + (0x2F99A, 'M', u'荣'), + (0x2F99B, 'M', u'莭'), + (0x2F99C, 'M', u'茣'), + (0x2F99D, 'M', u'莽'), + (0x2F99E, 'M', u'菧'), + (0x2F99F, 'M', u'著'), + (0x2F9A0, 'M', u'荓'), + (0x2F9A1, 'M', u'菊'), + (0x2F9A2, 'M', u'菌'), + (0x2F9A3, 'M', u'菜'), + (0x2F9A4, 'M', u'𦰶'), + (0x2F9A5, 'M', u'𦵫'), + (0x2F9A6, 'M', u'𦳕'), + (0x2F9A7, 'M', u'䔫'), + (0x2F9A8, 'M', u'蓱'), + (0x2F9A9, 'M', u'蓳'), + (0x2F9AA, 'M', u'蔖'), + (0x2F9AB, 'M', u'𧏊'), + (0x2F9AC, 'M', u'蕤'), + (0x2F9AD, 'M', u'𦼬'), + (0x2F9AE, 'M', u'䕝'), + (0x2F9AF, 'M', u'䕡'), + (0x2F9B0, 'M', u'𦾱'), + (0x2F9B1, 'M', u'𧃒'), + (0x2F9B2, 'M', u'䕫'), + (0x2F9B3, 'M', u'虐'), + (0x2F9B4, 'M', u'虜'), + (0x2F9B5, 'M', u'虧'), + (0x2F9B6, 'M', u'虩'), + (0x2F9B7, 'M', u'蚩'), + (0x2F9B8, 'M', u'蚈'), + (0x2F9B9, 'M', u'蜎'), + (0x2F9BA, 'M', u'蛢'), + ] + +def _seg_77(): + return [ + (0x2F9BB, 'M', u'蝹'), + (0x2F9BC, 'M', u'蜨'), + (0x2F9BD, 'M', u'蝫'), + (0x2F9BE, 'M', u'螆'), + (0x2F9BF, 'X'), + (0x2F9C0, 'M', u'蟡'), + (0x2F9C1, 'M', u'蠁'), + (0x2F9C2, 'M', u'䗹'), + (0x2F9C3, 'M', u'衠'), + (0x2F9C4, 'M', u'衣'), + (0x2F9C5, 'M', u'𧙧'), + (0x2F9C6, 'M', u'裗'), + (0x2F9C7, 'M', u'裞'), + (0x2F9C8, 'M', u'䘵'), + (0x2F9C9, 'M', u'裺'), + (0x2F9CA, 'M', u'㒻'), + (0x2F9CB, 'M', u'𧢮'), + (0x2F9CC, 'M', u'𧥦'), + (0x2F9CD, 'M', u'䚾'), + (0x2F9CE, 'M', u'䛇'), + (0x2F9CF, 'M', u'誠'), + (0x2F9D0, 'M', u'諭'), + (0x2F9D1, 'M', u'變'), + (0x2F9D2, 'M', u'豕'), + (0x2F9D3, 'M', u'𧲨'), + (0x2F9D4, 'M', u'貫'), + (0x2F9D5, 'M', u'賁'), + (0x2F9D6, 'M', u'贛'), + (0x2F9D7, 'M', u'起'), + (0x2F9D8, 'M', u'𧼯'), + (0x2F9D9, 'M', u'𠠄'), + (0x2F9DA, 'M', u'跋'), + (0x2F9DB, 'M', u'趼'), + (0x2F9DC, 'M', u'跰'), + (0x2F9DD, 'M', u'𠣞'), + (0x2F9DE, 'M', u'軔'), + (0x2F9DF, 'M', u'輸'), + (0x2F9E0, 'M', u'𨗒'), + (0x2F9E1, 'M', u'𨗭'), + (0x2F9E2, 'M', u'邔'), + (0x2F9E3, 'M', u'郱'), + (0x2F9E4, 'M', u'鄑'), + (0x2F9E5, 'M', u'𨜮'), + (0x2F9E6, 'M', u'鄛'), + (0x2F9E7, 'M', u'鈸'), + (0x2F9E8, 'M', u'鋗'), + (0x2F9E9, 'M', u'鋘'), + (0x2F9EA, 'M', u'鉼'), + (0x2F9EB, 'M', u'鏹'), + (0x2F9EC, 'M', u'鐕'), + (0x2F9ED, 'M', u'𨯺'), + (0x2F9EE, 'M', u'開'), + (0x2F9EF, 'M', u'䦕'), + (0x2F9F0, 'M', u'閷'), + (0x2F9F1, 'M', u'𨵷'), + (0x2F9F2, 'M', u'䧦'), + (0x2F9F3, 'M', u'雃'), + (0x2F9F4, 'M', u'嶲'), + (0x2F9F5, 'M', u'霣'), + (0x2F9F6, 'M', u'𩅅'), + (0x2F9F7, 'M', u'𩈚'), + (0x2F9F8, 'M', u'䩮'), + (0x2F9F9, 'M', u'䩶'), + (0x2F9FA, 'M', u'韠'), + (0x2F9FB, 'M', u'𩐊'), + (0x2F9FC, 'M', u'䪲'), + (0x2F9FD, 'M', u'𩒖'), + (0x2F9FE, 'M', u'頋'), + (0x2FA00, 'M', u'頩'), + (0x2FA01, 'M', u'𩖶'), + (0x2FA02, 'M', u'飢'), + (0x2FA03, 'M', u'䬳'), + (0x2FA04, 'M', u'餩'), + (0x2FA05, 'M', u'馧'), + (0x2FA06, 'M', u'駂'), + (0x2FA07, 'M', u'駾'), + (0x2FA08, 'M', u'䯎'), + (0x2FA09, 'M', u'𩬰'), + (0x2FA0A, 'M', u'鬒'), + (0x2FA0B, 'M', u'鱀'), + (0x2FA0C, 'M', u'鳽'), + (0x2FA0D, 'M', u'䳎'), + (0x2FA0E, 'M', u'䳭'), + (0x2FA0F, 'M', u'鵧'), + (0x2FA10, 'M', u'𪃎'), + (0x2FA11, 'M', u'䳸'), + (0x2FA12, 'M', u'𪄅'), + (0x2FA13, 'M', u'𪈎'), + (0x2FA14, 'M', u'𪊑'), + (0x2FA15, 'M', u'麻'), + (0x2FA16, 'M', u'䵖'), + (0x2FA17, 'M', u'黹'), + (0x2FA18, 'M', u'黾'), + (0x2FA19, 'M', u'鼅'), + (0x2FA1A, 'M', u'鼏'), + (0x2FA1B, 'M', u'鼖'), + (0x2FA1C, 'M', u'鼻'), + (0x2FA1D, 'M', u'𪘀'), + (0x2FA1E, 'X'), + (0xE0100, 'I'), + ] + +def _seg_78(): + return [ + (0xE01F0, 'X'), + ] + +uts46data = tuple( + _seg_0() + + _seg_1() + + _seg_2() + + _seg_3() + + _seg_4() + + _seg_5() + + _seg_6() + + _seg_7() + + _seg_8() + + _seg_9() + + _seg_10() + + _seg_11() + + _seg_12() + + _seg_13() + + _seg_14() + + _seg_15() + + _seg_16() + + _seg_17() + + _seg_18() + + _seg_19() + + _seg_20() + + _seg_21() + + _seg_22() + + _seg_23() + + _seg_24() + + _seg_25() + + _seg_26() + + _seg_27() + + _seg_28() + + _seg_29() + + _seg_30() + + _seg_31() + + _seg_32() + + _seg_33() + + _seg_34() + + _seg_35() + + _seg_36() + + _seg_37() + + _seg_38() + + _seg_39() + + _seg_40() + + _seg_41() + + _seg_42() + + _seg_43() + + _seg_44() + + _seg_45() + + _seg_46() + + _seg_47() + + _seg_48() + + _seg_49() + + _seg_50() + + _seg_51() + + _seg_52() + + _seg_53() + + _seg_54() + + _seg_55() + + _seg_56() + + _seg_57() + + _seg_58() + + _seg_59() + + _seg_60() + + _seg_61() + + _seg_62() + + _seg_63() + + _seg_64() + + _seg_65() + + _seg_66() + + _seg_67() + + _seg_68() + + _seg_69() + + _seg_70() + + _seg_71() + + _seg_72() + + _seg_73() + + _seg_74() + + _seg_75() + + _seg_76() + + _seg_77() + + _seg_78() +) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..a6f44a55c6377c746ec8ca831999fdde5e401aa6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/__init__.py @@ -0,0 +1,347 @@ +# -*- coding: utf-8 -*- + +""" +lockfile.py - Platform-independent advisory file locks. + +Requires Python 2.5 unless you apply 2.4.diff +Locking is done on a per-thread basis instead of a per-process basis. + +Usage: + +>>> lock = LockFile('somefile') +>>> try: +... lock.acquire() +... except AlreadyLocked: +... print 'somefile', 'is locked already.' +... except LockFailed: +... print 'somefile', 'can\\'t be locked.' +... else: +... print 'got lock' +got lock +>>> print lock.is_locked() +True +>>> lock.release() + +>>> lock = LockFile('somefile') +>>> print lock.is_locked() +False +>>> with lock: +... print lock.is_locked() +True +>>> print lock.is_locked() +False + +>>> lock = LockFile('somefile') +>>> # It is okay to lock twice from the same thread... +>>> with lock: +... lock.acquire() +... +>>> # Though no counter is kept, so you can't unlock multiple times... +>>> print lock.is_locked() +False + +Exceptions: + + Error - base class for other exceptions + LockError - base class for all locking exceptions + AlreadyLocked - Another thread or process already holds the lock + LockFailed - Lock failed for some other reason + UnlockError - base class for all unlocking exceptions + AlreadyUnlocked - File was not locked. + NotMyLock - File was locked but not by the current thread/process +""" + +from __future__ import absolute_import + +import functools +import os +import socket +import threading +import warnings + +# Work with PEP8 and non-PEP8 versions of threading module. +if not hasattr(threading, "current_thread"): + threading.current_thread = threading.currentThread +if not hasattr(threading.Thread, "get_name"): + threading.Thread.get_name = threading.Thread.getName + +__all__ = ['Error', 'LockError', 'LockTimeout', 'AlreadyLocked', + 'LockFailed', 'UnlockError', 'NotLocked', 'NotMyLock', + 'LinkFileLock', 'MkdirFileLock', 'SQLiteFileLock', + 'LockBase', 'locked'] + + +class Error(Exception): + """ + Base class for other exceptions. + + >>> try: + ... raise Error + ... except Exception: + ... pass + """ + pass + + +class LockError(Error): + """ + Base class for error arising from attempts to acquire the lock. + + >>> try: + ... raise LockError + ... except Error: + ... pass + """ + pass + + +class LockTimeout(LockError): + """Raised when lock creation fails within a user-defined period of time. + + >>> try: + ... raise LockTimeout + ... except LockError: + ... pass + """ + pass + + +class AlreadyLocked(LockError): + """Some other thread/process is locking the file. + + >>> try: + ... raise AlreadyLocked + ... except LockError: + ... pass + """ + pass + + +class LockFailed(LockError): + """Lock file creation failed for some other reason. + + >>> try: + ... raise LockFailed + ... except LockError: + ... pass + """ + pass + + +class UnlockError(Error): + """ + Base class for errors arising from attempts to release the lock. + + >>> try: + ... raise UnlockError + ... except Error: + ... pass + """ + pass + + +class NotLocked(UnlockError): + """Raised when an attempt is made to unlock an unlocked file. + + >>> try: + ... raise NotLocked + ... except UnlockError: + ... pass + """ + pass + + +class NotMyLock(UnlockError): + """Raised when an attempt is made to unlock a file someone else locked. + + >>> try: + ... raise NotMyLock + ... except UnlockError: + ... pass + """ + pass + + +class _SharedBase(object): + def __init__(self, path): + self.path = path + + def acquire(self, timeout=None): + """ + Acquire the lock. + + * If timeout is omitted (or None), wait forever trying to lock the + file. + + * If timeout > 0, try to acquire the lock for that many seconds. If + the lock period expires and the file is still locked, raise + LockTimeout. + + * If timeout <= 0, raise AlreadyLocked immediately if the file is + already locked. + """ + raise NotImplemented("implement in subclass") + + def release(self): + """ + Release the lock. + + If the file is not locked, raise NotLocked. + """ + raise NotImplemented("implement in subclass") + + def __enter__(self): + """ + Context manager support. + """ + self.acquire() + return self + + def __exit__(self, *_exc): + """ + Context manager support. + """ + self.release() + + def __repr__(self): + return "<%s: %r>" % (self.__class__.__name__, self.path) + + +class LockBase(_SharedBase): + """Base class for platform-specific lock classes.""" + def __init__(self, path, threaded=True, timeout=None): + """ + >>> lock = LockBase('somefile') + >>> lock = LockBase('somefile', threaded=False) + """ + super(LockBase, self).__init__(path) + self.lock_file = os.path.abspath(path) + ".lock" + self.hostname = socket.gethostname() + self.pid = os.getpid() + if threaded: + t = threading.current_thread() + # Thread objects in Python 2.4 and earlier do not have ident + # attrs. Worm around that. + ident = getattr(t, "ident", hash(t)) + self.tname = "-%x" % (ident & 0xffffffff) + else: + self.tname = "" + dirname = os.path.dirname(self.lock_file) + + # unique name is mostly about the current process, but must + # also contain the path -- otherwise, two adjacent locked + # files conflict (one file gets locked, creating lock-file and + # unique file, the other one gets locked, creating lock-file + # and overwriting the already existing lock-file, then one + # gets unlocked, deleting both lock-file and unique file, + # finally the last lock errors out upon releasing. + self.unique_name = os.path.join(dirname, + "%s%s.%s%s" % (self.hostname, + self.tname, + self.pid, + hash(self.path))) + self.timeout = timeout + + def is_locked(self): + """ + Tell whether or not the file is locked. + """ + raise NotImplemented("implement in subclass") + + def i_am_locking(self): + """ + Return True if this object is locking the file. + """ + raise NotImplemented("implement in subclass") + + def break_lock(self): + """ + Remove a lock. Useful if a locking thread failed to unlock. + """ + raise NotImplemented("implement in subclass") + + def __repr__(self): + return "<%s: %r -- %r>" % (self.__class__.__name__, self.unique_name, + self.path) + + +def _fl_helper(cls, mod, *args, **kwds): + warnings.warn("Import from %s module instead of lockfile package" % mod, + DeprecationWarning, stacklevel=2) + # This is a bit funky, but it's only for awhile. The way the unit tests + # are constructed this function winds up as an unbound method, so it + # actually takes three args, not two. We want to toss out self. + if not isinstance(args[0], str): + # We are testing, avoid the first arg + args = args[1:] + if len(args) == 1 and not kwds: + kwds["threaded"] = True + return cls(*args, **kwds) + + +def LinkFileLock(*args, **kwds): + """Factory function provided for backwards compatibility. + + Do not use in new code. Instead, import LinkLockFile from the + lockfile.linklockfile module. + """ + from . import linklockfile + return _fl_helper(linklockfile.LinkLockFile, "lockfile.linklockfile", + *args, **kwds) + + +def MkdirFileLock(*args, **kwds): + """Factory function provided for backwards compatibility. + + Do not use in new code. Instead, import MkdirLockFile from the + lockfile.mkdirlockfile module. + """ + from . import mkdirlockfile + return _fl_helper(mkdirlockfile.MkdirLockFile, "lockfile.mkdirlockfile", + *args, **kwds) + + +def SQLiteFileLock(*args, **kwds): + """Factory function provided for backwards compatibility. + + Do not use in new code. Instead, import SQLiteLockFile from the + lockfile.mkdirlockfile module. + """ + from . import sqlitelockfile + return _fl_helper(sqlitelockfile.SQLiteLockFile, "lockfile.sqlitelockfile", + *args, **kwds) + + +def locked(path, timeout=None): + """Decorator which enables locks for decorated function. + + Arguments: + - path: path for lockfile. + - timeout (optional): Timeout for acquiring lock. + + Usage: + @locked('/var/run/myname', timeout=0) + def myname(...): + ... + """ + def decor(func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + lock = FileLock(path, timeout=timeout) + lock.acquire() + try: + return func(*args, **kwargs) + finally: + lock.release() + return wrapper + return decor + + +if hasattr(os, "link"): + from . import linklockfile as _llf + LockFile = _llf.LinkLockFile +else: + from . import mkdirlockfile as _mlf + LockFile = _mlf.MkdirLockFile + +FileLock = LockFile diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.py new file mode 100644 index 0000000000000000000000000000000000000000..2ca9be0423591e61b3382b559473fcc56363cc46 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/linklockfile.py @@ -0,0 +1,73 @@ +from __future__ import absolute_import + +import time +import os + +from . import (LockBase, LockFailed, NotLocked, NotMyLock, LockTimeout, + AlreadyLocked) + + +class LinkLockFile(LockBase): + """Lock access to a file using atomic property of link(2). + + >>> lock = LinkLockFile('somefile') + >>> lock = LinkLockFile('somefile', threaded=False) + """ + + def acquire(self, timeout=None): + try: + open(self.unique_name, "wb").close() + except IOError: + raise LockFailed("failed to create %s" % self.unique_name) + + timeout = timeout if timeout is not None else self.timeout + end_time = time.time() + if timeout is not None and timeout > 0: + end_time += timeout + + while True: + # Try and create a hard link to it. + try: + os.link(self.unique_name, self.lock_file) + except OSError: + # Link creation failed. Maybe we've double-locked? + nlinks = os.stat(self.unique_name).st_nlink + if nlinks == 2: + # The original link plus the one I created == 2. We're + # good to go. + return + else: + # Otherwise the lock creation failed. + if timeout is not None and time.time() > end_time: + os.unlink(self.unique_name) + if timeout > 0: + raise LockTimeout("Timeout waiting to acquire" + " lock for %s" % + self.path) + else: + raise AlreadyLocked("%s is already locked" % + self.path) + time.sleep(timeout is not None and timeout / 10 or 0.1) + else: + # Link creation succeeded. We're good to go. + return + + def release(self): + if not self.is_locked(): + raise NotLocked("%s is not locked" % self.path) + elif not os.path.exists(self.unique_name): + raise NotMyLock("%s is locked, but not by me" % self.path) + os.unlink(self.unique_name) + os.unlink(self.lock_file) + + def is_locked(self): + return os.path.exists(self.lock_file) + + def i_am_locking(self): + return (self.is_locked() and + os.path.exists(self.unique_name) and + os.stat(self.unique_name).st_nlink == 2) + + def break_lock(self): + if os.path.exists(self.lock_file): + os.unlink(self.lock_file) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.py new file mode 100644 index 0000000000000000000000000000000000000000..05a8c96ca517271bbd4953d0cf83dc4173521b2e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/mkdirlockfile.py @@ -0,0 +1,84 @@ +from __future__ import absolute_import, division + +import time +import os +import sys +import errno + +from . import (LockBase, LockFailed, NotLocked, NotMyLock, LockTimeout, + AlreadyLocked) + + +class MkdirLockFile(LockBase): + """Lock file by creating a directory.""" + def __init__(self, path, threaded=True, timeout=None): + """ + >>> lock = MkdirLockFile('somefile') + >>> lock = MkdirLockFile('somefile', threaded=False) + """ + LockBase.__init__(self, path, threaded, timeout) + # Lock file itself is a directory. Place the unique file name into + # it. + self.unique_name = os.path.join(self.lock_file, + "%s.%s%s" % (self.hostname, + self.tname, + self.pid)) + + def acquire(self, timeout=None): + timeout = timeout if timeout is not None else self.timeout + end_time = time.time() + if timeout is not None and timeout > 0: + end_time += timeout + + if timeout is None: + wait = 0.1 + else: + wait = max(0, timeout / 10) + + while True: + try: + os.mkdir(self.lock_file) + except OSError: + err = sys.exc_info()[1] + if err.errno == errno.EEXIST: + # Already locked. + if os.path.exists(self.unique_name): + # Already locked by me. + return + if timeout is not None and time.time() > end_time: + if timeout > 0: + raise LockTimeout("Timeout waiting to acquire" + " lock for %s" % + self.path) + else: + # Someone else has the lock. + raise AlreadyLocked("%s is already locked" % + self.path) + time.sleep(wait) + else: + # Couldn't create the lock for some other reason + raise LockFailed("failed to create %s" % self.lock_file) + else: + open(self.unique_name, "wb").close() + return + + def release(self): + if not self.is_locked(): + raise NotLocked("%s is not locked" % self.path) + elif not os.path.exists(self.unique_name): + raise NotMyLock("%s is locked, but not by me" % self.path) + os.unlink(self.unique_name) + os.rmdir(self.lock_file) + + def is_locked(self): + return os.path.exists(self.lock_file) + + def i_am_locking(self): + return (self.is_locked() and + os.path.exists(self.unique_name)) + + def break_lock(self): + if os.path.exists(self.lock_file): + for name in os.listdir(self.lock_file): + os.unlink(os.path.join(self.lock_file, name)) + os.rmdir(self.lock_file) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.py new file mode 100644 index 0000000000000000000000000000000000000000..069e85b15bdfcb4fd7042222516fbfb046db06c9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/pidlockfile.py @@ -0,0 +1,190 @@ +# -*- coding: utf-8 -*- + +# pidlockfile.py +# +# Copyright © 2008–2009 Ben Finney +# +# This is free software: you may copy, modify, and/or distribute this work +# under the terms of the Python Software Foundation License, version 2 or +# later as published by the Python Software Foundation. +# No warranty expressed or implied. See the file LICENSE.PSF-2 for details. + +""" Lockfile behaviour implemented via Unix PID files. + """ + +from __future__ import absolute_import + +import errno +import os +import time + +from . import (LockBase, AlreadyLocked, LockFailed, NotLocked, NotMyLock, + LockTimeout) + + +class PIDLockFile(LockBase): + """ Lockfile implemented as a Unix PID file. + + The lock file is a normal file named by the attribute `path`. + A lock's PID file contains a single line of text, containing + the process ID (PID) of the process that acquired the lock. + + >>> lock = PIDLockFile('somefile') + >>> lock = PIDLockFile('somefile') + """ + + def __init__(self, path, threaded=False, timeout=None): + # pid lockfiles don't support threaded operation, so always force + # False as the threaded arg. + LockBase.__init__(self, path, False, timeout) + self.unique_name = self.path + + def read_pid(self): + """ Get the PID from the lock file. + """ + return read_pid_from_pidfile(self.path) + + def is_locked(self): + """ Test if the lock is currently held. + + The lock is held if the PID file for this lock exists. + + """ + return os.path.exists(self.path) + + def i_am_locking(self): + """ Test if the lock is held by the current process. + + Returns ``True`` if the current process ID matches the + number stored in the PID file. + """ + return self.is_locked() and os.getpid() == self.read_pid() + + def acquire(self, timeout=None): + """ Acquire the lock. + + Creates the PID file for this lock, or raises an error if + the lock could not be acquired. + """ + + timeout = timeout if timeout is not None else self.timeout + end_time = time.time() + if timeout is not None and timeout > 0: + end_time += timeout + + while True: + try: + write_pid_to_pidfile(self.path) + except OSError as exc: + if exc.errno == errno.EEXIST: + # The lock creation failed. Maybe sleep a bit. + if time.time() > end_time: + if timeout is not None and timeout > 0: + raise LockTimeout("Timeout waiting to acquire" + " lock for %s" % + self.path) + else: + raise AlreadyLocked("%s is already locked" % + self.path) + time.sleep(timeout is not None and timeout / 10 or 0.1) + else: + raise LockFailed("failed to create %s" % self.path) + else: + return + + def release(self): + """ Release the lock. + + Removes the PID file to release the lock, or raises an + error if the current process does not hold the lock. + + """ + if not self.is_locked(): + raise NotLocked("%s is not locked" % self.path) + if not self.i_am_locking(): + raise NotMyLock("%s is locked, but not by me" % self.path) + remove_existing_pidfile(self.path) + + def break_lock(self): + """ Break an existing lock. + + Removes the PID file if it already exists, otherwise does + nothing. + + """ + remove_existing_pidfile(self.path) + + +def read_pid_from_pidfile(pidfile_path): + """ Read the PID recorded in the named PID file. + + Read and return the numeric PID recorded as text in the named + PID file. If the PID file cannot be read, or if the content is + not a valid PID, return ``None``. + + """ + pid = None + try: + pidfile = open(pidfile_path, 'r') + except IOError: + pass + else: + # According to the FHS 2.3 section on PID files in /var/run: + # + # The file must consist of the process identifier in + # ASCII-encoded decimal, followed by a newline character. + # + # Programs that read PID files should be somewhat flexible + # in what they accept; i.e., they should ignore extra + # whitespace, leading zeroes, absence of the trailing + # newline, or additional lines in the PID file. + + line = pidfile.readline().strip() + try: + pid = int(line) + except ValueError: + pass + pidfile.close() + + return pid + + +def write_pid_to_pidfile(pidfile_path): + """ Write the PID in the named PID file. + + Get the numeric process ID (“PID”) of the current process + and write it to the named file as a line of text. + + """ + open_flags = (os.O_CREAT | os.O_EXCL | os.O_WRONLY) + open_mode = 0o644 + pidfile_fd = os.open(pidfile_path, open_flags, open_mode) + pidfile = os.fdopen(pidfile_fd, 'w') + + # According to the FHS 2.3 section on PID files in /var/run: + # + # The file must consist of the process identifier in + # ASCII-encoded decimal, followed by a newline character. For + # example, if crond was process number 25, /var/run/crond.pid + # would contain three characters: two, five, and newline. + + pid = os.getpid() + pidfile.write("%s\n" % pid) + pidfile.close() + + +def remove_existing_pidfile(pidfile_path): + """ Remove the named PID file if it exists. + + Removing a PID file that doesn't already exist puts us in the + desired state, so we ignore the condition if the file does not + exist. + + """ + try: + os.remove(pidfile_path) + except OSError as exc: + if exc.errno == errno.ENOENT: + pass + else: + raise diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.py new file mode 100644 index 0000000000000000000000000000000000000000..f997e2444e75b176761965bbf3e1f82c5c3ad0e2 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/sqlitelockfile.py @@ -0,0 +1,156 @@ +from __future__ import absolute_import, division + +import time +import os + +try: + unicode +except NameError: + unicode = str + +from . import LockBase, NotLocked, NotMyLock, LockTimeout, AlreadyLocked + + +class SQLiteLockFile(LockBase): + "Demonstrate SQL-based locking." + + testdb = None + + def __init__(self, path, threaded=True, timeout=None): + """ + >>> lock = SQLiteLockFile('somefile') + >>> lock = SQLiteLockFile('somefile', threaded=False) + """ + LockBase.__init__(self, path, threaded, timeout) + self.lock_file = unicode(self.lock_file) + self.unique_name = unicode(self.unique_name) + + if SQLiteLockFile.testdb is None: + import tempfile + _fd, testdb = tempfile.mkstemp() + os.close(_fd) + os.unlink(testdb) + del _fd, tempfile + SQLiteLockFile.testdb = testdb + + import sqlite3 + self.connection = sqlite3.connect(SQLiteLockFile.testdb) + + c = self.connection.cursor() + try: + c.execute("create table locks" + "(" + " lock_file varchar(32)," + " unique_name varchar(32)" + ")") + except sqlite3.OperationalError: + pass + else: + self.connection.commit() + import atexit + atexit.register(os.unlink, SQLiteLockFile.testdb) + + def acquire(self, timeout=None): + timeout = timeout if timeout is not None else self.timeout + end_time = time.time() + if timeout is not None and timeout > 0: + end_time += timeout + + if timeout is None: + wait = 0.1 + elif timeout <= 0: + wait = 0 + else: + wait = timeout / 10 + + cursor = self.connection.cursor() + + while True: + if not self.is_locked(): + # Not locked. Try to lock it. + cursor.execute("insert into locks" + " (lock_file, unique_name)" + " values" + " (?, ?)", + (self.lock_file, self.unique_name)) + self.connection.commit() + + # Check to see if we are the only lock holder. + cursor.execute("select * from locks" + " where unique_name = ?", + (self.unique_name,)) + rows = cursor.fetchall() + if len(rows) > 1: + # Nope. Someone else got there. Remove our lock. + cursor.execute("delete from locks" + " where unique_name = ?", + (self.unique_name,)) + self.connection.commit() + else: + # Yup. We're done, so go home. + return + else: + # Check to see if we are the only lock holder. + cursor.execute("select * from locks" + " where unique_name = ?", + (self.unique_name,)) + rows = cursor.fetchall() + if len(rows) == 1: + # We're the locker, so go home. + return + + # Maybe we should wait a bit longer. + if timeout is not None and time.time() > end_time: + if timeout > 0: + # No more waiting. + raise LockTimeout("Timeout waiting to acquire" + " lock for %s" % + self.path) + else: + # Someone else has the lock and we are impatient.. + raise AlreadyLocked("%s is already locked" % self.path) + + # Well, okay. We'll give it a bit longer. + time.sleep(wait) + + def release(self): + if not self.is_locked(): + raise NotLocked("%s is not locked" % self.path) + if not self.i_am_locking(): + raise NotMyLock("%s is locked, but not by me (by %s)" % + (self.unique_name, self._who_is_locking())) + cursor = self.connection.cursor() + cursor.execute("delete from locks" + " where unique_name = ?", + (self.unique_name,)) + self.connection.commit() + + def _who_is_locking(self): + cursor = self.connection.cursor() + cursor.execute("select unique_name from locks" + " where lock_file = ?", + (self.lock_file,)) + return cursor.fetchone()[0] + + def is_locked(self): + cursor = self.connection.cursor() + cursor.execute("select * from locks" + " where lock_file = ?", + (self.lock_file,)) + rows = cursor.fetchall() + return not not rows + + def i_am_locking(self): + cursor = self.connection.cursor() + cursor.execute("select * from locks" + " where lock_file = ?" + " and unique_name = ?", + (self.lock_file, self.unique_name)) + return not not cursor.fetchall() + + def break_lock(self): + cursor = self.connection.cursor() + cursor.execute("delete from locks" + " where lock_file = ?", + (self.lock_file,)) + self.connection.commit() diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.py new file mode 100644 index 0000000000000000000000000000000000000000..23b41f582b9f8d40a1375b47ed1fb25da12d0c3b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/lockfile/symlinklockfile.py @@ -0,0 +1,70 @@ +from __future__ import absolute_import + +import os +import time + +from . import (LockBase, NotLocked, NotMyLock, LockTimeout, + AlreadyLocked) + + +class SymlinkLockFile(LockBase): + """Lock access to a file using symlink(2).""" + + def __init__(self, path, threaded=True, timeout=None): + # super(SymlinkLockFile).__init(...) + LockBase.__init__(self, path, threaded, timeout) + # split it back! + self.unique_name = os.path.split(self.unique_name)[1] + + def acquire(self, timeout=None): + # Hopefully unnecessary for symlink. + # try: + # open(self.unique_name, "wb").close() + # except IOError: + # raise LockFailed("failed to create %s" % self.unique_name) + timeout = timeout if timeout is not None else self.timeout + end_time = time.time() + if timeout is not None and timeout > 0: + end_time += timeout + + while True: + # Try and create a symbolic link to it. + try: + os.symlink(self.unique_name, self.lock_file) + except OSError: + # Link creation failed. Maybe we've double-locked? + if self.i_am_locking(): + # Linked to out unique name. Proceed. + return + else: + # Otherwise the lock creation failed. + if timeout is not None and time.time() > end_time: + if timeout > 0: + raise LockTimeout("Timeout waiting to acquire" + " lock for %s" % + self.path) + else: + raise AlreadyLocked("%s is already locked" % + self.path) + time.sleep(timeout / 10 if timeout is not None else 0.1) + else: + # Link creation succeeded. We're good to go. + return + + def release(self): + if not self.is_locked(): + raise NotLocked("%s is not locked" % self.path) + elif not self.i_am_locking(): + raise NotMyLock("%s is locked, but not by me" % self.path) + os.unlink(self.lock_file) + + def is_locked(self): + return os.path.islink(self.lock_file) + + def i_am_locking(self): + return (os.path.islink(self.lock_file) + and os.readlink(self.lock_file) == self.unique_name) + + def break_lock(self): + if os.path.islink(self.lock_file): # exists && link + os.unlink(self.lock_file) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..b32650755808e9b386c64aee8ef8b756bfa30e93 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/__init__.py @@ -0,0 +1,65 @@ +# coding: utf-8 +from pip._vendor.msgpack._version import version +from pip._vendor.msgpack.exceptions import * + +from collections import namedtuple + + +class ExtType(namedtuple('ExtType', 'code data')): + """ExtType represents ext type in msgpack.""" + def __new__(cls, code, data): + if not isinstance(code, int): + raise TypeError("code must be int") + if not isinstance(data, bytes): + raise TypeError("data must be bytes") + if not 0 <= code <= 127: + raise ValueError("code must be 0~127") + return super(ExtType, cls).__new__(cls, code, data) + + +import os +if os.environ.get('MSGPACK_PUREPYTHON'): + from pip._vendor.msgpack.fallback import Packer, unpackb, Unpacker +else: + try: + from pip._vendor.msgpack._cmsgpack import Packer, unpackb, Unpacker + except ImportError: + from pip._vendor.msgpack.fallback import Packer, unpackb, Unpacker + + +def pack(o, stream, **kwargs): + """ + Pack object `o` and write it to `stream` + + See :class:`Packer` for options. + """ + packer = Packer(**kwargs) + stream.write(packer.pack(o)) + + +def packb(o, **kwargs): + """ + Pack object `o` and return packed bytes + + See :class:`Packer` for options. + """ + return Packer(**kwargs).pack(o) + + +def unpack(stream, **kwargs): + """ + Unpack an object from `stream`. + + Raises `ExtraData` when `stream` contains extra bytes. + See :class:`Unpacker` for options. + """ + data = stream.read() + return unpackb(data, **kwargs) + + +# alias for compatibility to simplejson/marshal/pickle. +load = unpack +loads = unpackb + +dump = pack +dumps = packb diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/_version.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/_version.py new file mode 100644 index 0000000000000000000000000000000000000000..926c5e7b02b8974f160f06584d2ece945d319721 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/_version.py @@ -0,0 +1 @@ +version = (0, 6, 1) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/exceptions.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..d6d2615cfdd0b914d064cdf7eecd45761e4bcaf6 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/exceptions.py @@ -0,0 +1,48 @@ +class UnpackException(Exception): + """Base class for some exceptions raised while unpacking. + + NOTE: unpack may raise exception other than subclass of + UnpackException. If you want to catch all error, catch + Exception instead. + """ + + +class BufferFull(UnpackException): + pass + + +class OutOfData(UnpackException): + pass + + +class FormatError(ValueError, UnpackException): + """Invalid msgpack format""" + + +class StackError(ValueError, UnpackException): + """Too nested""" + + +# Deprecated. Use ValueError instead +UnpackValueError = ValueError + + +class ExtraData(UnpackValueError): + """ExtraData is raised when there is trailing data. + + This exception is raised while only one-shot (not streaming) + unpack. + """ + + def __init__(self, unpacked, extra): + self.unpacked = unpacked + self.extra = extra + + def __str__(self): + return "unpack(b) received extra data." + + +# Deprecated. Use Exception instead to catch all exception during packing. +PackException = Exception +PackValueError = ValueError +PackOverflowError = OverflowError diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/fallback.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/fallback.py new file mode 100644 index 0000000000000000000000000000000000000000..5b731dddab75d24c70e4baf340da3f4b82491153 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/msgpack/fallback.py @@ -0,0 +1,1027 @@ +"""Fallback pure Python implementation of msgpack""" + +import sys +import struct +import warnings + + +if sys.version_info[0] == 2: + PY2 = True + int_types = (int, long) + def dict_iteritems(d): + return d.iteritems() +else: + PY2 = False + int_types = int + unicode = str + xrange = range + def dict_iteritems(d): + return d.items() + +if sys.version_info < (3, 5): + # Ugly hack... + RecursionError = RuntimeError + + def _is_recursionerror(e): + return len(e.args) == 1 and isinstance(e.args[0], str) and \ + e.args[0].startswith('maximum recursion depth exceeded') +else: + def _is_recursionerror(e): + return True + +if hasattr(sys, 'pypy_version_info'): + # cStringIO is slow on PyPy, StringIO is faster. However: PyPy's own + # StringBuilder is fastest. + from __pypy__ import newlist_hint + try: + from __pypy__.builders import BytesBuilder as StringBuilder + except ImportError: + from __pypy__.builders import StringBuilder + USING_STRINGBUILDER = True + class StringIO(object): + def __init__(self, s=b''): + if s: + self.builder = StringBuilder(len(s)) + self.builder.append(s) + else: + self.builder = StringBuilder() + def write(self, s): + if isinstance(s, memoryview): + s = s.tobytes() + elif isinstance(s, bytearray): + s = bytes(s) + self.builder.append(s) + def getvalue(self): + return self.builder.build() +else: + USING_STRINGBUILDER = False + from io import BytesIO as StringIO + newlist_hint = lambda size: [] + + +from pip._vendor.msgpack.exceptions import ( + BufferFull, + OutOfData, + ExtraData, + FormatError, + StackError, +) + +from pip._vendor.msgpack import ExtType + + +EX_SKIP = 0 +EX_CONSTRUCT = 1 +EX_READ_ARRAY_HEADER = 2 +EX_READ_MAP_HEADER = 3 + +TYPE_IMMEDIATE = 0 +TYPE_ARRAY = 1 +TYPE_MAP = 2 +TYPE_RAW = 3 +TYPE_BIN = 4 +TYPE_EXT = 5 + +DEFAULT_RECURSE_LIMIT = 511 + + +def _check_type_strict(obj, t, type=type, tuple=tuple): + if type(t) is tuple: + return type(obj) in t + else: + return type(obj) is t + + +def _get_data_from_buffer(obj): + try: + view = memoryview(obj) + except TypeError: + # try to use legacy buffer protocol if 2.7, otherwise re-raise + if PY2: + view = memoryview(buffer(obj)) + warnings.warn("using old buffer interface to unpack %s; " + "this leads to unpacking errors if slicing is used and " + "will be removed in a future version" % type(obj), + RuntimeWarning, stacklevel=3) + else: + raise + if view.itemsize != 1: + raise ValueError("cannot unpack from multi-byte object") + return view + + +def unpack(stream, **kwargs): + warnings.warn( + "Direct calling implementation's unpack() is deprecated, Use msgpack.unpack() or unpackb() instead.", + DeprecationWarning, stacklevel=2) + data = stream.read() + return unpackb(data, **kwargs) + + +def unpackb(packed, **kwargs): + """ + Unpack an object from `packed`. + + Raises ``ExtraData`` when *packed* contains extra bytes. + Raises ``ValueError`` when *packed* is incomplete. + Raises ``FormatError`` when *packed* is not valid msgpack. + Raises ``StackError`` when *packed* contains too nested. + Other exceptions can be raised during unpacking. + + See :class:`Unpacker` for options. + """ + unpacker = Unpacker(None, max_buffer_size=len(packed), **kwargs) + unpacker.feed(packed) + try: + ret = unpacker._unpack() + except OutOfData: + raise ValueError("Unpack failed: incomplete input") + except RecursionError as e: + if _is_recursionerror(e): + raise StackError + raise + if unpacker._got_extradata(): + raise ExtraData(ret, unpacker._get_extradata()) + return ret + + +if sys.version_info < (2, 7, 6): + def _unpack_from(f, b, o=0): + """Explicit typcast for legacy struct.unpack_from""" + return struct.unpack_from(f, bytes(b), o) +else: + _unpack_from = struct.unpack_from + + +class Unpacker(object): + """Streaming unpacker. + + arguments: + + :param file_like: + File-like object having `.read(n)` method. + If specified, unpacker reads serialized data from it and :meth:`feed()` is not usable. + + :param int read_size: + Used as `file_like.read(read_size)`. (default: `min(16*1024, max_buffer_size)`) + + :param bool use_list: + If true, unpack msgpack array to Python list. + Otherwise, unpack to Python tuple. (default: True) + + :param bool raw: + If true, unpack msgpack raw to Python bytes (default). + Otherwise, unpack to Python str (or unicode on Python 2) by decoding + with UTF-8 encoding (recommended). + Currently, the default is true, but it will be changed to false in + near future. So you must specify it explicitly for keeping backward + compatibility. + + *encoding* option which is deprecated overrides this option. + + :param bool strict_map_key: + If true, only str or bytes are accepted for map (dict) keys. + It's False by default for backward-compatibility. + But it will be True from msgpack 1.0. + + :param callable object_hook: + When specified, it should be callable. + Unpacker calls it with a dict argument after unpacking msgpack map. + (See also simplejson) + + :param callable object_pairs_hook: + When specified, it should be callable. + Unpacker calls it with a list of key-value pairs after unpacking msgpack map. + (See also simplejson) + + :param str encoding: + Encoding used for decoding msgpack raw. + If it is None (default), msgpack raw is deserialized to Python bytes. + + :param str unicode_errors: + (deprecated) Used for decoding msgpack raw with *encoding*. + (default: `'strict'`) + + :param int max_buffer_size: + Limits size of data waiting unpacked. 0 means system's INT_MAX (default). + Raises `BufferFull` exception when it is insufficient. + You should set this parameter when unpacking data from untrusted source. + + :param int max_str_len: + Deprecated, use *max_buffer_size* instead. + Limits max length of str. (default: max_buffer_size or 1024*1024) + + :param int max_bin_len: + Deprecated, use *max_buffer_size* instead. + Limits max length of bin. (default: max_buffer_size or 1024*1024) + + :param int max_array_len: + Limits max length of array. + (default: max_buffer_size or 128*1024) + + :param int max_map_len: + Limits max length of map. + (default: max_buffer_size//2 or 32*1024) + + :param int max_ext_len: + Deprecated, use *max_buffer_size* instead. + Limits max size of ext type. (default: max_buffer_size or 1024*1024) + + Example of streaming deserialize from file-like object:: + + unpacker = Unpacker(file_like, raw=False, max_buffer_size=10*1024*1024) + for o in unpacker: + process(o) + + Example of streaming deserialize from socket:: + + unpacker = Unpacker(raw=False, max_buffer_size=10*1024*1024) + while True: + buf = sock.recv(1024**2) + if not buf: + break + unpacker.feed(buf) + for o in unpacker: + process(o) + + Raises ``ExtraData`` when *packed* contains extra bytes. + Raises ``OutOfData`` when *packed* is incomplete. + Raises ``FormatError`` when *packed* is not valid msgpack. + Raises ``StackError`` when *packed* contains too nested. + Other exceptions can be raised during unpacking. + """ + + def __init__(self, file_like=None, read_size=0, use_list=True, raw=True, strict_map_key=False, + object_hook=None, object_pairs_hook=None, list_hook=None, + encoding=None, unicode_errors=None, max_buffer_size=0, + ext_hook=ExtType, + max_str_len=-1, + max_bin_len=-1, + max_array_len=-1, + max_map_len=-1, + max_ext_len=-1): + if encoding is not None: + warnings.warn( + "encoding is deprecated, Use raw=False instead.", + DeprecationWarning, stacklevel=2) + + if unicode_errors is None: + unicode_errors = 'strict' + + if file_like is None: + self._feeding = True + else: + if not callable(file_like.read): + raise TypeError("`file_like.read` must be callable") + self.file_like = file_like + self._feeding = False + + #: array of bytes fed. + self._buffer = bytearray() + #: Which position we currently reads + self._buff_i = 0 + + # When Unpacker is used as an iterable, between the calls to next(), + # the buffer is not "consumed" completely, for efficiency sake. + # Instead, it is done sloppily. To make sure we raise BufferFull at + # the correct moments, we have to keep track of how sloppy we were. + # Furthermore, when the buffer is incomplete (that is: in the case + # we raise an OutOfData) we need to rollback the buffer to the correct + # state, which _buf_checkpoint records. + self._buf_checkpoint = 0 + + if max_str_len == -1: + max_str_len = max_buffer_size or 1024*1024 + if max_bin_len == -1: + max_bin_len = max_buffer_size or 1024*1024 + if max_array_len == -1: + max_array_len = max_buffer_size or 128*1024 + if max_map_len == -1: + max_map_len = max_buffer_size//2 or 32*1024 + if max_ext_len == -1: + max_ext_len = max_buffer_size or 1024*1024 + + self._max_buffer_size = max_buffer_size or 2**31-1 + if read_size > self._max_buffer_size: + raise ValueError("read_size must be smaller than max_buffer_size") + self._read_size = read_size or min(self._max_buffer_size, 16*1024) + self._raw = bool(raw) + self._strict_map_key = bool(strict_map_key) + self._encoding = encoding + self._unicode_errors = unicode_errors + self._use_list = use_list + self._list_hook = list_hook + self._object_hook = object_hook + self._object_pairs_hook = object_pairs_hook + self._ext_hook = ext_hook + self._max_str_len = max_str_len + self._max_bin_len = max_bin_len + self._max_array_len = max_array_len + self._max_map_len = max_map_len + self._max_ext_len = max_ext_len + self._stream_offset = 0 + + if list_hook is not None and not callable(list_hook): + raise TypeError('`list_hook` is not callable') + if object_hook is not None and not callable(object_hook): + raise TypeError('`object_hook` is not callable') + if object_pairs_hook is not None and not callable(object_pairs_hook): + raise TypeError('`object_pairs_hook` is not callable') + if object_hook is not None and object_pairs_hook is not None: + raise TypeError("object_pairs_hook and object_hook are mutually " + "exclusive") + if not callable(ext_hook): + raise TypeError("`ext_hook` is not callable") + + def feed(self, next_bytes): + assert self._feeding + view = _get_data_from_buffer(next_bytes) + if (len(self._buffer) - self._buff_i + len(view) > self._max_buffer_size): + raise BufferFull + + # Strip buffer before checkpoint before reading file. + if self._buf_checkpoint > 0: + del self._buffer[:self._buf_checkpoint] + self._buff_i -= self._buf_checkpoint + self._buf_checkpoint = 0 + + # Use extend here: INPLACE_ADD += doesn't reliably typecast memoryview in jython + self._buffer.extend(view) + + def _consume(self): + """ Gets rid of the used parts of the buffer. """ + self._stream_offset += self._buff_i - self._buf_checkpoint + self._buf_checkpoint = self._buff_i + + def _got_extradata(self): + return self._buff_i < len(self._buffer) + + def _get_extradata(self): + return self._buffer[self._buff_i:] + + def read_bytes(self, n): + return self._read(n) + + def _read(self, n): + # (int) -> bytearray + self._reserve(n) + i = self._buff_i + self._buff_i = i+n + return self._buffer[i:i+n] + + def _reserve(self, n): + remain_bytes = len(self._buffer) - self._buff_i - n + + # Fast path: buffer has n bytes already + if remain_bytes >= 0: + return + + if self._feeding: + self._buff_i = self._buf_checkpoint + raise OutOfData + + # Strip buffer before checkpoint before reading file. + if self._buf_checkpoint > 0: + del self._buffer[:self._buf_checkpoint] + self._buff_i -= self._buf_checkpoint + self._buf_checkpoint = 0 + + # Read from file + remain_bytes = -remain_bytes + while remain_bytes > 0: + to_read_bytes = max(self._read_size, remain_bytes) + read_data = self.file_like.read(to_read_bytes) + if not read_data: + break + assert isinstance(read_data, bytes) + self._buffer += read_data + remain_bytes -= len(read_data) + + if len(self._buffer) < n + self._buff_i: + self._buff_i = 0 # rollback + raise OutOfData + + def _read_header(self, execute=EX_CONSTRUCT): + typ = TYPE_IMMEDIATE + n = 0 + obj = None + self._reserve(1) + b = self._buffer[self._buff_i] + self._buff_i += 1 + if b & 0b10000000 == 0: + obj = b + elif b & 0b11100000 == 0b11100000: + obj = -1 - (b ^ 0xff) + elif b & 0b11100000 == 0b10100000: + n = b & 0b00011111 + typ = TYPE_RAW + if n > self._max_str_len: + raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) + obj = self._read(n) + elif b & 0b11110000 == 0b10010000: + n = b & 0b00001111 + typ = TYPE_ARRAY + if n > self._max_array_len: + raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len) + elif b & 0b11110000 == 0b10000000: + n = b & 0b00001111 + typ = TYPE_MAP + if n > self._max_map_len: + raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len) + elif b == 0xc0: + obj = None + elif b == 0xc2: + obj = False + elif b == 0xc3: + obj = True + elif b == 0xc4: + typ = TYPE_BIN + self._reserve(1) + n = self._buffer[self._buff_i] + self._buff_i += 1 + if n > self._max_bin_len: + raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len)) + obj = self._read(n) + elif b == 0xc5: + typ = TYPE_BIN + self._reserve(2) + n = _unpack_from(">H", self._buffer, self._buff_i)[0] + self._buff_i += 2 + if n > self._max_bin_len: + raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len)) + obj = self._read(n) + elif b == 0xc6: + typ = TYPE_BIN + self._reserve(4) + n = _unpack_from(">I", self._buffer, self._buff_i)[0] + self._buff_i += 4 + if n > self._max_bin_len: + raise ValueError("%s exceeds max_bin_len(%s)" % (n, self._max_bin_len)) + obj = self._read(n) + elif b == 0xc7: # ext 8 + typ = TYPE_EXT + self._reserve(2) + L, n = _unpack_from('Bb', self._buffer, self._buff_i) + self._buff_i += 2 + if L > self._max_ext_len: + raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len)) + obj = self._read(L) + elif b == 0xc8: # ext 16 + typ = TYPE_EXT + self._reserve(3) + L, n = _unpack_from('>Hb', self._buffer, self._buff_i) + self._buff_i += 3 + if L > self._max_ext_len: + raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len)) + obj = self._read(L) + elif b == 0xc9: # ext 32 + typ = TYPE_EXT + self._reserve(5) + L, n = _unpack_from('>Ib', self._buffer, self._buff_i) + self._buff_i += 5 + if L > self._max_ext_len: + raise ValueError("%s exceeds max_ext_len(%s)" % (L, self._max_ext_len)) + obj = self._read(L) + elif b == 0xca: + self._reserve(4) + obj = _unpack_from(">f", self._buffer, self._buff_i)[0] + self._buff_i += 4 + elif b == 0xcb: + self._reserve(8) + obj = _unpack_from(">d", self._buffer, self._buff_i)[0] + self._buff_i += 8 + elif b == 0xcc: + self._reserve(1) + obj = self._buffer[self._buff_i] + self._buff_i += 1 + elif b == 0xcd: + self._reserve(2) + obj = _unpack_from(">H", self._buffer, self._buff_i)[0] + self._buff_i += 2 + elif b == 0xce: + self._reserve(4) + obj = _unpack_from(">I", self._buffer, self._buff_i)[0] + self._buff_i += 4 + elif b == 0xcf: + self._reserve(8) + obj = _unpack_from(">Q", self._buffer, self._buff_i)[0] + self._buff_i += 8 + elif b == 0xd0: + self._reserve(1) + obj = _unpack_from("b", self._buffer, self._buff_i)[0] + self._buff_i += 1 + elif b == 0xd1: + self._reserve(2) + obj = _unpack_from(">h", self._buffer, self._buff_i)[0] + self._buff_i += 2 + elif b == 0xd2: + self._reserve(4) + obj = _unpack_from(">i", self._buffer, self._buff_i)[0] + self._buff_i += 4 + elif b == 0xd3: + self._reserve(8) + obj = _unpack_from(">q", self._buffer, self._buff_i)[0] + self._buff_i += 8 + elif b == 0xd4: # fixext 1 + typ = TYPE_EXT + if self._max_ext_len < 1: + raise ValueError("%s exceeds max_ext_len(%s)" % (1, self._max_ext_len)) + self._reserve(2) + n, obj = _unpack_from("b1s", self._buffer, self._buff_i) + self._buff_i += 2 + elif b == 0xd5: # fixext 2 + typ = TYPE_EXT + if self._max_ext_len < 2: + raise ValueError("%s exceeds max_ext_len(%s)" % (2, self._max_ext_len)) + self._reserve(3) + n, obj = _unpack_from("b2s", self._buffer, self._buff_i) + self._buff_i += 3 + elif b == 0xd6: # fixext 4 + typ = TYPE_EXT + if self._max_ext_len < 4: + raise ValueError("%s exceeds max_ext_len(%s)" % (4, self._max_ext_len)) + self._reserve(5) + n, obj = _unpack_from("b4s", self._buffer, self._buff_i) + self._buff_i += 5 + elif b == 0xd7: # fixext 8 + typ = TYPE_EXT + if self._max_ext_len < 8: + raise ValueError("%s exceeds max_ext_len(%s)" % (8, self._max_ext_len)) + self._reserve(9) + n, obj = _unpack_from("b8s", self._buffer, self._buff_i) + self._buff_i += 9 + elif b == 0xd8: # fixext 16 + typ = TYPE_EXT + if self._max_ext_len < 16: + raise ValueError("%s exceeds max_ext_len(%s)" % (16, self._max_ext_len)) + self._reserve(17) + n, obj = _unpack_from("b16s", self._buffer, self._buff_i) + self._buff_i += 17 + elif b == 0xd9: + typ = TYPE_RAW + self._reserve(1) + n = self._buffer[self._buff_i] + self._buff_i += 1 + if n > self._max_str_len: + raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) + obj = self._read(n) + elif b == 0xda: + typ = TYPE_RAW + self._reserve(2) + n, = _unpack_from(">H", self._buffer, self._buff_i) + self._buff_i += 2 + if n > self._max_str_len: + raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) + obj = self._read(n) + elif b == 0xdb: + typ = TYPE_RAW + self._reserve(4) + n, = _unpack_from(">I", self._buffer, self._buff_i) + self._buff_i += 4 + if n > self._max_str_len: + raise ValueError("%s exceeds max_str_len(%s)", n, self._max_str_len) + obj = self._read(n) + elif b == 0xdc: + typ = TYPE_ARRAY + self._reserve(2) + n, = _unpack_from(">H", self._buffer, self._buff_i) + self._buff_i += 2 + if n > self._max_array_len: + raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len) + elif b == 0xdd: + typ = TYPE_ARRAY + self._reserve(4) + n, = _unpack_from(">I", self._buffer, self._buff_i) + self._buff_i += 4 + if n > self._max_array_len: + raise ValueError("%s exceeds max_array_len(%s)", n, self._max_array_len) + elif b == 0xde: + self._reserve(2) + n, = _unpack_from(">H", self._buffer, self._buff_i) + self._buff_i += 2 + if n > self._max_map_len: + raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len) + typ = TYPE_MAP + elif b == 0xdf: + self._reserve(4) + n, = _unpack_from(">I", self._buffer, self._buff_i) + self._buff_i += 4 + if n > self._max_map_len: + raise ValueError("%s exceeds max_map_len(%s)", n, self._max_map_len) + typ = TYPE_MAP + else: + raise FormatError("Unknown header: 0x%x" % b) + return typ, n, obj + + def _unpack(self, execute=EX_CONSTRUCT): + typ, n, obj = self._read_header(execute) + + if execute == EX_READ_ARRAY_HEADER: + if typ != TYPE_ARRAY: + raise ValueError("Expected array") + return n + if execute == EX_READ_MAP_HEADER: + if typ != TYPE_MAP: + raise ValueError("Expected map") + return n + # TODO should we eliminate the recursion? + if typ == TYPE_ARRAY: + if execute == EX_SKIP: + for i in xrange(n): + # TODO check whether we need to call `list_hook` + self._unpack(EX_SKIP) + return + ret = newlist_hint(n) + for i in xrange(n): + ret.append(self._unpack(EX_CONSTRUCT)) + if self._list_hook is not None: + ret = self._list_hook(ret) + # TODO is the interaction between `list_hook` and `use_list` ok? + return ret if self._use_list else tuple(ret) + if typ == TYPE_MAP: + if execute == EX_SKIP: + for i in xrange(n): + # TODO check whether we need to call hooks + self._unpack(EX_SKIP) + self._unpack(EX_SKIP) + return + if self._object_pairs_hook is not None: + ret = self._object_pairs_hook( + (self._unpack(EX_CONSTRUCT), + self._unpack(EX_CONSTRUCT)) + for _ in xrange(n)) + else: + ret = {} + for _ in xrange(n): + key = self._unpack(EX_CONSTRUCT) + if self._strict_map_key and type(key) not in (unicode, bytes): + raise ValueError("%s is not allowed for map key" % str(type(key))) + ret[key] = self._unpack(EX_CONSTRUCT) + if self._object_hook is not None: + ret = self._object_hook(ret) + return ret + if execute == EX_SKIP: + return + if typ == TYPE_RAW: + if self._encoding is not None: + obj = obj.decode(self._encoding, self._unicode_errors) + elif self._raw: + obj = bytes(obj) + else: + obj = obj.decode('utf_8') + return obj + if typ == TYPE_EXT: + return self._ext_hook(n, bytes(obj)) + if typ == TYPE_BIN: + return bytes(obj) + assert typ == TYPE_IMMEDIATE + return obj + + def __iter__(self): + return self + + def __next__(self): + try: + ret = self._unpack(EX_CONSTRUCT) + self._consume() + return ret + except OutOfData: + self._consume() + raise StopIteration + except RecursionError: + raise StackError + + next = __next__ + + def skip(self): + self._unpack(EX_SKIP) + self._consume() + + def unpack(self): + try: + ret = self._unpack(EX_CONSTRUCT) + except RecursionError: + raise StackError + self._consume() + return ret + + def read_array_header(self): + ret = self._unpack(EX_READ_ARRAY_HEADER) + self._consume() + return ret + + def read_map_header(self): + ret = self._unpack(EX_READ_MAP_HEADER) + self._consume() + return ret + + def tell(self): + return self._stream_offset + + +class Packer(object): + """ + MessagePack Packer + + usage: + + packer = Packer() + astream.write(packer.pack(a)) + astream.write(packer.pack(b)) + + Packer's constructor has some keyword arguments: + + :param callable default: + Convert user type to builtin type that Packer supports. + See also simplejson's document. + + :param bool use_single_float: + Use single precision float type for float. (default: False) + + :param bool autoreset: + Reset buffer after each pack and return its content as `bytes`. (default: True). + If set this to false, use `bytes()` to get content and `.reset()` to clear buffer. + + :param bool use_bin_type: + Use bin type introduced in msgpack spec 2.0 for bytes. + It also enables str8 type for unicode. + + :param bool strict_types: + If set to true, types will be checked to be exact. Derived classes + from serializeable types will not be serialized and will be + treated as unsupported type and forwarded to default. + Additionally tuples will not be serialized as lists. + This is useful when trying to implement accurate serialization + for python types. + + :param str encoding: + (deprecated) Convert unicode to bytes with this encoding. (default: 'utf-8') + + :param str unicode_errors: + Error handler for encoding unicode. (default: 'strict') + """ + def __init__(self, default=None, encoding=None, unicode_errors=None, + use_single_float=False, autoreset=True, use_bin_type=False, + strict_types=False): + if encoding is None: + encoding = 'utf_8' + else: + warnings.warn( + "encoding is deprecated, Use raw=False instead.", + DeprecationWarning, stacklevel=2) + + if unicode_errors is None: + unicode_errors = 'strict' + + self._strict_types = strict_types + self._use_float = use_single_float + self._autoreset = autoreset + self._use_bin_type = use_bin_type + self._encoding = encoding + self._unicode_errors = unicode_errors + self._buffer = StringIO() + if default is not None: + if not callable(default): + raise TypeError("default must be callable") + self._default = default + + def _pack(self, obj, nest_limit=DEFAULT_RECURSE_LIMIT, + check=isinstance, check_type_strict=_check_type_strict): + default_used = False + if self._strict_types: + check = check_type_strict + list_types = list + else: + list_types = (list, tuple) + while True: + if nest_limit < 0: + raise ValueError("recursion limit exceeded") + if obj is None: + return self._buffer.write(b"\xc0") + if check(obj, bool): + if obj: + return self._buffer.write(b"\xc3") + return self._buffer.write(b"\xc2") + if check(obj, int_types): + if 0 <= obj < 0x80: + return self._buffer.write(struct.pack("B", obj)) + if -0x20 <= obj < 0: + return self._buffer.write(struct.pack("b", obj)) + if 0x80 <= obj <= 0xff: + return self._buffer.write(struct.pack("BB", 0xcc, obj)) + if -0x80 <= obj < 0: + return self._buffer.write(struct.pack(">Bb", 0xd0, obj)) + if 0xff < obj <= 0xffff: + return self._buffer.write(struct.pack(">BH", 0xcd, obj)) + if -0x8000 <= obj < -0x80: + return self._buffer.write(struct.pack(">Bh", 0xd1, obj)) + if 0xffff < obj <= 0xffffffff: + return self._buffer.write(struct.pack(">BI", 0xce, obj)) + if -0x80000000 <= obj < -0x8000: + return self._buffer.write(struct.pack(">Bi", 0xd2, obj)) + if 0xffffffff < obj <= 0xffffffffffffffff: + return self._buffer.write(struct.pack(">BQ", 0xcf, obj)) + if -0x8000000000000000 <= obj < -0x80000000: + return self._buffer.write(struct.pack(">Bq", 0xd3, obj)) + if not default_used and self._default is not None: + obj = self._default(obj) + default_used = True + continue + raise OverflowError("Integer value out of range") + if check(obj, (bytes, bytearray)): + n = len(obj) + if n >= 2**32: + raise ValueError("%s is too large" % type(obj).__name__) + self._pack_bin_header(n) + return self._buffer.write(obj) + if check(obj, unicode): + if self._encoding is None: + raise TypeError( + "Can't encode unicode string: " + "no encoding is specified") + obj = obj.encode(self._encoding, self._unicode_errors) + n = len(obj) + if n >= 2**32: + raise ValueError("String is too large") + self._pack_raw_header(n) + return self._buffer.write(obj) + if check(obj, memoryview): + n = len(obj) * obj.itemsize + if n >= 2**32: + raise ValueError("Memoryview is too large") + self._pack_bin_header(n) + return self._buffer.write(obj) + if check(obj, float): + if self._use_float: + return self._buffer.write(struct.pack(">Bf", 0xca, obj)) + return self._buffer.write(struct.pack(">Bd", 0xcb, obj)) + if check(obj, ExtType): + code = obj.code + data = obj.data + assert isinstance(code, int) + assert isinstance(data, bytes) + L = len(data) + if L == 1: + self._buffer.write(b'\xd4') + elif L == 2: + self._buffer.write(b'\xd5') + elif L == 4: + self._buffer.write(b'\xd6') + elif L == 8: + self._buffer.write(b'\xd7') + elif L == 16: + self._buffer.write(b'\xd8') + elif L <= 0xff: + self._buffer.write(struct.pack(">BB", 0xc7, L)) + elif L <= 0xffff: + self._buffer.write(struct.pack(">BH", 0xc8, L)) + else: + self._buffer.write(struct.pack(">BI", 0xc9, L)) + self._buffer.write(struct.pack("b", code)) + self._buffer.write(data) + return + if check(obj, list_types): + n = len(obj) + self._pack_array_header(n) + for i in xrange(n): + self._pack(obj[i], nest_limit - 1) + return + if check(obj, dict): + return self._pack_map_pairs(len(obj), dict_iteritems(obj), + nest_limit - 1) + if not default_used and self._default is not None: + obj = self._default(obj) + default_used = 1 + continue + raise TypeError("Cannot serialize %r" % (obj, )) + + def pack(self, obj): + try: + self._pack(obj) + except: + self._buffer = StringIO() # force reset + raise + if self._autoreset: + ret = self._buffer.getvalue() + self._buffer = StringIO() + return ret + + def pack_map_pairs(self, pairs): + self._pack_map_pairs(len(pairs), pairs) + if self._autoreset: + ret = self._buffer.getvalue() + self._buffer = StringIO() + return ret + + def pack_array_header(self, n): + if n >= 2**32: + raise ValueError + self._pack_array_header(n) + if self._autoreset: + ret = self._buffer.getvalue() + self._buffer = StringIO() + return ret + + def pack_map_header(self, n): + if n >= 2**32: + raise ValueError + self._pack_map_header(n) + if self._autoreset: + ret = self._buffer.getvalue() + self._buffer = StringIO() + return ret + + def pack_ext_type(self, typecode, data): + if not isinstance(typecode, int): + raise TypeError("typecode must have int type.") + if not 0 <= typecode <= 127: + raise ValueError("typecode should be 0-127") + if not isinstance(data, bytes): + raise TypeError("data must have bytes type") + L = len(data) + if L > 0xffffffff: + raise ValueError("Too large data") + if L == 1: + self._buffer.write(b'\xd4') + elif L == 2: + self._buffer.write(b'\xd5') + elif L == 4: + self._buffer.write(b'\xd6') + elif L == 8: + self._buffer.write(b'\xd7') + elif L == 16: + self._buffer.write(b'\xd8') + elif L <= 0xff: + self._buffer.write(b'\xc7' + struct.pack('B', L)) + elif L <= 0xffff: + self._buffer.write(b'\xc8' + struct.pack('>H', L)) + else: + self._buffer.write(b'\xc9' + struct.pack('>I', L)) + self._buffer.write(struct.pack('B', typecode)) + self._buffer.write(data) + + def _pack_array_header(self, n): + if n <= 0x0f: + return self._buffer.write(struct.pack('B', 0x90 + n)) + if n <= 0xffff: + return self._buffer.write(struct.pack(">BH", 0xdc, n)) + if n <= 0xffffffff: + return self._buffer.write(struct.pack(">BI", 0xdd, n)) + raise ValueError("Array is too large") + + def _pack_map_header(self, n): + if n <= 0x0f: + return self._buffer.write(struct.pack('B', 0x80 + n)) + if n <= 0xffff: + return self._buffer.write(struct.pack(">BH", 0xde, n)) + if n <= 0xffffffff: + return self._buffer.write(struct.pack(">BI", 0xdf, n)) + raise ValueError("Dict is too large") + + def _pack_map_pairs(self, n, pairs, nest_limit=DEFAULT_RECURSE_LIMIT): + self._pack_map_header(n) + for (k, v) in pairs: + self._pack(k, nest_limit - 1) + self._pack(v, nest_limit - 1) + + def _pack_raw_header(self, n): + if n <= 0x1f: + self._buffer.write(struct.pack('B', 0xa0 + n)) + elif self._use_bin_type and n <= 0xff: + self._buffer.write(struct.pack('>BB', 0xd9, n)) + elif n <= 0xffff: + self._buffer.write(struct.pack(">BH", 0xda, n)) + elif n <= 0xffffffff: + self._buffer.write(struct.pack(">BI", 0xdb, n)) + else: + raise ValueError('Raw is too large') + + def _pack_bin_header(self, n): + if not self._use_bin_type: + return self._pack_raw_header(n) + elif n <= 0xff: + return self._buffer.write(struct.pack('>BB', 0xc4, n)) + elif n <= 0xffff: + return self._buffer.write(struct.pack(">BH", 0xc5, n)) + elif n <= 0xffffffff: + return self._buffer.write(struct.pack(">BI", 0xc6, n)) + else: + raise ValueError('Bin is too large') + + def bytes(self): + """Return internal buffer contents as bytes object""" + return self._buffer.getvalue() + + def reset(self): + """Reset internal buffer. + + This method is usaful only when autoreset=False. + """ + self._buffer = StringIO() + + def getbuffer(self): + """Return view of internal buffer.""" + if USING_STRINGBUILDER or PY2: + return memoryview(self.bytes()) + else: + return self._buffer.getbuffer() diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/markers.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/markers.py new file mode 100644 index 0000000000000000000000000000000000000000..548247681bc180e8c2e7981952864ccd0dd70a28 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/markers.py @@ -0,0 +1,296 @@ +# 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 pip._vendor.pyparsing import ParseException, ParseResults, stringStart, stringEnd +from pip._vendor.pyparsing import ZeroOrMore, Group, Forward, QuotedString +from pip._vendor.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") + | L("sys.platform") # PEP-345 + | L("platform.version") # PEP-345 + | L("platform.machine") # PEP-345 + | L("platform.python_implementation") # PEP-345 + | L("python_implementation") # PEP-345 + | L("extra") # undocumented setuptools legacy +) +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 "".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/pip/_vendor/packaging/requirements.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/requirements.py new file mode 100644 index 0000000000000000000000000000000000000000..dbc5f11db264f183b24002193f81e3045b939a81 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/requirements.py @@ -0,0 +1,138 @@ +# 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 pip._vendor.pyparsing import stringStart, stringEnd, originalTextFor, ParseException +from pip._vendor.pyparsing import ZeroOrMore, Word, Optional, Regex, Combine +from pip._vendor.pyparsing import Literal as L # noqa +from pip._vendor.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_SEPARATOR = SEMICOLON +MARKER = MARKER_SEPARATOR + 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 +# pyparsing isn't thread safe during initialization, so we do it eagerly, see +# issue #104 +REQUIREMENT.parseString("x[]") + + +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( + 'Parse error at "{0!r}": {1}'.format( + requirement_string[e.loc : e.loc + 8], e.msg + ) + ) + + self.name = req.name + if req.url: + parsed_url = urlparse.urlparse(req.url) + if parsed_url.scheme == "file": + if urlparse.urlunparse(parsed_url) != req.url: + raise InvalidRequirement("Invalid URL given") + elif not (parsed_url.scheme and parsed_url.netloc) or ( + not parsed_url.scheme and not parsed_url.netloc + ): + raise InvalidRequirement("Invalid URL: {0}".format(req.url)) + 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(" ") + + if self.marker: + parts.append("; {0}".format(self.marker)) + + return "".join(parts) + + def __repr__(self): + return "".format(str(self)) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/specifiers.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/specifiers.py new file mode 100644 index 0000000000000000000000000000000000000000..743576a080a0af8d0995f307ea6afc645b13ca61 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/specifiers.py @@ -0,0 +1,749 @@ +# 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 beginning. + 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(==|!=|<=|>=|<|>)) + \s* + (?P + [^,;\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(~=|==|!=|<=|>=|<|>|===)) + (?P + (?: + # 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. + (?=": "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 technically 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 "".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/pip/_vendor/packaging/utils.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..88418786933b8bc5f6179b8e191f60f79efd7074 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pip/_vendor/packaging/utils.py @@ -0,0 +1,57 @@ +# 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 + +from .version import InvalidVersion, Version + + +_canonicalize_regex = re.compile(r"[-_.]+") + + +def canonicalize_name(name): + # This is taken from PEP 503. + return _canonicalize_regex.sub("-", name).lower() + + +def canonicalize_version(version): + """ + This is very similar to Version.__str__, but has one subtle differences + with the way it handles the release segment. + """ + + try: + version = Version(version) + except InvalidVersion: + # Legacy versions cannot be normalized + return version + + parts = [] + + # Epoch + if version.epoch != 0: + parts.append("{0}!".format(version.epoch)) + + # Release segment + # NB: This strips trailing '.0's to normalize + parts.append(re.sub(r"(\.0)+$", "", ".".join(str(x) for x in version.release))) + + # Pre-release + if version.pre is not None: + parts.append("".join(str(x) for x in version.pre)) + + # Post-release + if version.post is not None: + parts.append(".post{0}".format(version.post)) + + # Development release + if version.dev is not None: + parts.append(".dev{0}".format(version.dev)) + + # Local version segment + if version.local is not None: + parts.append("+{0}".format(version.local)) + + return "".join(parts) diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/__about__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/__about__.py new file mode 100644 index 0000000000000000000000000000000000000000..95d330ef823aa2e12f7846bc63c0955b25df6029 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/__about__.py @@ -0,0 +1,21 @@ +# 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__ = "16.8" + +__author__ = "Donald Stufft and individual contributors" +__email__ = "donald@stufft.io" + +__license__ = "BSD or Apache License, Version 2.0" +__copyright__ = "Copyright 2014-2016 %s" % __author__ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/__init__.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..5ee6220203e5425f900fb5a43676c24ea377c2fa --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/__init__.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 + +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/pkg_resources/_vendor/packaging/_structures.py b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_vendor/packaging/_structures.py new file mode 100644 index 0000000000000000000000000000000000000000..ccc27861c3a4d9efaa3db753c77c4515a627bd98 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pkg_resources/_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/pytz/zoneinfo/America/Argentina/Mendoza b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Argentina/Mendoza new file mode 100644 index 0000000000000000000000000000000000000000..f9e677f171b3900dfd978eb8ea2aa226557d2c5b 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/Mendoza differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Argentina/Rio_Gallegos b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Argentina/Rio_Gallegos new file mode 100644 index 0000000000000000000000000000000000000000..c36587e1c292673fa537cecf729f4c873d375c9a 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/Rio_Gallegos differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Argentina/Salta b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Argentina/Salta new file mode 100644 index 0000000000000000000000000000000000000000..0e797f2215ab398bc59b8e4d60e5260fcb365c3b 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/Salta differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Marengo b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Marengo new file mode 100644 index 0000000000000000000000000000000000000000..1abf75e7e864625b975feebdd0b232d0de624b27 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Marengo differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Petersburg b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Petersburg new file mode 100644 index 0000000000000000000000000000000000000000..0133548ecac014f4b37f0abcd471a5a6b4e7ed5f Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Petersburg differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Tell_City b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Tell_City new file mode 100644 index 0000000000000000000000000000000000000000..4ce95c152a3d8974fdc67072f944eae97b5997ec Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Tell_City differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Vevay b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Vevay new file mode 100644 index 0000000000000000000000000000000000000000..d236b7c07726828984d3afbfa872b3abeae3e809 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Vevay differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Vincennes b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Vincennes new file mode 100644 index 0000000000000000000000000000000000000000..c818929d19b2ca5925c181696f02a2ba93a7009a Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Vincennes differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Winamac b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Winamac new file mode 100644 index 0000000000000000000000000000000000000000..630935c1e1a8c1a87e728fc1dcc4c930e81b30e9 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Indiana/Winamac differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Kentucky/Louisville b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Kentucky/Louisville new file mode 100644 index 0000000000000000000000000000000000000000..f4c4cf966fa6a0130b9ee5fbd01fe0790fe8f001 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Kentucky/Louisville differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Kentucky/Monticello b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Kentucky/Monticello new file mode 100644 index 0000000000000000000000000000000000000000..438e3eab4a6e581c6f5e7661098bf07b1a000593 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/Kentucky/Monticello differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/North_Dakota/Beulah b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/North_Dakota/Beulah new file mode 100644 index 0000000000000000000000000000000000000000..246345dde7cada7b0de81cc23fabc66b60d51e79 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/North_Dakota/Beulah differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/North_Dakota/Center b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/North_Dakota/Center new file mode 100644 index 0000000000000000000000000000000000000000..1fa0703778034551487b7b55d80d41ad220f2102 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/North_Dakota/Center differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/North_Dakota/New_Salem b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/North_Dakota/New_Salem new file mode 100644 index 0000000000000000000000000000000000000000..123f2aeecfc88f2e543f99d6a859e02788170852 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/America/North_Dakota/New_Salem differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Samara b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Samara new file mode 100644 index 0000000000000000000000000000000000000000..97d5dd9e6ed7fc924c9bcb514f991cc8b52061b3 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Samara differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/San_Marino b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/San_Marino new file mode 100644 index 0000000000000000000000000000000000000000..ac4c16342b5bbfa4c58a26f57db33b95f5b3e533 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/San_Marino differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Sarajevo b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Sarajevo 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/Sarajevo differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Saratov b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Saratov new file mode 100644 index 0000000000000000000000000000000000000000..8fd5f6d4b881457d13fdcdd35abb6fc5429d7084 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Saratov differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Tallinn b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Tallinn new file mode 100644 index 0000000000000000000000000000000000000000..b5acca3cf51e7f7b3176965748688ff41720246f Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Tallinn differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Tirane b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Tirane new file mode 100644 index 0000000000000000000000000000000000000000..0b86017d243f1b7bbb41d6b4feefcb2b7edfc7d8 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Tirane differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Tiraspol b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Tiraspol 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/Tiraspol differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Ulyanovsk b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Ulyanovsk new file mode 100644 index 0000000000000000000000000000000000000000..7b61bdc522b5b7f4397fdb9246185f4d972f4b6c Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Ulyanovsk differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Uzhgorod b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Uzhgorod new file mode 100644 index 0000000000000000000000000000000000000000..66ae8d69e3f86cfdd8d90a9b1d094d807f75f27a Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Uzhgorod differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vaduz b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vaduz 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/Vaduz differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vatican b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vatican new file mode 100644 index 0000000000000000000000000000000000000000..ac4c16342b5bbfa4c58a26f57db33b95f5b3e533 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vatican differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vienna b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vienna new file mode 100644 index 0000000000000000000000000000000000000000..696f359d4bd4fa489252450b4eb36b7c08048c66 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vienna differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vilnius b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vilnius new file mode 100644 index 0000000000000000000000000000000000000000..7abd63fa608e0186b9f154d9fcc32472c28f6759 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Vilnius differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Volgograd b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Volgograd new file mode 100644 index 0000000000000000000000000000000000000000..d1cfac0e388de542a10c8f0b84fff0b29e70fc1d Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Volgograd differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Warsaw b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Warsaw new file mode 100644 index 0000000000000000000000000000000000000000..e33cf67171da78aa9e6eb02e50f9b9603da4c3f4 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Warsaw differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Zagreb b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Zagreb 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/Zagreb differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Zaporozhye b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Zaporozhye new file mode 100644 index 0000000000000000000000000000000000000000..e42edfc8506b9b99362b36d90c8b8c4db67d50d8 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Zaporozhye differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Zurich b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Europe/Zurich 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/Zurich differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Antananarivo b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Antananarivo new file mode 100644 index 0000000000000000000000000000000000000000..9a2918f40404340d576ce850f2950baad751f8a8 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Antananarivo differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Chagos b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Chagos new file mode 100644 index 0000000000000000000000000000000000000000..93d6dda50f579093f25617c77081ae99c8631ea5 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Chagos differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Christmas b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Christmas new file mode 100644 index 0000000000000000000000000000000000000000..d18c3810d97bbd424dc3c8fa98de46bfa08c3fa8 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Christmas differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Cocos b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Cocos new file mode 100644 index 0000000000000000000000000000000000000000..f8116e7025cadc709bbd995905e88c92ed03642a Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Cocos differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Comoro b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Comoro new file mode 100644 index 0000000000000000000000000000000000000000..9a2918f40404340d576ce850f2950baad751f8a8 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Comoro differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Kerguelen b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Kerguelen new file mode 100644 index 0000000000000000000000000000000000000000..cde4cf7ea7086a3fa3609566ff03e9425b096f36 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Kerguelen differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Mahe b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Mahe new file mode 100644 index 0000000000000000000000000000000000000000..cba7dfe7358ebf0d27542ca3abf3ac0045fae196 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Mahe differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Maldives b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Maldives new file mode 100644 index 0000000000000000000000000000000000000000..7c839cfa9bd62842cf23f01d5195b239bc5a437c Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Maldives differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Mauritius b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Mauritius new file mode 100644 index 0000000000000000000000000000000000000000..17f26169904928e4061e4ee58bdf7a6c62001524 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Mauritius differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Mayotte b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Mayotte new file mode 100644 index 0000000000000000000000000000000000000000..9a2918f40404340d576ce850f2950baad751f8a8 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Mayotte differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Reunion b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Reunion new file mode 100644 index 0000000000000000000000000000000000000000..dfe08313dffde345044d5053e3359f92163d3e38 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Indian/Reunion differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Mexico/BajaNorte b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Mexico/BajaNorte new file mode 100644 index 0000000000000000000000000000000000000000..ada6bf78b2815d3d99c97d521ab9a6b35c8af8c3 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Mexico/BajaNorte differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Mexico/BajaSur b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Mexico/BajaSur new file mode 100644 index 0000000000000000000000000000000000000000..e4a785743d75f939c3e4798ebe7c79d38e4cfd08 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Mexico/BajaSur differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Mexico/General b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Mexico/General new file mode 100644 index 0000000000000000000000000000000000000000..e7fb6f2953d123efbc2550f450decd794b017d4f Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Mexico/General differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Fakaofo b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Fakaofo new file mode 100644 index 0000000000000000000000000000000000000000..e40307f6aab2a169bb957979f5580affb379131e Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Fakaofo differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Wake b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Wake new file mode 100644 index 0000000000000000000000000000000000000000..c9e310670f07e9e577791bfa19fefde61351fcdf Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Wake differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Wallis b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Wallis new file mode 100644 index 0000000000000000000000000000000000000000..b35344b312c6ca690c0f79a858c3995a05c71ff3 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Wallis differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Yap b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Yap new file mode 100644 index 0000000000000000000000000000000000000000..07c84b7110ad9589810b916390aedc7ef498f423 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/Pacific/Yap differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Alaska b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Alaska new file mode 100644 index 0000000000000000000000000000000000000000..9bbb2fd3b361ea8aa4c126d14df5fa370343a63f Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Alaska differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Aleutian b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Aleutian new file mode 100644 index 0000000000000000000000000000000000000000..43236498f681cc06f64ca2afa613880331fe6fbb Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Aleutian differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Arizona b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Arizona new file mode 100644 index 0000000000000000000000000000000000000000..ac6bb0c78291f1e341f42c34639458fb385bf8ed Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Arizona differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Central b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Central new file mode 100644 index 0000000000000000000000000000000000000000..a5b1617c7f70bfc77b7d504aaa3f23603082c3cb Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Central differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/East-Indiana b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/East-Indiana new file mode 100644 index 0000000000000000000000000000000000000000..09511ccdcf97a5baa8e1b0eb75e040eee6b6e0c4 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/East-Indiana differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Eastern b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Eastern new file mode 100644 index 0000000000000000000000000000000000000000..2f75480e069b60b6c58a9137c7eebd4796f74226 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Eastern differ diff --git a/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Hawaii b/benchmark/NYU_CTF_Bench/test/2019/CSAW-Quals/crypto/brillouin/lib/python2.7/site-packages/pytz/zoneinfo/US/Hawaii 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/US/Hawaii differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95b8905b66b35190bdaa8d8ede44d1b2 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95b8905b66b35190bdaa8d8ede44d1b2 new file mode 100644 index 0000000000000000000000000000000000000000..c21aca2a917cf6fed954dc7a2cd21534cb511e12 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95b8905b66b35190bdaa8d8ede44d1b2 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95bf7545f79aa08d8aa73c8949e927d5 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95bf7545f79aa08d8aa73c8949e927d5 new file mode 100644 index 0000000000000000000000000000000000000000..ad5c23c686836e7dfdd41153478bd8e673d68e6b Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95bf7545f79aa08d8aa73c8949e927d5 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95cbc8bac3f339b37f5743157f79a479 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95cbc8bac3f339b37f5743157f79a479 new file mode 100644 index 0000000000000000000000000000000000000000..7ec870d42f01a74c3c1bbdb4e68ecf81530f0f0c Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95cbc8bac3f339b37f5743157f79a479 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95cf5b46c5e0d2af4fa95a8c5858fe21 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95cf5b46c5e0d2af4fa95a8c5858fe21 new file mode 100644 index 0000000000000000000000000000000000000000..0a0b7fd5af09bbe1006a2f93e1fe7b9536aacb47 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95cf5b46c5e0d2af4fa95a8c5858fe21 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95f9eb57b609693759d21ede5fc7a691 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95f9eb57b609693759d21ede5fc7a691 new file mode 100644 index 0000000000000000000000000000000000000000..26a3939fa61dac198fd35236de308a9c17c74d51 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/95/95f9eb57b609693759d21ede5fc7a691 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9605c7b728c8457c78d34adc56e74bb3 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9605c7b728c8457c78d34adc56e74bb3 new file mode 100644 index 0000000000000000000000000000000000000000..32742af383f465d3e3d943d763b4e9fd7c0ce586 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9605c7b728c8457c78d34adc56e74bb3 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9620374b8231df4fd6bd4397f968700f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9620374b8231df4fd6bd4397f968700f new file mode 100644 index 0000000000000000000000000000000000000000..3ae5c5b1012350ee38147f2460a5d9ac3529feae Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9620374b8231df4fd6bd4397f968700f differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9621259abbebeb64fec97cf05ebb0f20 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9621259abbebeb64fec97cf05ebb0f20 new file mode 100644 index 0000000000000000000000000000000000000000..17c74fe902c35156377422ea36e1ba12b2a9bcde Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9621259abbebeb64fec97cf05ebb0f20 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9654203ca4518bdca221627959b557ae b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9654203ca4518bdca221627959b557ae new file mode 100644 index 0000000000000000000000000000000000000000..a18bd047eb11712a26a9d640ceb3e3e62cbc15b4 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/96/9654203ca4518bdca221627959b557ae differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9d/9de1c5316d06bc93e86b2e35c7ff6cc3 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9d/9de1c5316d06bc93e86b2e35c7ff6cc3 new file mode 100644 index 0000000000000000000000000000000000000000..fb3158ffe1ddc2d3b77f9c5fae8a78cb4ef64634 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9d/9de1c5316d06bc93e86b2e35c7ff6cc3 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9e/9e20436077284662cd9fea239f5a0e04 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9e/9e20436077284662cd9fea239f5a0e04 new file mode 100644 index 0000000000000000000000000000000000000000..31e5991042a9b8597422b7ebc03051e064a36a1e Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9e/9e20436077284662cd9fea239f5a0e04 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9e/9e2e2239862b1dede438fda8a28642b4 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9e/9e2e2239862b1dede438fda8a28642b4 new file mode 100644 index 0000000000000000000000000000000000000000..3dcd5280d99c81aca0f9d505bd561d9cdcce7a33 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9e/9e2e2239862b1dede438fda8a28642b4 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9e/9e77a4279ec2ef9583f553683477cbcb b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9e/9e77a4279ec2ef9583f553683477cbcb new file mode 100644 index 0000000000000000000000000000000000000000..4456de015f9bf8c137bde616573ad981f6b0be0f Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9e/9e77a4279ec2ef9583f553683477cbcb differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9f/9fa4166454ee2564aeda895bf37622f3 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9f/9fa4166454ee2564aeda895bf37622f3 new file mode 100644 index 0000000000000000000000000000000000000000..342d09a1344fa8c3730111ccf8b11a007852e4cc Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9f/9fa4166454ee2564aeda895bf37622f3 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9f/9fb79824613a4744bd3b3d6305ade06e b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9f/9fb79824613a4744bd3b3d6305ade06e new file mode 100644 index 0000000000000000000000000000000000000000..81560d0b6dc547d425ea251f4bf0112120b6c75a Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9f/9fb79824613a4744bd3b3d6305ade06e differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9f/9fdd643497262ef65d388a9ec71e0fa3 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9f/9fdd643497262ef65d388a9ec71e0fa3 new file mode 100644 index 0000000000000000000000000000000000000000..b8131c9a5178a4d50c1a285a0cab6050a8196564 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/9f/9fdd643497262ef65d388a9ec71e0fa3 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a0/a00d271fada7af7141f29c03f38f138a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a0/a00d271fada7af7141f29c03f38f138a new file mode 100644 index 0000000000000000000000000000000000000000..15a05c020dcc6e3a2ad22145e448a8b85330d88e Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a0/a00d271fada7af7141f29c03f38f138a differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a1715f989d16bf0a6f5c7b31f15278bc b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a1715f989d16bf0a6f5c7b31f15278bc new file mode 100644 index 0000000000000000000000000000000000000000..98319511eed2b85ce3778511f9f942e0cc9be2f6 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a1715f989d16bf0a6f5c7b31f15278bc differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a17eed499adf4afaa0ff865e94cef0b9 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a17eed499adf4afaa0ff865e94cef0b9 new file mode 100644 index 0000000000000000000000000000000000000000..bd47b9b60edc25c71a2fff6be36137f56aeceb55 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a17eed499adf4afaa0ff865e94cef0b9 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a188a8b1d42af52238d5c9d4f86b5b35 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a188a8b1d42af52238d5c9d4f86b5b35 new file mode 100644 index 0000000000000000000000000000000000000000..bf8fa6df1c7575edf864ce6016db0880bf871b4c Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a188a8b1d42af52238d5c9d4f86b5b35 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a18c833d151a9ed743fd2add411e385f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a18c833d151a9ed743fd2add411e385f new file mode 100644 index 0000000000000000000000000000000000000000..7ad3a341c95e5a44873d9a8514b6dcc1528596ce Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a18c833d151a9ed743fd2add411e385f differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a18c89bb6b977f74b6a4baaca2b7f06f b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a18c89bb6b977f74b6a4baaca2b7f06f new file mode 100644 index 0000000000000000000000000000000000000000..4ae179ffd7b6691263784bc3112ed607afde0a6f Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a18c89bb6b977f74b6a4baaca2b7f06f differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a19062ba5004656f5ac9ed943bf2662a b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a19062ba5004656f5ac9ed943bf2662a new file mode 100644 index 0000000000000000000000000000000000000000..2683d43e08ec8b130e424e7c85c11d8ca965cfe7 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a19062ba5004656f5ac9ed943bf2662a differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a19c936b8cb8fd26daf11c20f8cb71ca b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a19c936b8cb8fd26daf11c20f8cb71ca new file mode 100644 index 0000000000000000000000000000000000000000..6d241b6f3044513d4128078b86d48cebad01210e Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a1/a19c936b8cb8fd26daf11c20f8cb71ca differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a7/a786ca7d27c5859e1a10b5d1e4a4d491 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a7/a786ca7d27c5859e1a10b5d1e4a4d491 new file mode 100644 index 0000000000000000000000000000000000000000..a6f84322445cf0019efade8fd29ec546984f54fa Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a7/a786ca7d27c5859e1a10b5d1e4a4d491 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a99287049172c481ab066e3023f93b3b b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a99287049172c481ab066e3023f93b3b new file mode 100644 index 0000000000000000000000000000000000000000..77115538206a72f3975bce5fe9dfa26e7e0b211e Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a99287049172c481ab066e3023f93b3b differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9c06c98cbb019b9cecd1a92dbece6a3 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9c06c98cbb019b9cecd1a92dbece6a3 new file mode 100644 index 0000000000000000000000000000000000000000..cead7e5a79cd68bdc6847750aa6ba86665d6da97 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9c06c98cbb019b9cecd1a92dbece6a3 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9c4354dbc704a48ad30f3bcfbcac047 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9c4354dbc704a48ad30f3bcfbcac047 new file mode 100644 index 0000000000000000000000000000000000000000..3d245df245afee7866bb4f72a5a198a2ce7f74a3 Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9c4354dbc704a48ad30f3bcfbcac047 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9df65185539186b60977a5861d9ddd3 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9df65185539186b60977a5861d9ddd3 new file mode 100644 index 0000000000000000000000000000000000000000..b8ebb3a52061e6a5803b675f79277b54f7921aef Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9df65185539186b60977a5861d9ddd3 differ diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9e7a13d5974dec026c18c55667997b7 b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9e7a13d5974dec026c18c55667997b7 new file mode 100644 index 0000000000000000000000000000000000000000..2db93667cdeae0243c41fe0f726b88fafc3c743d Binary files /dev/null and b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/Artifacts/a9/a9e7a13d5974dec026c18c55667997b7 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/SkinningModule/IMGUI/RectSelectionTool.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/RectSelectionTool.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..2f8fc9a88c6850e01202a669372bfbc8e60b3652 --- /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.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 7b6edb0347e814797aa9c181f8e5918f +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/SkeletonSelection.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/SkeletonSelection.cs new file mode 100644 index 0000000000000000000000000000000000000000..b3b8f0715018ce7d30f60001244224aecbaf4259 --- /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/SkeletonSelection.cs @@ -0,0 +1,102 @@ +using System; +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ + [Serializable] + internal class SkeletonSelection : IBoneSelection + { + [SerializeField] + private BoneSelection m_BoneSelection = new BoneSelection(); + + public int Count + { + get { return m_BoneSelection.Count; } + } + + public BoneCache activeElement + { + get { return m_BoneSelection.activeElement; } + set + { + ValidateBone(value); + m_BoneSelection.activeElement = value; + } + } + public BoneCache[] elements + { + get { return m_BoneSelection.elements; } + set + { + foreach (var bone in value) + ValidateBone(bone); + + m_BoneSelection.elements = value; + } + } + + public BoneCache root + { + get { return m_BoneSelection.root; } + } + + public BoneCache[] roots + { + get { return m_BoneSelection.roots; } + } + + public void BeginSelection() + { + m_BoneSelection.BeginSelection(); + } + + public void Clear() + { + m_BoneSelection.Clear(); + } + + public bool Contains(BoneCache element) + { + return m_BoneSelection.Contains(element); + } + + public void EndSelection(bool select) + { + m_BoneSelection.EndSelection(select); + } + + public void Select(BoneCache element, bool select) + { + ValidateBone(element); + m_BoneSelection.Select(element, select); + } + + private void ValidateBone(BoneCache bone) + { + if (bone == null) + return; + + var skinningCache = bone.skinningCache; + + if (skinningCache.hasCharacter) + { + if (bone.skeleton != skinningCache.character.skeleton) + throw new Exception("Selection Exception: bone does not belong to character skeleton"); + } + else + { + var selectedSprite = skinningCache.selectedSprite; + + if (selectedSprite == null) + throw new Exception("Selection Exception: skeleton not selected"); + else + { + var skeleton = selectedSprite.GetSkeleton(); + + if (bone.skeleton != skeleton) + throw new Exception("Selection Exception: bone's skeleton does not match selected skeleton"); + } + } + } + } +} 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/SkeletonSelection.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/SkeletonSelection.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..8d9669bf6949f4b9731c50e670aa36b4e36e42ac --- /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/SkeletonSelection.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c66db58fd56e0a14690d99c115527f28 +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/CircleVertexSelector.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/Selectors/CircleVertexSelector.cs new file mode 100644 index 0000000000000000000000000000000000000000..b88b3f91ace58b192f50633962ca74537ac43af4 --- /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/CircleVertexSelector.cs @@ -0,0 +1,28 @@ +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ + internal class CircleVertexSelector : ICircleSelector + { + public ISelection selection { get; set; } + public ISpriteMeshData spriteMeshData { get; set; } + public Vector2 position { get; set; } + public float radius { get; set; } + + public void Select() + { + if(spriteMeshData == null) + return; + + var sqrRadius = radius * radius; + + for (int i = 0; i < spriteMeshData.vertexCount; i++) + { + if ((spriteMeshData.GetPosition(i) - position).sqrMagnitude <= sqrRadius) + { + selection.Select(i, 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/Selectors/CircleVertexSelector.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/Selectors/CircleVertexSelector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..38eb2bd805dea222079045347f6eadcd196a896c --- /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/CircleVertexSelector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f8bd55f54ef124b618d88fafb91f0170 +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/GenericVertexSelector.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/Selectors/GenericVertexSelector.cs new file mode 100644 index 0000000000000000000000000000000000000000..e943a9efe07dd6a809650a0aff9ba8829743eef4 --- /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/GenericVertexSelector.cs @@ -0,0 +1,22 @@ +using System; +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ + internal class GenericVertexSelector : ISelector + { + public ISelection selection { get; set; } + public ISpriteMeshData spriteMeshData { get; set; } + public Func SelectionCallback; + + public void Select() + { + Debug.Assert(selection != null); + Debug.Assert(spriteMeshData != null); + Debug.Assert(SelectionCallback != null); + + for (var i = 0; i < spriteMeshData.vertexCount; i++) + selection.Select(i, SelectionCallback(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/Selectors/GenericVertexSelector.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/Selectors/GenericVertexSelector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..feded4daa0c1b26be1d1bc41ed84d54c252b4ecd --- /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/GenericVertexSelector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1ae93e85c98624948917679be12e485b +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/ICircleSelector.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/Selectors/ICircleSelector.cs new file mode 100644 index 0000000000000000000000000000000000000000..cf38756ab1a8e8e89e57e069646b9d7caa9b70b4 --- /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/ICircleSelector.cs @@ -0,0 +1,9 @@ +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ + internal interface ICircleSelector : ISelector + { + float radius { get; set; } + } +} 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/SkeletonTool.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/SkeletonTool.cs new file mode 100644 index 0000000000000000000000000000000000000000..4a1d0d58a8a955060aab7832740eaf9bcc7d605e --- /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/SkeletonTool.cs @@ -0,0 +1,198 @@ +using System; +using UnityEditor.U2D.Layout; +using UnityEngine; + +namespace UnityEditor.U2D.Animation +{ + internal class SkeletonTool : BaseTool + { + [SerializeField] + private SkeletonController m_SkeletonController; + private SkeletonToolView m_SkeletonToolView; + private RectBoneSelector m_RectBoneSelector = new RectBoneSelector(); + private RectSelectionTool m_RectSelectionTool = new RectSelectionTool(); + private UnselectTool m_UnselectTool = new UnselectTool(); + + public bool enableBoneInspector { get; set; } + + public SkeletonMode mode + { + get { return m_SkeletonController.view.mode; } + set { m_SkeletonController.view.mode = value; } + } + + public bool editBindPose + { + get { return m_SkeletonController.editBindPose; } + set { m_SkeletonController.editBindPose = value; } + } + + public ISkeletonStyle skeletonStyle + { + get { return m_SkeletonController.styleOverride; } + set { m_SkeletonController.styleOverride = value; } + } + + public override int defaultControlID + { + get { return 0; } + } + + public BoneCache hoveredBone + { + get { return m_SkeletonController.hoveredBone; } + } + + public SkeletonCache skeleton + { + get { return m_SkeletonController.skeleton; } + private set { m_SkeletonController.skeleton = value; } + } + + internal override void OnCreate() + { + m_SkeletonController = new SkeletonController(); + m_SkeletonController.view = new SkeletonView(new GUIWrapper()); + m_SkeletonController.view.InvalidID = 0; + m_SkeletonController.selection = skinningCache.skeletonSelection; + m_SkeletonToolView = new SkeletonToolView(); + m_SkeletonToolView.onBoneNameChanged += BoneNameChanged; + m_SkeletonToolView.onBoneDepthChanged += BoneDepthChanged; + m_RectBoneSelector.selection = skinningCache.skeletonSelection; + m_RectSelectionTool.rectSelector = m_RectBoneSelector; + m_RectSelectionTool.cacheUndo = skinningCache; + m_RectSelectionTool.onSelectionUpdate += () => + { + skinningCache.events.boneSelectionChanged.Invoke(); + }; + m_UnselectTool.cacheUndo = skinningCache; + m_UnselectTool.selection = skinningCache.skeletonSelection; + m_UnselectTool.onUnselect += () => + { + skinningCache.events.boneSelectionChanged.Invoke(); + }; + } + + public override void Initialize(LayoutOverlay layout) + { + m_SkeletonToolView.Initialize(layout); + } + + protected override void OnActivate() + { + SetupSkeleton(skinningCache.GetEffectiveSkeleton(skinningCache.selectedSprite)); + UpdateBoneInspector(); + skinningCache.events.boneSelectionChanged.AddListener(BoneSelectionChanged); + skinningCache.events.selectedSpriteChanged.AddListener(SelectedSpriteChanged); + skinningCache.events.skinningModeChanged.AddListener(SkinningModeChanged); + skinningCache.events.boneDepthChanged.AddListener(BoneDataChanged); + skinningCache.events.boneNameChanged.AddListener(BoneDataChanged); + skeletonStyle = null; + } + + protected override void OnDeactivate() + { + m_SkeletonToolView.Hide(); + m_SkeletonController.Reset(); + skinningCache.events.boneSelectionChanged.RemoveListener(BoneSelectionChanged); + skinningCache.events.selectedSpriteChanged.RemoveListener(SelectedSpriteChanged); + skinningCache.events.skinningModeChanged.RemoveListener(SkinningModeChanged); + skinningCache.events.boneDepthChanged.RemoveListener(BoneDataChanged); + skinningCache.events.boneNameChanged.RemoveListener(BoneDataChanged); + skeletonStyle = null; + } + + void BoneDataChanged(BoneCache bone) + { + if(m_SkeletonToolView.target == bone) + m_SkeletonToolView.Update(bone.name, Mathf.RoundToInt(bone.depth)); + } + + private void SelectedSpriteChanged(SpriteCache sprite) + { + SetupSkeleton(skinningCache.GetEffectiveSkeleton(sprite)); + } + + private void BoneSelectionChanged() + { + UpdateBoneInspector(); + } + + private void UpdateBoneInspector() + { + var selectedBone = skinningCache.skeletonSelection.activeElement; + var selectionCount = skinningCache.skeletonSelection.Count; + + m_SkeletonToolView.Hide(); + + if (enableBoneInspector && selectedBone != null && selectionCount == 1) + { + m_SkeletonToolView.Update(selectedBone.name, Mathf.RoundToInt(selectedBone.depth)); + m_SkeletonToolView.Show(selectedBone); + } + } + + private void SkinningModeChanged(SkinningMode mode) + { + SetupSkeleton(skinningCache.GetEffectiveSkeleton(skinningCache.selectedSprite)); + } + + private void SetupSkeleton(SkeletonCache sk) + { + m_RectBoneSelector.bones = null; + skeleton = sk; + + if (skeleton != null) + m_RectBoneSelector.bones = skeleton.bones; + } + + protected override void OnGUI() + { + m_SkeletonController.view.defaultControlID = 0; + + if (skeleton != null && mode != SkeletonMode.Disabled) + { + m_RectSelectionTool.OnGUI(); + m_SkeletonController.view.defaultControlID = m_RectSelectionTool.controlID; + } + + m_SkeletonController.OnGUI(); + m_UnselectTool.OnGUI(); + } + + private void BoneNameChanged(BoneCache selectedBone, string name) + { + if (selectedBone != null) + { + if (string.Compare(selectedBone.name, name) == 0) + return; + + if(string.IsNullOrEmpty(name) || string.IsNullOrWhiteSpace(name)) + m_SkeletonToolView.Update(selectedBone.name, Mathf.RoundToInt(selectedBone.depth)); + else + { + using (skinningCache.UndoScope(TextContent.boneName)) + { + selectedBone.name = name; + skinningCache.events.boneNameChanged.Invoke(selectedBone); + } + } + } + } + + private void BoneDepthChanged(BoneCache selectedBone, int depth) + { + if (selectedBone != null) + { + if (Mathf.RoundToInt(selectedBone.depth) == depth) + return; + + using (skinningCache.UndoScope(TextContent.boneDepth)) + { + selectedBone.depth = depth; + skinningCache.events.boneDepthChanged.Invoke(selectedBone); + } + } + } + } +} 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/SkeletonTool.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/SkeletonTool.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..5214704c1328e8941d578bad591aab87d2aeb3fd --- /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/SkeletonTool.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: acc0de355e663464684a1b81871fe30b +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/SkeletonToolView.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/SkeletonToolView.cs new file mode 100644 index 0000000000000000000000000000000000000000..b38d3e91199ffa0acb39883afa45c5f6c64f541d --- /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/SkeletonToolView.cs @@ -0,0 +1,46 @@ +using System; +using UnityEditor.U2D.Layout; + +namespace UnityEditor.U2D.Animation +{ + internal class SkeletonToolView + { + private BoneInspectorPanel m_BoneInspectorPanel; + + public event Action onBoneNameChanged = (b, s) => {}; + public event Action onBoneDepthChanged = (b, i) => {}; + + public SkeletonToolView() + { + m_BoneInspectorPanel = BoneInspectorPanel.GenerateFromUXML(); + m_BoneInspectorPanel.onBoneNameChanged += (b, n) => onBoneNameChanged(b, n); + m_BoneInspectorPanel.onBoneDepthChanged += (b, d) => onBoneDepthChanged(b, d); + Hide(); + } + + public void Initialize(LayoutOverlay layout) + { + layout.rightOverlay.Add(m_BoneInspectorPanel); + } + + public void Show(BoneCache target) + { + m_BoneInspectorPanel.target = target; + m_BoneInspectorPanel.SetHiddenFromLayout(false); + } + + public BoneCache target => m_BoneInspectorPanel.target; + + public void Hide() + { + m_BoneInspectorPanel.HidePanel(); + m_BoneInspectorPanel.target = null; + } + + public void Update(string name, int depth) + { + m_BoneInspectorPanel.boneName = name; + m_BoneInspectorPanel.boneDepth = depth; + } + } +} 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/SkeletonToolView.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/SkeletonToolView.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1c6b54ef53e7548e25c1e6ce2075c32e55de3139 --- /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/SkeletonToolView.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 26ec4641af523f44f8f62994a423b3b4 +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.path@4.0.1/Editor/EditablePath/BezierUtility.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/EditablePath/BezierUtility.cs new file mode 100644 index 0000000000000000000000000000000000000000..1c5e1a1d58e3d897a2b188d8d264aa7f0859428a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/EditablePath/BezierUtility.cs @@ -0,0 +1,223 @@ +using UnityEngine; + +namespace UnityEditor.U2D.Path +{ + public static class BezierUtility + { + static Vector3[] s_TempPoints = new Vector3[3]; + + public static Vector3 BezierPoint(Vector3 startPosition, Vector3 startTangent, Vector3 endTangent, Vector3 endPosition, float t) + { + float s = 1.0f - t; + return startPosition * s * s * s + startTangent * s * s * t * 3.0f + endTangent * s * t * t * 3.0f + endPosition * t * t * t; + } + + public static Vector3 ClosestPointOnCurve(Vector3 point, Vector3 startPosition, Vector3 endPosition, Vector3 startTangent, Vector3 endTangent, out float t) + { + Vector3 startToEnd = endPosition - startPosition; + Vector3 startToTangent = (startTangent - startPosition); + Vector3 endToTangent = (endTangent - endPosition); + + float sqrError = 0.001f; + + if (Colinear(startToTangent, startToEnd, sqrError) && Colinear(endToTangent, startToEnd, sqrError)) + return ClosestPointToSegment(point, startPosition, endPosition, out t); + + Vector3 leftStartPosition; + Vector3 leftEndPosition; + Vector3 leftStartTangent; + Vector3 leftEndTangent; + + Vector3 rightStartPosition; + Vector3 rightEndPosition; + Vector3 rightStartTangent; + Vector3 rightEndTangent; + + float leftStartT = 0f; + float leftEndT = 0.5f; + float rightStartT = 0.5f; + float rightEndT = 1f; + + SplitBezier(0.5f, startPosition, endPosition, startTangent, endTangent, + out leftStartPosition, out leftEndPosition, out leftStartTangent, out leftEndTangent, + out rightStartPosition, out rightEndPosition, out rightStartTangent, out rightEndTangent); + + Vector3 pointLeft = ClosestPointOnCurveIterative(point, leftStartPosition, leftEndPosition, leftStartTangent, leftEndTangent, sqrError, ref leftStartT, ref leftEndT); + Vector3 pointRight = ClosestPointOnCurveIterative(point, rightStartPosition, rightEndPosition, rightStartTangent, rightEndTangent, sqrError, ref rightStartT, ref rightEndT); + + if ((point - pointLeft).sqrMagnitude < (point - pointRight).sqrMagnitude) + { + t = leftStartT; + return pointLeft; + } + + t = rightStartT; + return pointRight; + } + + public static Vector3 ClosestPointOnCurveFast(Vector3 point, Vector3 startPosition, Vector3 endPosition, Vector3 startTangent, Vector3 endTangent, out float t) + { + float sqrError = 0.001f; + float startT = 0f; + float endT = 1f; + + Vector3 closestPoint = ClosestPointOnCurveIterative(point, startPosition, endPosition, startTangent, endTangent, sqrError, ref startT, ref endT); + + t = startT; + + return closestPoint; + } + + private static Vector3 ClosestPointOnCurveIterative(Vector3 point, Vector3 startPosition, Vector3 endPosition, Vector3 startTangent, Vector3 endTangent, float sqrError, ref float startT, ref float endT) + { + while ((startPosition - endPosition).sqrMagnitude > sqrError) + { + Vector3 startToEnd = endPosition - startPosition; + Vector3 startToTangent = (startTangent - startPosition); + Vector3 endToTangent = (endTangent - endPosition); + + if (Colinear(startToTangent, startToEnd, sqrError) && Colinear(endToTangent, startToEnd, sqrError)) + { + float t; + Vector3 closestPoint = ClosestPointToSegment(point, startPosition, endPosition, out t); + t *= (endT - startT); + startT += t; + endT -= t; + return closestPoint; + } + + Vector3 leftStartPosition; + Vector3 leftEndPosition; + Vector3 leftStartTangent; + Vector3 leftEndTangent; + + Vector3 rightStartPosition; + Vector3 rightEndPosition; + Vector3 rightStartTangent; + Vector3 rightEndTangent; + + SplitBezier(0.5f, startPosition, endPosition, startTangent, endTangent, + out leftStartPosition, out leftEndPosition, out leftStartTangent, out leftEndTangent, + out rightStartPosition, out rightEndPosition, out rightStartTangent, out rightEndTangent); + + s_TempPoints[0] = leftStartPosition; + s_TempPoints[1] = leftStartTangent; + s_TempPoints[2] = leftEndTangent; + + float sqrDistanceLeft = SqrDistanceToPolyLine(point, s_TempPoints); + + s_TempPoints[0] = rightEndPosition; + s_TempPoints[1] = rightEndTangent; + s_TempPoints[2] = rightStartTangent; + + float sqrDistanceRight = SqrDistanceToPolyLine(point, s_TempPoints); + + if (sqrDistanceLeft < sqrDistanceRight) + { + startPosition = leftStartPosition; + endPosition = leftEndPosition; + startTangent = leftStartTangent; + endTangent = leftEndTangent; + + endT -= (endT - startT) * 0.5f; + } + else + { + startPosition = rightStartPosition; + endPosition = rightEndPosition; + startTangent = rightStartTangent; + endTangent = rightEndTangent; + + startT += (endT - startT) * 0.5f; + } + } + + return endPosition; + } + + public static void SplitBezier(float t, Vector3 startPosition, Vector3 endPosition, Vector3 startRightTangent, Vector3 endLeftTangent, + out Vector3 leftStartPosition, out Vector3 leftEndPosition, out Vector3 leftStartTangent, out Vector3 leftEndTangent, + out Vector3 rightStartPosition, out Vector3 rightEndPosition, out Vector3 rightStartTangent, out Vector3 rightEndTangent) + { + Vector3 tangent0 = (startRightTangent - startPosition); + Vector3 tangent1 = (endLeftTangent - endPosition); + Vector3 tangentEdge = (endLeftTangent - startRightTangent); + + Vector3 tangentPoint0 = startPosition + tangent0 * t; + Vector3 tangentPoint1 = endPosition + tangent1 * (1f - t); + Vector3 tangentEdgePoint = startRightTangent + tangentEdge * t; + + Vector3 newTangent0 = tangentPoint0 + (tangentEdgePoint - tangentPoint0) * t; + Vector3 newTangent1 = tangentPoint1 + (tangentEdgePoint - tangentPoint1) * (1f - t); + Vector3 newTangentEdge = newTangent1 - newTangent0; + + Vector3 bezierPoint = newTangent0 + newTangentEdge * t; + + leftStartPosition = startPosition; + leftEndPosition = bezierPoint; + leftStartTangent = tangentPoint0; + leftEndTangent = newTangent0; + + rightStartPosition = bezierPoint; + rightEndPosition = endPosition; + rightStartTangent = newTangent1; + rightEndTangent = tangentPoint1; + } + + private static Vector3 ClosestPointToSegment(Vector3 point, Vector3 segmentStart, Vector3 segmentEnd, out float t) + { + Vector3 relativePoint = point - segmentStart; + Vector3 segment = (segmentEnd - segmentStart); + Vector3 segmentDirection = segment.normalized; + float length = segment.magnitude; + + float dot = Vector3.Dot(relativePoint, segmentDirection); + + if (dot <= 0f) + dot = 0f; + else if (dot >= length) + dot = length; + + t = dot / length; + + return segmentStart + segment * t; + } + + private static float SqrDistanceToPolyLine(Vector3 point, Vector3[] points) + { + float minDistance = float.MaxValue; + + for (int i = 0; i < points.Length - 1; ++i) + { + float distance = SqrDistanceToSegment(point, points[i], points[i + 1]); + + if (distance < minDistance) + minDistance = distance; + } + + return minDistance; + } + + private static float SqrDistanceToSegment(Vector3 point, Vector3 segmentStart, Vector3 segmentEnd) + { + Vector3 relativePoint = point - segmentStart; + Vector3 segment = (segmentEnd - segmentStart); + Vector3 segmentDirection = segment.normalized; + float length = segment.magnitude; + + float dot = Vector3.Dot(relativePoint, segmentDirection); + + if (dot <= 0f) + return (point - segmentStart).sqrMagnitude; + else if (dot >= length) + return (point - segmentEnd).sqrMagnitude; + + return Vector3.Cross(relativePoint, segmentDirection).sqrMagnitude; + } + + private static bool Colinear(Vector3 v1, Vector3 v2, float error = 0.0001f) + { + return Mathf.Abs(v1.x * v2.y - v1.y * v2.x + v1.x * v2.z - v1.z * v2.x + v1.y * v2.z - v1.z * v2.y) < error; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Handles/Path/pointHovered.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Handles/Path/pointHovered.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..0b672503295954743c6f5296b7f1342f60676d93 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Handles/Path/pointHovered.png.meta @@ -0,0 +1,112 @@ +fileFormatVersion: 2 +guid: eaa90b7bb801a1144b58c4926d95ad6a +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 9 + 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: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: iPhone + 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: 357346b6d26030047a52ccb34ccb2886 + 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.path@4.0.1/Editor/Handles/Path/pointNormal.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Handles/Path/pointNormal.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..8f1e4fff98f47f76b950cc52769e93e39cdf56f0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Handles/Path/pointNormal.png.meta @@ -0,0 +1,112 @@ +fileFormatVersion: 2 +guid: 514bcbaba91a4704599b5b170200682a +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 9 + 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: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: iPhone + 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: 36cdba5fd2caa914892902a32774cdb8 + 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.path@4.0.1/Editor/Handles/Path/pointPreview.png.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Handles/Path/pointPreview.png.meta new file mode 100644 index 0000000000000000000000000000000000000000..afe71e02f1fa32ba33b2d3fb3946a42cd6f2e8a8 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Handles/Path/pointPreview.png.meta @@ -0,0 +1,112 @@ +fileFormatVersion: 2 +guid: 1d3a30b709ec7b94ab8997b21eae5849 +TextureImporter: + internalIDToNameTable: [] + externalObjects: {} + serializedVersion: 9 + 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: 1 + alignment: 0 + spritePivot: {x: 0.5, y: 0.5} + spritePixelsToUnits: 100 + spriteBorder: {x: 0, y: 0, z: 0, w: 0} + spriteGenerateFallbackPhysicsShape: 1 + alphaUsage: 1 + alphaIsTransparency: 1 + spriteTessellationDetail: -1 + textureType: 0 + textureShape: 1 + singleChannelComponent: 0 + maxTextureSizeSet: 0 + compressionQualitySet: 0 + textureFormatSet: 0 + platformSettings: + - serializedVersion: 2 + buildTarget: DefaultTexturePlatform + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: Standalone + maxTextureSize: 2048 + resizeAlgorithm: 0 + textureFormat: -1 + textureCompression: 0 + compressionQuality: 50 + crunchedCompression: 0 + allowsAlphaSplitting: 0 + overridden: 0 + androidETC2FallbackOverride: 0 + - serializedVersion: 2 + buildTarget: iPhone + 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: 52d8d99422b17e64bb6ba5d2dadd70b8 + 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.path@4.0.1/Editor/IMGUI/Drawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/Drawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..03edbfff34884a36da00221fc49a243cc163f23d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/Drawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1b31573f9ab124c47b5e877a88088db1 +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.path@4.0.1/Editor/IMGUI/GUIFramework.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework.meta new file mode 100644 index 0000000000000000000000000000000000000000..c15dd07636a2e7cd5bdb7d4066e77c29dcdcfb5b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 33e44f9d4edce8344a708573c37ebe4a +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.path@4.0.1/Editor/IMGUI/GUIFramework/LayoutData.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/LayoutData.cs new file mode 100644 index 0000000000000000000000000000000000000000..38e064a415d052e71cd5873991bf274163a157c7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/LayoutData.cs @@ -0,0 +1,25 @@ +using UnityEngine; + +namespace UnityEditor.U2D.Path.GUIFramework +{ + public struct LayoutData + { + public int index; + public float distance; + public Vector3 position; + public Vector3 forward; + public Vector3 up; + public Vector3 right; + public object userData; + + public static readonly LayoutData zero = new LayoutData() { index = 0, distance = float.MaxValue, position = Vector3.zero, forward = Vector3.forward, up = Vector3.up, right = Vector3.right }; + + public static LayoutData Nearest(LayoutData currentData, LayoutData newData) + { + if (newData.distance <= currentData.distance) + return newData; + + return currentData; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/LayoutData.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/LayoutData.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..9f108e9f00f7d2c6e899bf4d72d3bb7dfe8c5842 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/LayoutData.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 6aa087efd8b80a948a0b4273603bc269 +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.path@4.0.1/Editor/IMGUI/GUIFramework/SliderAction.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/SliderAction.cs new file mode 100644 index 0000000000000000000000000000000000000000..9466b4c5c8487d7cbaeec16dc899abd1a318a299 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/SliderAction.cs @@ -0,0 +1,60 @@ +using System; +using UnityEngine; + +namespace UnityEditor.U2D.Path.GUIFramework +{ + public class SliderAction : ClickAction + { + private SliderData m_SliderData; + + public Action onSliderBegin; + public Action onSliderChanged; + public Action onSliderEnd; + + public SliderAction(Control control) : base(control, 0, false) + { + } + + protected override bool GetFinishContidtion(IGUIState guiState) + { + return guiState.eventType == EventType.MouseUp && guiState.mouseButton == 0; + } + + + protected override void OnTrigger(IGUIState guiState) + { + base.OnTrigger(guiState); + + m_SliderData.position = hoveredControl.hotLayoutData.position; + m_SliderData.forward = hoveredControl.hotLayoutData.forward; + m_SliderData.right = hoveredControl.hotLayoutData.right; + m_SliderData.up = hoveredControl.hotLayoutData.up; + + if (onSliderBegin != null) + onSliderBegin(guiState, hoveredControl, m_SliderData.position); + } + + protected override void OnFinish(IGUIState guiState) + { + if (onSliderEnd != null) + onSliderEnd(guiState, hoveredControl, m_SliderData.position); + + guiState.UseEvent(); + guiState.Repaint(); + } + + protected override void OnPerform(IGUIState guiState) + { + Vector3 newPosition; + var changed = guiState.Slider(ID, m_SliderData, out newPosition); + + if (changed) + { + m_SliderData.position = newPosition; + + if (onSliderChanged != null) + onSliderChanged(guiState, hoveredControl, newPosition); + } + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/SliderAction.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/SliderAction.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f0b560b07b709b744955f36a592c15ac5bdb4cef --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/GUIFramework/SliderAction.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c6e0d9eacb9684e46b55a1fe312301e5 +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.path@4.0.1/Editor/IMGUI/IDrawer.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/IDrawer.cs new file mode 100644 index 0000000000000000000000000000000000000000..90e7a29c2ffa12a6378103214f384fb95c3493da --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/IDrawer.cs @@ -0,0 +1,15 @@ +using UnityEngine; + +namespace UnityEditor.U2D.Path +{ + public interface IDrawer + { + void DrawCreatePointPreview(Vector3 position); + void DrawPoint(Vector3 position); + void DrawPointHovered(Vector3 position); + void DrawPointSelected(Vector3 position); + void DrawLine(Vector3 p1, Vector3 p2, float width, Color color); + void DrawBezier(Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4, float width, Color color); + void DrawTangent(Vector3 position, Vector3 tangent); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/IDrawer.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/IDrawer.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..85be081d4ec0d2909dda382c22b7f8933605b9dd --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/IDrawer.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 1a38d8ca070072b4f82fca33e7316cc0 +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.path@4.0.1/Editor/IMGUI/PathEditor.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/PathEditor.cs new file mode 100644 index 0000000000000000000000000000000000000000..c4108632c2fc27fc1144f7cb823a624dd4ec6911 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/PathEditor.cs @@ -0,0 +1,537 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using UnityEngine; +using UnityEditor; +using UnityEditor.U2D.Path.GUIFramework; + +namespace UnityEditor.U2D.Path +{ + public class PathEditor + { + const float kSnappingDistance = 15f; + const string kDeleteCommandName = "Delete"; + const string kSoftDeleteCommandName = "SoftDelete"; + public IEditablePathController controller { get; set; } + public bool linearTangentIsZero { get; set; } + private IDrawer m_Drawer = new Drawer(); + private IDrawer m_DrawerOverride; + private GUISystem m_GUISystem; + + public IDrawer drawerOverride { get; set; } + + private IDrawer drawer + { + get + { + if (drawerOverride != null) + return drawerOverride; + + return m_Drawer; + } + } + + public PathEditor() : this(new GUISystem(new GUIState())) { } + + public PathEditor(GUISystem guiSystem) + { + m_GUISystem = guiSystem; + + var m_PointControl = new GenericControl("Point") + { + count = GetPointCount, + distance = (guiState, i) => + { + var position = GetPoint(i).position; + return guiState.DistanceToCircle(position, guiState.GetHandleSize(position) * 10f); + }, + position = (i) => { return GetPoint(i).position; }, + forward = (i) => { return GetForward(); }, + up = (i) => { return GetUp(); }, + right = (i) => { return GetRight(); }, + onRepaint = DrawPoint + }; + + var m_EdgeControl = new GenericControl("Edge") + { + count = GetEdgeCount, + distance = DistanceToEdge, + position = (i) => { return GetPoint(i).position; }, + forward = (i) => { return GetForward(); }, + up = (i) => { return GetUp(); }, + right = (i) => { return GetRight(); }, + onRepaint = DrawEdge + }; + m_EdgeControl.onEndLayout = (guiState) => { controller.AddClosestPath(m_EdgeControl.layoutData.distance); }; + + var m_LeftTangentControl = new GenericControl("LeftTangent") + { + count = () => + { + if (GetShapeType() != ShapeType.Spline) + return 0; + + return GetPointCount(); + }, + distance = (guiState, i) => + { + if (linearTangentIsZero && GetPoint(i).tangentMode == TangentMode.Linear) + return float.MaxValue; + + if (!IsSelected(i) || IsOpenEnded() && i == 0) + return float.MaxValue; + + var position = GetLeftTangent(i); + return guiState.DistanceToCircle(position, guiState.GetHandleSize(position) * 10f); + }, + position = (i) => { return GetLeftTangent(i); }, + forward = (i) => { return GetForward(); }, + up = (i) => { return GetUp(); }, + right = (i) => { return GetRight(); }, + onRepaint = (guiState, control, i) => + { + if (!IsSelected(i) || IsOpenEnded() && i == 0) + return; + + var point = GetPoint(i); + + if (linearTangentIsZero && point.tangentMode == TangentMode.Linear) + return; + + var position = point.position; + var leftTangent = GetLeftTangent(i); + + drawer.DrawTangent(position, leftTangent); + } + }; + + var m_RightTangentControl = new GenericControl("RightTangent") + { + count = () => + { + if (GetShapeType() != ShapeType.Spline) + return 0; + + return GetPointCount(); + }, + distance = (guiState, i) => + { + if (linearTangentIsZero && GetPoint(i).tangentMode == TangentMode.Linear) + return float.MaxValue; + + if (!IsSelected(i) || IsOpenEnded() && i == GetPointCount()-1) + return float.MaxValue; + + var position = GetRightTangent(i); + return guiState.DistanceToCircle(position, guiState.GetHandleSize(position) * 10f); + }, + position = (i) => { return GetRightTangent(i); }, + forward = (i) => { return GetForward(); }, + up = (i) => { return GetUp(); }, + right = (i) => { return GetRight(); }, + onRepaint = (guiState, control, i) => + { + if (!IsSelected(i) || IsOpenEnded() && i == GetPointCount()-1) + return; + + var point = GetPoint(i); + + if (linearTangentIsZero && point.tangentMode == TangentMode.Linear) + return; + + var position = point.position; + var rightTangent = GetRightTangent(i); + + drawer.DrawTangent(position, rightTangent); + } + }; + + var m_CreatePointAction = new CreatePointAction(m_PointControl, m_EdgeControl) + { + enable = (guiState, action) => !IsAltDown(guiState) && !guiState.isActionKeyDown && controller.closestEditablePath == controller.editablePath, + enableRepaint = (guiState, action) => EnableCreatePointRepaint(guiState, m_PointControl, m_LeftTangentControl, m_RightTangentControl), + repaintOnMouseMove = (guiState, action) => true, + guiToWorld = GUIToWorld, + onCreatePoint = (index, position) => + { + controller.RegisterUndo("Create Point"); + controller.CreatePoint(index, position); + }, + onPreRepaint = (guiState, action) => + { + if (GetPointCount() > 0) + { + var position = ClosestPointInEdge(guiState, guiState.mousePosition, m_EdgeControl.layoutData.index); + drawer.DrawCreatePointPreview(position); + } + } + }; + + Action removePoints = (guiState) => + { + controller.RegisterUndo("Remove Point"); + controller.RemoveSelectedPoints(); + guiState.changed = true; + }; + + var m_RemovePointAction1 = new CommandAction(kDeleteCommandName) + { + enable = (guiState, action) => { return GetSelectedPointCount() > 0; }, + onCommand = removePoints + }; + + var m_RemovePointAction2 = new CommandAction(kSoftDeleteCommandName) + { + enable = (guiState, action) => { return GetSelectedPointCount() > 0; }, + onCommand = removePoints + }; + + var dragged = false; + var m_MovePointAction = new SliderAction(m_PointControl) + { + enable = (guiState, action) => !IsAltDown(guiState), + onClick = (guiState, control) => + { + dragged = false; + var index = control.layoutData.index; + + if (!IsSelected(index)) + { + controller.RegisterUndo("Selection"); + + if (!guiState.isActionKeyDown) + controller.ClearSelection(); + + controller.SelectPoint(index, true); + guiState.changed = true; + } + }, + onSliderChanged = (guiState, control, position) => + { + var index = control.hotLayoutData.index; + var delta = SnapIfNeeded(position) - GetPoint(index).position; + + if (!dragged) + { + controller.RegisterUndo("Move Point"); + dragged = true; + } + + controller.MoveSelectedPoints(delta); + } + }; + + var m_MoveEdgeAction = new SliderAction(m_EdgeControl) + { + enable = (guiState, action) => !IsAltDown(guiState) && guiState.isActionKeyDown, + onSliderBegin = (guiState, control, position) => + { + dragged = false; + + }, + onSliderChanged = (guiState, control, position) => + { + var index = control.hotLayoutData.index; + var delta = position - GetPoint(index).position; + + if (!dragged) + { + controller.RegisterUndo("Move Edge"); + dragged = true; + } + + controller.MoveEdge(index, delta); + } + }; + + var cachedRightTangent = Vector3.zero; + var cachedLeftTangent = Vector3.zero; + var cachedTangentMode = TangentMode.Linear; + + var m_MoveLeftTangentAction = new SliderAction(m_LeftTangentControl) + { + enable = (guiState, action) => !IsAltDown(guiState), + onSliderBegin = (guiState, control, position) => + { + dragged = false; + var point = GetPoint(control.hotLayoutData.index); + cachedRightTangent = point.rightTangent; + cachedTangentMode = point.tangentMode; + }, + onSliderChanged = (guiState, control, position) => + { + var index = control.hotLayoutData.index; + var setToLinear = m_PointControl.distance(guiState, index) <= DefaultControl.kPickDistance; + + if (!dragged) + { + controller.RegisterUndo("Move Tangent"); + dragged = true; + } + + position = SnapIfNeeded(position); + controller.SetLeftTangent(index, position, setToLinear, guiState.isShiftDown, cachedRightTangent, cachedTangentMode); + + } + }; + + var m_MoveRightTangentAction = new SliderAction(m_RightTangentControl) + { + enable = (guiState, action) => !IsAltDown(guiState), + onSliderBegin = (guiState, control, position) => + { + dragged = false; + var point = GetPoint(control.hotLayoutData.index); + cachedLeftTangent = point.leftTangent; + cachedTangentMode = point.tangentMode; + }, + onSliderChanged = (guiState, control, position) => + { + var index = control.hotLayoutData.index; + var setToLinear = m_PointControl.distance(guiState, index) <= DefaultControl.kPickDistance; + + if (!dragged) + { + controller.RegisterUndo("Move Tangent"); + dragged = true; + } + + position = SnapIfNeeded(position); + controller.SetRightTangent(index, position, setToLinear, guiState.isShiftDown, cachedLeftTangent, cachedTangentMode); + } + }; + + m_GUISystem.AddControl(m_EdgeControl); + m_GUISystem.AddControl(m_PointControl); + m_GUISystem.AddControl(m_LeftTangentControl); + m_GUISystem.AddControl(m_RightTangentControl); + m_GUISystem.AddAction(m_CreatePointAction); + m_GUISystem.AddAction(m_RemovePointAction1); + m_GUISystem.AddAction(m_RemovePointAction2); + m_GUISystem.AddAction(m_MovePointAction); + m_GUISystem.AddAction(m_MoveEdgeAction); + m_GUISystem.AddAction(m_MoveLeftTangentAction); + m_GUISystem.AddAction(m_MoveRightTangentAction); + } + + public void OnGUI() + { + m_GUISystem.OnGUI(); + } + + private bool IsAltDown(IGUIState guiState) + { + return guiState.hotControl == 0 && guiState.isAltDown; + } + + private ControlPoint GetPoint(int index) + { + return controller.editablePath.GetPoint(index); + } + + private int GetPointCount() + { + return controller.editablePath.pointCount; + } + + private int GetEdgeCount() + { + if (controller.editablePath.isOpenEnded) + return controller.editablePath.pointCount - 1; + + return controller.editablePath.pointCount; + } + + private int GetSelectedPointCount() + { + return controller.editablePath.selection.Count; + } + + private bool IsSelected(int index) + { + return controller.editablePath.selection.Contains(index); + } + + private Vector3 GetForward() + { + return controller.editablePath.forward; + } + + private Vector3 GetUp() + { + return controller.editablePath.up; + } + + private Vector3 GetRight() + { + return controller.editablePath.right; + } + + private Matrix4x4 GetLocalToWorldMatrix() + { + return controller.editablePath.localToWorldMatrix; + } + + private ShapeType GetShapeType() + { + return controller.editablePath.shapeType; + } + + private bool IsOpenEnded() + { + return controller.editablePath.isOpenEnded; + } + + private Vector3 GetLeftTangent(int index) + { + if (linearTangentIsZero) + return GetPoint(index).leftTangent; + + return controller.editablePath.CalculateLeftTangent(index); + } + + private Vector3 GetRightTangent(int index) + { + if (linearTangentIsZero) + return GetPoint(index).rightTangent; + + return controller.editablePath.CalculateRightTangent(index); + } + + private int NextIndex(int index) + { + return EditablePathUtility.Mod(index + 1, GetPointCount()); + } + + private ControlPoint NextControlPoint(int index) + { + return GetPoint(NextIndex(index)); + } + + private int PrevIndex(int index) + { + return EditablePathUtility.Mod(index - 1, GetPointCount()); + } + + private ControlPoint PrevControlPoint(int index) + { + return GetPoint(PrevIndex(index)); + } + + private Vector3 ClosestPointInEdge(IGUIState guiState, Vector2 mousePosition, int index) + { + if (GetShapeType() == ShapeType.Polygon) + { + var p0 = GetPoint(index).position; + var p1 = NextControlPoint(index).position; + var mouseWorldPosition = GUIToWorld(guiState, mousePosition); + + var dir1 = (mouseWorldPosition - p0); + var dir2 = (p1 - p0); + + return Mathf.Clamp01(Vector3.Dot(dir1, dir2.normalized) / dir2.magnitude) * dir2 + p0; + } + else if (GetShapeType() == ShapeType.Spline) + { + var nextIndex = NextIndex(index); + float t; + return BezierUtility.ClosestPointOnCurve( + GUIToWorld(guiState, mousePosition), + GetPoint(index).position, + GetPoint(nextIndex).position, + GetRightTangent(index), + GetLeftTangent(nextIndex), + out t); + } + + return Vector3.zero; + } + + private float DistanceToEdge(IGUIState guiState, int index) + { + if (GetShapeType() == ShapeType.Polygon) + { + return guiState.DistanceToSegment(GetPoint(index).position, NextControlPoint(index).position); + } + else if (GetShapeType() == ShapeType.Spline) + { + var closestPoint = ClosestPointInEdge(guiState, guiState.mousePosition, index); + var closestPoint2 = HandleUtility.WorldToGUIPoint(closestPoint); + + return (closestPoint2 - guiState.mousePosition).magnitude; + } + + return float.MaxValue; + } + + private Vector3 GUIToWorld(IGUIState guiState, Vector2 position) + { + return guiState.GUIToWorld(position, GetForward(), GetLocalToWorldMatrix().MultiplyPoint3x4(Vector3.zero)); + } + + private void DrawPoint(IGUIState guiState, Control control, int index) + { + var position = GetPoint(index).position; + + if (guiState.hotControl == control.actionID && control.hotLayoutData.index == index || IsSelected(index)) + drawer.DrawPointSelected(position); + else if (guiState.hotControl == 0 && guiState.nearestControl == control.ID && !IsAltDown(guiState) && control.layoutData.index == index) + drawer.DrawPointHovered(position); + else + drawer.DrawPoint(position); + } + + private void DrawEdge(IGUIState guiState, Control control, int index) + { + if (GetShapeType() == ShapeType.Polygon) + { + var nextIndex = NextIndex(index); + var color = Color.white; + + if(guiState.nearestControl == control.ID && control.layoutData.index == index && guiState.hotControl == 0 && !IsAltDown(guiState)) + color = Color.yellow; + + drawer.DrawLine(GetPoint(index).position, GetPoint(nextIndex).position, 5f, color); + } + else if (GetShapeType() == ShapeType.Spline) + { + var nextIndex = NextIndex(index); + var color = Color.white; + + if(guiState.nearestControl == control.ID && control.layoutData.index == index && guiState.hotControl == 0 && !IsAltDown(guiState)) + color = Color.yellow; + + drawer.DrawBezier( + GetPoint(index).position, + GetRightTangent(index), + GetLeftTangent(nextIndex), + GetPoint(nextIndex).position, + 5f, + color); + } + } + + private bool EnableCreatePointRepaint(IGUIState guiState, Control pointControl, Control leftTangentControl, Control rightTangentControl) + { + return guiState.nearestControl != pointControl.ID && + guiState.hotControl == 0 && + (guiState.nearestControl != leftTangentControl.ID) && + (guiState.nearestControl != rightTangentControl.ID); + } + + private Vector3 SnapIfNeeded(Vector3 position) + { + if (!controller.enableSnapping || controller.snapping == null) + return position; + + var guiPosition = HandleUtility.WorldToGUIPoint(position); + var snappedGuiPosition = HandleUtility.WorldToGUIPoint(controller.snapping.Snap(position)); + var sqrDistance = (guiPosition - snappedGuiPosition).sqrMagnitude; + + if (sqrDistance < kSnappingDistance * kSnappingDistance) + position = controller.snapping.Snap(position); + + return position; + } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/PathEditor.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/PathEditor.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..45867450325a65d7cb8c8122666ebe50b416b20a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/PathEditor.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 20eb80169ce2c0944aca58413fc34b1a +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.path@4.0.1/Editor/IMGUI/RectSelector.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/RectSelector.cs new file mode 100644 index 0000000000000000000000000000000000000000..5f2a12cb0e43542b897dce89ab4f124db6362b09 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/RectSelector.cs @@ -0,0 +1,132 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using UnityEditor; +using UnityEditor.U2D.Path.GUIFramework; + +namespace UnityEditor.U2D.Path +{ + public abstract class RectSelector : ISelector + { + public class Styles + { + public readonly GUIStyle selectionRectStyle; + + public Styles() + { + selectionRectStyle = GUI.skin.FindStyle("selectionRect"); + } + } + + public Action, bool> onSelectionBegin; + public Action> onSelectionChanged; + public Action> onSelectionEnd; + + private GUISystem m_GUISystem; + private Control m_RectSelectorControl; + private GUIAction m_RectSelectAction; + private Rect m_GUIRect; + private Styles m_Styles; + + public Rect guiRect + { + get { return m_GUIRect; } + } + + private Styles styles + { + get + { + if (m_Styles == null) + m_Styles = new Styles(); + + return m_Styles; + } + } + + public RectSelector() : this(new GUISystem(new GUIState())) { } + + public RectSelector(GUISystem guiSystem) + { + m_GUISystem = guiSystem; + + m_RectSelectorControl = new GenericDefaultControl("RectSelector"); + + var start = Vector2.zero; + var rectEnd = Vector2.zero; + m_RectSelectAction = new SliderAction(m_RectSelectorControl) + { + enable = (guiState, action) => !IsAltDown(guiState), + enableRepaint = (guiState, action) => + { + var size = start - rectEnd; + return size != Vector2.zero && guiState.hotControl == action.ID; + }, + onSliderBegin = (guiState, control, position) => + { + start = guiState.mousePosition; + rectEnd = guiState.mousePosition; + m_GUIRect = FromToRect(start, rectEnd); + + if (onSelectionBegin != null) + onSelectionBegin(this, guiState.isShiftDown); + }, + onSliderChanged = (guiState, control, position) => + { + rectEnd = guiState.mousePosition; + m_GUIRect = FromToRect(start, rectEnd); + + if (onSelectionChanged != null) + onSelectionChanged(this); + }, + onSliderEnd = (guiState, control, position) => + { + if (onSelectionEnd != null) + onSelectionEnd(this); + }, + onRepaint = (guiState, action) => + { + Handles.BeginGUI(); + styles.selectionRectStyle.Draw(m_GUIRect, GUIContent.none, false, false, false, false); + Handles.EndGUI(); + } + }; + + m_GUISystem.AddControl(m_RectSelectorControl); + m_GUISystem.AddAction(m_RectSelectAction); + } + + private bool IsAltDown(IGUIState guiState) + { + return guiState.hotControl == 0 && guiState.isAltDown; + } + + private Rect FromToRect(Vector2 start, Vector2 end) + { + Rect r = new Rect(start.x, start.y, end.x - start.x, end.y - start.y); + if (r.width < 0) + { + r.x += r.width; + r.width = -r.width; + } + if (r.height < 0) + { + r.y += r.height; + r.height = -r.height; + } + return r; + } + + public void OnGUI() + { + m_GUISystem.OnGUI(); + } + + bool ISelector.Select(T element) + { + return Select(element); + } + + protected abstract bool Select(T element); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/RectSelector.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/RectSelector.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a2c38cf420ec4070f8b60884fbaeca2fc87cd90a --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/IMGUI/RectSelector.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 24a6adab990cd9541b5ad6343eb12b32 +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.path@4.0.1/Editor/Selection/IndexedSelection.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Selection/IndexedSelection.cs new file mode 100644 index 0000000000000000000000000000000000000000..2b20e5bba4a4b26d72243a63c0cdbe0896b9ed33 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Selection/IndexedSelection.cs @@ -0,0 +1,13 @@ +using UnityEngine; +using System; +using System.Collections; +using System.Collections.Generic; + +namespace UnityEditor.U2D.Path +{ + [Serializable] + internal class IndexedSelection : SerializableSelection + { + protected override int GetInvalidElement() { return -1; } + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Unity.2D.Path.Editor.asmdef b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Unity.2D.Path.Editor.asmdef new file mode 100644 index 0000000000000000000000000000000000000000..7b6525c1fff75a0be0ccb1830fa6336ddaf32577 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Unity.2D.Path.Editor.asmdef @@ -0,0 +1,15 @@ +{ + "name": "Unity.2D.Path.Editor", + "references": [], + "optionalUnityReferences": [], + "includePlatforms": [ + "Editor" + ], + "excludePlatforms": [], + "allowUnsafeCode": false, + "overrideReferences": false, + "precompiledReferences": [], + "autoReferenced": true, + "defineConstraints": [], + "versionDefines": [] +} \ 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.path@4.0.1/Editor/Unity.2D.Path.Editor.asmdef.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Unity.2D.Path.Editor.asmdef.meta new file mode 100644 index 0000000000000000000000000000000000000000..fe7ef0a31f68c21a0015435259957d5f08b6bfc9 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Editor/Unity.2D.Path.Editor.asmdef.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 4237adb6ac177124b8f4a94835b7b455 +AssemblyDefinitionImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/PlaceholderTests.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/PlaceholderTests.cs new file mode 100644 index 0000000000000000000000000000000000000000..af418f1c586e1918de5a4e7981810665d4319fce --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/PlaceholderTests.cs @@ -0,0 +1,10 @@ +using NUnit.Framework; + +internal class PathPlaceholder +{ + [Test] + public void PlaceHolderTest() + { + Assert.Pass("Path tests are in a separate package."); + } +} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/PlaceholderTests.cs.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/PlaceholderTests.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..bc4407101b3358679ba07bd54350cd5b6cb27a0e --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/PlaceholderTests.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 685b325483700af4abc5c9b7b9d97757 +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.path@4.0.1/Tests/Unity.2D.Path.Tests.asmdef b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/Unity.2D.Path.Tests.asmdef new file mode 100644 index 0000000000000000000000000000000000000000..5d4e4c676ba6cd9bdeba17fcd49c47002be3ab60 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/Unity.2D.Path.Tests.asmdef @@ -0,0 +1,20 @@ +{ + "name": "Unity.2D.Path.Tests", + "references": [ + ], + "includePlatforms": [ + "Editor" + ], + "excludePlatforms": [], + "allowUnsafeCode": false, + "overrideReferences": true, + "precompiledReferences": [ + "nunit.framework.dll" + ], + "autoReferenced": false, + "defineConstraints": [ + "UNITY_INCLUDE_TESTS" + ], + "versionDefines": [], + "noEngineReferences": false +} \ 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.path@4.0.1/Tests/Unity.2D.Path.Tests.asmdef.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/Unity.2D.Path.Tests.asmdef.meta new file mode 100644 index 0000000000000000000000000000000000000000..34039d2b6592eefa025ff54e8c6080584c081c49 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.path@4.0.1/Tests/Unity.2D.Path.Tests.asmdef.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 6d12c3e51f4c89149908f5b37ad1301c +AssemblyDefinitionImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Extras/Custom Canvas Scaler/CustomCanvasScaler.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Extras/Custom Canvas Scaler/CustomCanvasScaler.cs new file mode 100644 index 0000000000000000000000000000000000000000..b5eab87a140e9d7288ba53f790bcf75772ce47be --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Extras/Custom Canvas Scaler/CustomCanvasScaler.cs @@ -0,0 +1,71 @@ +#if UGUI_1_0_0_OR_NEWER +using UnityEngine; +using UnityEngine.UI; + +public class CustomCanvasScaler : CanvasScaler +{ + private Canvas m_RootCanvas; + private const float kLogBase = 2; + + protected override void OnEnable() + { + m_RootCanvas = GetComponent(); + base.OnEnable(); + } + + protected override void HandleScaleWithScreenSize() + { + Vector2 screenSize; + if (m_RootCanvas.worldCamera != null) + { + screenSize = new Vector2(m_RootCanvas.worldCamera.pixelWidth, m_RootCanvas.worldCamera.pixelHeight); + } + else + { + screenSize = new Vector2(Screen.width, Screen.height); + } + + // Multiple display support only when not the main display. For display 0 the reported + // resolution is always the desktops resolution since its part of the display API, + // so we use the standard none multiple display method. (case 741751) + int displayIndex = m_RootCanvas.targetDisplay; + if (displayIndex > 0 && displayIndex < Display.displays.Length) + { + Display disp = Display.displays[displayIndex]; + screenSize = new Vector2(disp.renderingWidth, disp.renderingHeight); + } + + float scaleFactor = 0; + switch (m_ScreenMatchMode) + { + case ScreenMatchMode.MatchWidthOrHeight: + { + // We take the log of the relative width and height before taking the average. + // Then we transform it back in the original space. + // the reason to transform in and out of logarithmic space is to have better behavior. + // If one axis has twice resolution and the other has half, it should even out if widthOrHeight value is at 0.5. + // In normal space the average would be (0.5 + 2) / 2 = 1.25 + // In logarithmic space the average is (-1 + 1) / 2 = 0 + float logWidth = Mathf.Log(screenSize.x / m_ReferenceResolution.x, kLogBase); + float logHeight = Mathf.Log(screenSize.y / m_ReferenceResolution.y, kLogBase); + float logWeightedAverage = Mathf.Lerp(logWidth, logHeight, m_MatchWidthOrHeight); + scaleFactor = Mathf.Pow(kLogBase, logWeightedAverage); + break; + } + case ScreenMatchMode.Expand: + { + scaleFactor = Mathf.Min(screenSize.x / m_ReferenceResolution.x, screenSize.y / m_ReferenceResolution.y); + break; + } + case ScreenMatchMode.Shrink: + { + scaleFactor = Mathf.Max(screenSize.x / m_ReferenceResolution.x, screenSize.y / m_ReferenceResolution.y); + break; + } + } + + SetScaleFactor(scaleFactor); + SetReferencePixelsPerUnit(m_ReferencePixelsPerUnit); + } +} +#endif diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated Parent.controller b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated Parent.controller new file mode 100644 index 0000000000000000000000000000000000000000..ba804e274ad623710cea0ec49c0f3eb2da30122d --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated Parent.controller @@ -0,0 +1,69 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!91 &9100000 +AnimatorController: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInternal: {fileID: 0} + m_Name: Hero - Animated Parent + serializedVersion: 5 + m_AnimatorParameters: [] + m_AnimatorLayers: + - serializedVersion: 5 + m_Name: Base Layer + m_StateMachine: {fileID: 1107776340298020612} + m_Mask: {fileID: 0} + m_Motions: [] + m_Behaviours: [] + m_BlendingMode: 0 + m_SyncedLayerIndex: -1 + m_DefaultWeight: 0 + m_IKPass: 0 + m_SyncedLayerAffectsTiming: 0 + m_Controller: {fileID: 9100000} +--- !u!1102 &1102092394750910678 +AnimatorState: + serializedVersion: 5 + m_ObjectHideFlags: 1 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInternal: {fileID: 0} + m_Name: New Animation + m_Speed: 1 + m_CycleOffset: 0 + m_Transitions: [] + m_StateMachineBehaviours: [] + m_Position: {x: 50, y: 50, z: 0} + m_IKOnFeet: 0 + m_WriteDefaultValues: 1 + m_Mirror: 0 + m_SpeedParameterActive: 0 + m_MirrorParameterActive: 0 + m_CycleOffsetParameterActive: 0 + m_TimeParameterActive: 0 + m_Motion: {fileID: 7400000, guid: bcd1b955207624e779f5753cda5a9db5, type: 2} + m_Tag: + m_SpeedParameter: + m_MirrorParameter: + m_CycleOffsetParameter: + m_TimeParameter: +--- !u!1107 &1107776340298020612 +AnimatorStateMachine: + serializedVersion: 5 + m_ObjectHideFlags: 1 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInternal: {fileID: 0} + m_Name: Base Layer + m_ChildStates: + - serializedVersion: 1 + m_State: {fileID: 1102092394750910678} + m_Position: {x: 200, y: 0, z: 0} + m_ChildStateMachines: [] + m_AnyStateTransitions: [] + m_EntryTransitions: [] + m_StateMachineTransitions: {} + m_StateMachineBehaviours: [] + m_AnyStatePosition: {x: 50, y: 20, z: 0} + m_EntryPosition: {x: 50, y: 120, z: 0} + m_ExitPosition: {x: 800, y: 120, z: 0} + m_ParentStateMachinePosition: {x: 800, y: 20, z: 0} + m_DefaultState: {fileID: 1102092394750910678} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated Parent.controller.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated Parent.controller.meta new file mode 100644 index 0000000000000000000000000000000000000000..9f465f64a30e5aadbcaf98f53acb50e732444f4c --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated Parent.controller.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 88052358f50444723945fd406586b51d +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 9100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated.controller b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated.controller new file mode 100644 index 0000000000000000000000000000000000000000..3b74e6118b903eb2e89315abd0f7d7fb65c926e7 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated.controller @@ -0,0 +1,69 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!91 &9100000 +AnimatorController: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInternal: {fileID: 0} + m_Name: Hero - Animated + serializedVersion: 5 + m_AnimatorParameters: [] + m_AnimatorLayers: + - serializedVersion: 5 + m_Name: Base Layer + m_StateMachine: {fileID: 1107137455478800888} + m_Mask: {fileID: 0} + m_Motions: [] + m_Behaviours: [] + m_BlendingMode: 0 + m_SyncedLayerIndex: -1 + m_DefaultWeight: 0 + m_IKPass: 0 + m_SyncedLayerAffectsTiming: 0 + m_Controller: {fileID: 9100000} +--- !u!1102 &1102101695326265708 +AnimatorState: + serializedVersion: 5 + m_ObjectHideFlags: 1 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInternal: {fileID: 0} + m_Name: New Animation + m_Speed: 1 + m_CycleOffset: 0 + m_Transitions: [] + m_StateMachineBehaviours: [] + m_Position: {x: 50, y: 50, z: 0} + m_IKOnFeet: 0 + m_WriteDefaultValues: 1 + m_Mirror: 0 + m_SpeedParameterActive: 0 + m_MirrorParameterActive: 0 + m_CycleOffsetParameterActive: 0 + m_TimeParameterActive: 0 + m_Motion: {fileID: 7400000, guid: 7237359e596ae4b3493528d1dc54c6bc, type: 2} + m_Tag: + m_SpeedParameter: + m_MirrorParameter: + m_CycleOffsetParameter: + m_TimeParameter: +--- !u!1107 &1107137455478800888 +AnimatorStateMachine: + serializedVersion: 5 + m_ObjectHideFlags: 1 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInternal: {fileID: 0} + m_Name: Base Layer + m_ChildStates: + - serializedVersion: 1 + m_State: {fileID: 1102101695326265708} + m_Position: {x: 200, y: 0, z: 0} + m_ChildStateMachines: [] + m_AnyStateTransitions: [] + m_EntryTransitions: [] + m_StateMachineTransitions: {} + m_StateMachineBehaviours: [] + m_AnyStatePosition: {x: 50, y: 20, z: 0} + m_EntryPosition: {x: 50, y: 120, z: 0} + m_ExitPosition: {x: 800, y: 120, z: 0} + m_ParentStateMachinePosition: {x: 800, y: 20, z: 0} + m_DefaultState: {fileID: 1102101695326265708} diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated.controller.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated.controller.meta new file mode 100644 index 0000000000000000000000000000000000000000..083707cc96bc9d033182c24e4165a9f4e27dbf19 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Animators/Hero - Animated.controller.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 945d9f228206f4b4eaa8579bc6a10b18 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 9100000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Hero Animation.anim b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Hero Animation.anim new file mode 100644 index 0000000000000000000000000000000000000000..8c1f118d4da14f7ed452a7a4d4a1fb09c4bb5794 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Hero Animation.anim @@ -0,0 +1,241 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!74 &7400000 +AnimationClip: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInternal: {fileID: 0} + m_Name: Hero Animation + serializedVersion: 6 + m_Legacy: 0 + m_Compressed: 0 + m_UseHighQualityCurve: 1 + m_RotationCurves: [] + m_CompressedRotationCurves: [] + m_EulerCurves: [] + m_PositionCurves: + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: 0 + value: {x: -0.75, y: 1.5, z: 0} + inSlope: {x: 0, y: 0, z: 0} + outSlope: {x: 0, y: 0, z: 0} + tangentMode: 0 + weightedMode: 0 + inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + - serializedVersion: 3 + time: 1.3333334 + value: {x: 1.04, y: 1.5, z: 0} + inSlope: {x: 0, y: 0, z: 0} + outSlope: {x: 0, y: 0, z: 0} + tangentMode: 0 + weightedMode: 0 + inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + - serializedVersion: 3 + time: 2.6666667 + value: {x: 0.12, y: 0.64, z: 0} + inSlope: {x: -0.67125005, y: 0, z: 0} + outSlope: {x: -0.67125005, y: 0, z: 0} + tangentMode: 0 + weightedMode: 0 + inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + - serializedVersion: 3 + time: 4 + value: {x: -0.75, y: 1.5, z: 0} + inSlope: {x: 0, y: 0, z: 0} + outSlope: {x: 0, y: 0, z: 0} + tangentMode: 0 + weightedMode: 0 + inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + path: + m_ScaleCurves: [] + m_FloatCurves: [] + m_PPtrCurves: [] + m_SampleRate: 60 + m_WrapMode: 0 + m_Bounds: + m_Center: {x: 0, y: 0, z: 0} + m_Extent: {x: 0, y: 0, z: 0} + m_ClipBindingConstant: + genericBindings: + - serializedVersion: 2 + path: 0 + attribute: 1 + script: {fileID: 0} + typeID: 4 + customType: 0 + isPPtrCurve: 0 + pptrCurveMapping: [] + m_AnimationClipSettings: + serializedVersion: 2 + m_AdditiveReferencePoseClip: {fileID: 0} + m_AdditiveReferencePoseTime: 0 + m_StartTime: 0 + m_StopTime: 4 + m_OrientationOffsetY: 0 + m_Level: 0 + m_CycleOffset: 0 + m_HasAdditiveReferencePose: 0 + m_LoopTime: 1 + m_LoopBlend: 0 + m_LoopBlendOrientation: 0 + m_LoopBlendPositionY: 0 + m_LoopBlendPositionXZ: 0 + m_KeepOriginalOrientation: 0 + m_KeepOriginalPositionY: 1 + m_KeepOriginalPositionXZ: 0 + m_HeightFromFeet: 0 + m_Mirror: 0 + m_EditorCurves: + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: 0 + value: -0.75 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 1.3333334 + value: 1.04 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 2.6666667 + value: 0.12 + inSlope: -0.67125005 + outSlope: -0.67125005 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 4 + value: -0.75 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: m_LocalPosition.x + path: + classID: 4 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: 0 + value: 1.5 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 1.3333334 + value: 1.5 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 2.6666667 + value: 0.64 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 4 + value: 1.5 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: m_LocalPosition.y + path: + classID: 4 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 1.3333334 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 2.6666667 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 4 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: m_LocalPosition.z + path: + classID: 4 + script: {fileID: 0} + m_EulerEditorCurves: [] + m_HasGenericRootTransform: 1 + m_HasMotionFloatCurves: 0 + m_GenerateMotionCurves: 0 + m_Events: [] diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Hero Animation.anim.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Hero Animation.anim.meta new file mode 100644 index 0000000000000000000000000000000000000000..f214ece080c7bda5de6aa8a4ea50492532c0da08 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Hero Animation.anim.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 7237359e596ae4b3493528d1dc54c6bc +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 7400000 + userData: + assetBundleName: + assetBundleVariant: diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Parent Hero Animation.anim b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Parent Hero Animation.anim new file mode 100644 index 0000000000000000000000000000000000000000..4c887d4d9f03c0d57f5bb3b4647afab2c2d024ad --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Parent Hero Animation.anim @@ -0,0 +1,241 @@ +%YAML 1.1 +%TAG !u! tag:unity3d.com,2011: +--- !u!74 &7400000 +AnimationClip: + m_ObjectHideFlags: 0 + m_CorrespondingSourceObject: {fileID: 0} + m_PrefabInternal: {fileID: 0} + m_Name: Parent Hero Animation + serializedVersion: 6 + m_Legacy: 0 + m_Compressed: 0 + m_UseHighQualityCurve: 1 + m_RotationCurves: [] + m_CompressedRotationCurves: [] + m_EulerCurves: [] + m_PositionCurves: + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: 0 + value: {x: 2, y: -1.5, z: 0} + inSlope: {x: 0, y: 0, z: 0} + outSlope: {x: 0, y: 0, z: 0} + tangentMode: 0 + weightedMode: 0 + inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + - serializedVersion: 3 + time: 1.3333334 + value: {x: 4.05, y: -1.5, z: 0} + inSlope: {x: 0, y: 0, z: 0} + outSlope: {x: 0, y: 0, z: 0} + tangentMode: 0 + weightedMode: 0 + inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + - serializedVersion: 3 + time: 2.6666667 + value: {x: 3, y: -2.28, z: 0} + inSlope: {x: -0.76875013, y: 0, z: 0} + outSlope: {x: -0.76875013, y: 0, z: 0} + tangentMode: 0 + weightedMode: 0 + inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + - serializedVersion: 3 + time: 4 + value: {x: 2, y: -1.5, z: 0} + inSlope: {x: 0, y: 0, z: 0} + outSlope: {x: 0, y: 0, z: 0} + tangentMode: 0 + weightedMode: 0 + inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334} + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + path: + m_ScaleCurves: [] + m_FloatCurves: [] + m_PPtrCurves: [] + m_SampleRate: 60 + m_WrapMode: 0 + m_Bounds: + m_Center: {x: 0, y: 0, z: 0} + m_Extent: {x: 0, y: 0, z: 0} + m_ClipBindingConstant: + genericBindings: + - serializedVersion: 2 + path: 0 + attribute: 1 + script: {fileID: 0} + typeID: 4 + customType: 0 + isPPtrCurve: 0 + pptrCurveMapping: [] + m_AnimationClipSettings: + serializedVersion: 2 + m_AdditiveReferencePoseClip: {fileID: 0} + m_AdditiveReferencePoseTime: 0 + m_StartTime: 0 + m_StopTime: 4 + m_OrientationOffsetY: 0 + m_Level: 0 + m_CycleOffset: 0 + m_HasAdditiveReferencePose: 0 + m_LoopTime: 1 + m_LoopBlend: 0 + m_LoopBlendOrientation: 0 + m_LoopBlendPositionY: 0 + m_LoopBlendPositionXZ: 0 + m_KeepOriginalOrientation: 0 + m_KeepOriginalPositionY: 1 + m_KeepOriginalPositionXZ: 0 + m_HeightFromFeet: 0 + m_Mirror: 0 + m_EditorCurves: + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: 0 + value: 2 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 1.3333334 + value: 4.05 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 2.6666667 + value: 3 + inSlope: -0.76875013 + outSlope: -0.76875013 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 4 + value: 2 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: m_LocalPosition.x + path: + classID: 4 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: 0 + value: -1.5 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 1.3333334 + value: -1.5 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 2.6666667 + value: -2.28 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 4 + value: -1.5 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: m_LocalPosition.y + path: + classID: 4 + script: {fileID: 0} + - curve: + serializedVersion: 2 + m_Curve: + - serializedVersion: 3 + time: 0 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 1.3333334 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 2.6666667 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + - serializedVersion: 3 + time: 4 + value: 0 + inSlope: 0 + outSlope: 0 + tangentMode: 136 + weightedMode: 0 + inWeight: 0.33333334 + outWeight: 0.33333334 + m_PreInfinity: 2 + m_PostInfinity: 2 + m_RotationOrder: 4 + attribute: m_LocalPosition.z + path: + classID: 4 + script: {fileID: 0} + m_EulerEditorCurves: [] + m_HasGenericRootTransform: 1 + m_HasMotionFloatCurves: 0 + m_GenerateMotionCurves: 0 + m_Events: [] diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Parent Hero Animation.anim.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Parent Hero Animation.anim.meta new file mode 100644 index 0000000000000000000000000000000000000000..a1f0e8ab7bd854d9b4138071d98ca7dda8087ad4 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.2d.pixel-perfect@4.0.1/Samples~/Scenes and Extras/Scenes/Animation/Clips/Parent Hero Animation.anim.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: bcd1b955207624e779f5753cda5a9db5 +NativeFormatImporter: + externalObjects: {} + mainObjectFileID: 7400000 + 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.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.meta new file mode 100644 index 0000000000000000000000000000000000000000..10cf1f2661b72a0ec377491fdc92ad4bc65672d8 --- /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.meta @@ -0,0 +1,8 @@ +fileFormatVersion: 2 +guid: 1d6d62c94d82bf748b95682fa88ef3b9 +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.mathematics@1.1.0/Tests/Tests/Shared/TestBitmanipulation.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/TestBitmanipulation.cs new file mode 100644 index 0000000000000000000000000000000000000000..1c1be1e63f34296ac0d51cdcc4914b99064a19b7 --- /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/TestBitmanipulation.cs @@ -0,0 +1,547 @@ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBitmanipulation + { + [TestCompiler] + public static void bitmask_bool4() + { + TestUtils.AreEqual(0b0000, bitmask(new bool4(false, false, false, false))); + TestUtils.AreEqual(0b0001, bitmask(new bool4(true, false, false, false))); + TestUtils.AreEqual(0b0010, bitmask(new bool4(false, true, false, false))); + TestUtils.AreEqual(0b0100, bitmask(new bool4(false, false, true, false))); + TestUtils.AreEqual(0b1000, bitmask(new bool4(false, false, false, true))); + + TestUtils.AreEqual(0b1111, bitmask(new bool4(true, true, true, true))); + TestUtils.AreEqual(0b1110, bitmask(new bool4(false, true, true, true))); + TestUtils.AreEqual(0b1101, bitmask(new bool4(true, false, true, true))); + TestUtils.AreEqual(0b1011, bitmask(new bool4(true, true, false, true))); + TestUtils.AreEqual(0b0111, bitmask(new bool4(true, true, true, false))); + } + + [TestCompiler] + public static void countbits_int1() + { + TestUtils.AreEqual(countbits( 0x01234567), 12); + TestUtils.AreEqual(countbits( 0x456789AB), 16); + TestUtils.AreEqual(countbits(-0x01234567), 21); + TestUtils.AreEqual(countbits(-0x456789AB), 17); + TestUtils.AreEqual(countbits(-1), 32); + } + + [TestCompiler] + public static void countbits_int2() + { + TestUtils.AreEqual(countbits(int2(0, 0x01234567)), int2(0, 12)); + TestUtils.AreEqual(countbits(int2(0x456789AB, -0x01234567)), int2(16, 21)); + TestUtils.AreEqual(countbits(int2(-0x456789AB, -1)), int2(17, 32)); + } + + [TestCompiler] + public static void countbits_int3() + { + TestUtils.AreEqual(countbits(int3(0, 0x01234567, 0x456789AB)), int3(0, 12, 16)); + TestUtils.AreEqual(countbits(int3(-0x01234567, -0x456789AB, -1)), int3(21, 17, 32)); + } + + [TestCompiler] + public static void countbits_int4() + { + TestUtils.AreEqual(countbits(int4(0, 0x01234567, 0x456789AB, -0x01234567)), int4(0, 12, 16, 21)); + TestUtils.AreEqual(countbits(int4(-0x456789AB, -1, -7, -15)), int4(17, 32, 30, 29)); + } + + [TestCompiler] + public static void countbits_uint() + { + TestUtils.AreEqual(countbits(0u), 0); + TestUtils.AreEqual(countbits(0x01234567u), 12); + TestUtils.AreEqual(countbits(0x456789ABu), 16); + TestUtils.AreEqual(countbits(0x89ABCDEFu), 20); + TestUtils.AreEqual(countbits(0xCDEF0123u), 16); + TestUtils.AreEqual(countbits(0xFFFFFFFFu), 32); + } + + [TestCompiler] + public static void countbits_uint2() + { + TestUtils.AreEqual(countbits(uint2(0, 0x01234567)), int2(0, 12)); + TestUtils.AreEqual(countbits(uint2(0x456789AB, 0x89ABCDEFu)), int2(16, 20)); + TestUtils.AreEqual(countbits(uint2(0xCDEF0123u, 0xFFFFFFFFu)), int2(16, 32)); + } + + [TestCompiler] + public static void countbits_uint3() + { + TestUtils.AreEqual(countbits(uint3(0, 0x01234567, 0x456789AB)), int3(0, 12, 16)); + TestUtils.AreEqual(countbits(uint3(0x89ABCDEFu, 0xCDEF0123u, 0xFFFFFFFFu)), int3(20, 16, 32)); + } + + [TestCompiler] + public static void countbits_uint4() + { + TestUtils.AreEqual(countbits(uint4(0, 0x01234567, 0x456789AB, 0x89ABCDEFu)), int4(0, 12, 16, 20)); + TestUtils.AreEqual(countbits(uint4(0xCDEF0123u, 0xFFFFFFFFu, 0xFFFFFFF5u, 0xFFFFFFF1u)), int4(16, 32, 30, 29)); + } + + [TestCompiler] + public static void countbits_long() + { + TestUtils.AreEqual(countbits(0L), 0); + TestUtils.AreEqual(countbits(0x0123456789ABCDEFL), 32); + TestUtils.AreEqual(countbits(-0x0123456789ABCDEFL), 33); + TestUtils.AreEqual(countbits(-1L), 64); + } + + [TestCompiler] + public static void countbits_ulong() + { + TestUtils.AreEqual(countbits(0UL), 0); + TestUtils.AreEqual(countbits(0x0123456789ABCDEFUL), 32); + TestUtils.AreEqual(countbits(0x89ABCDEF01234567UL), 32); + TestUtils.AreEqual(countbits(0xFFFFFFFFFFFFFFFFUL), 64); + } + + [TestCompiler] + public static void lzcnt_int() + { + TestUtils.AreEqual(lzcnt(0), 32); + TestUtils.AreEqual(lzcnt(1), 31); + TestUtils.AreEqual(lzcnt(2), 30); + TestUtils.AreEqual(lzcnt(3), 30); + TestUtils.AreEqual(lzcnt(0x5321), 17); + TestUtils.AreEqual(lzcnt(0x04435321), 5); + TestUtils.AreEqual(lzcnt(-1), 0); + TestUtils.AreEqual(lzcnt(-2147483648), 0); + } + + [TestCompiler] + public static void lzcnt_int2() + { + TestUtils.AreEqual(lzcnt(int2(0, 1)), int2(32, 31)); + TestUtils.AreEqual(lzcnt(int2(2, 3)), int2(30, 30)); + TestUtils.AreEqual(lzcnt(int2(0x5321, 0x04435321)), int2(17, 5)); + TestUtils.AreEqual(lzcnt(int2(-1, -2147483648)), int2(0, 0)); + } + + [TestCompiler] + public static void lzcnt_int3() + { + TestUtils.AreEqual(lzcnt(int3(0, 1, 2)), int3(32, 31, 30)); + TestUtils.AreEqual(lzcnt(int3(3, 0x5321, 0x04435321)), int3(30, 17, 5)); + TestUtils.AreEqual(lzcnt(int3(-1, -2147483648, 17)), int3(0, 0, 27)); + } + + [TestCompiler] + public static void lzcnt_int4() + { + TestUtils.AreEqual(lzcnt(int4(0, 1, 2, 3)), int4(32, 31, 30, 30)); + TestUtils.AreEqual(lzcnt(int4(0x5321, 0x04435321, -1, -2147483648)), int4(17, 5, 0, 0)); + } + + [TestCompiler] + public static void lzcnt_uint() + { + TestUtils.AreEqual(lzcnt(0u), 32); + TestUtils.AreEqual(lzcnt(1u), 31); + TestUtils.AreEqual(lzcnt(2u), 30); + TestUtils.AreEqual(lzcnt(3u), 30); + TestUtils.AreEqual(lzcnt(0x5321u), 17); + TestUtils.AreEqual(lzcnt(0x04435321u), 5); + TestUtils.AreEqual(lzcnt(0x84435320u), 0); + TestUtils.AreEqual(lzcnt(0xFFFFFFFFu), 0); + } + + [TestCompiler] + public static void lzcnt_uint2() + { + TestUtils.AreEqual(lzcnt(uint2(0u, 1u)), int2(32, 31)); + TestUtils.AreEqual(lzcnt(uint2(2u, 3u)), int2(30, 30)); + TestUtils.AreEqual(lzcnt(uint2(0x5321u, 0x04435321u)), int2(17, 5)); + TestUtils.AreEqual(lzcnt(uint2(0x84435320u, 0xFFFFFFFFu)), int2(0, 0)); + } + + [TestCompiler] + public static void lzcnt_uint3() + { + TestUtils.AreEqual(lzcnt(uint3(0u, 1u, 2u)), int3(32, 31, 30)); + TestUtils.AreEqual(lzcnt(uint3(3u, 0x5321u, 0x04435321u)), int3(30, 17, 5)); + TestUtils.AreEqual(lzcnt(uint3(0x84435320u, 0xFFFFFFFFu, 17)), int3(0, 0, 27)); + } + + [TestCompiler] + public static void lzcnt_uint4() + { + TestUtils.AreEqual(lzcnt(uint2(0u, 1u)), int2(32, 31)); + TestUtils.AreEqual(lzcnt(uint2(2u, 3u)), int2(30, 30)); + TestUtils.AreEqual(lzcnt(uint2(0x5321u, 0x04435321u)), int2(17, 5)); + TestUtils.AreEqual(lzcnt(uint2(0x84435320u, 0xFFFFFFFFu)), int2(0, 0)); + } + + [TestCompiler] + public static void lzcnt_long() + { + TestUtils.AreEqual(lzcnt(0L), 64); + TestUtils.AreEqual(lzcnt(1L), 63); + TestUtils.AreEqual(lzcnt(0x1FFF1234L), 35); + TestUtils.AreEqual(lzcnt(0x1FFFF1234L), 31); + TestUtils.AreEqual(lzcnt(0x1FFFFFFF1234L), 19); + TestUtils.AreEqual(lzcnt(-1L), 0); + TestUtils.AreEqual(lzcnt(-9223372036854775808L), 0); + } + + [TestCompiler] + public static void lzcnt_ulong() + { + TestUtils.AreEqual(lzcnt(0UL), 64); + TestUtils.AreEqual(lzcnt(1UL), 63); + TestUtils.AreEqual(lzcnt(0x1FFF1234UL), 35); + TestUtils.AreEqual(lzcnt(0x1FFFF1234UL), 31); + TestUtils.AreEqual(lzcnt(0x1FFFFFFF1234UL), 19); + TestUtils.AreEqual(lzcnt(0xFFFFFFFFFFFFFFFFUL), 0); + TestUtils.AreEqual(lzcnt(0x8000000000000000UL), 0); + } + + [TestCompiler] + public static void tzcnt_int() + { + TestUtils.AreEqual(tzcnt(0), 32); + TestUtils.AreEqual(tzcnt(1), 0); + TestUtils.AreEqual(tzcnt(2), 1); + TestUtils.AreEqual(tzcnt(3), 0); + TestUtils.AreEqual(tzcnt(0x53210), 4); + TestUtils.AreEqual(tzcnt(0x44420000), 17); + TestUtils.AreEqual(tzcnt(-2), 1); + TestUtils.AreEqual(tzcnt(-2147483647), 0); + TestUtils.AreEqual(tzcnt(-2147483648), 31); + } + + [TestCompiler] + public static void tzcnt_int2() + { + TestUtils.AreEqual(tzcnt(int2(0, 1)), int2(32, 0)); + TestUtils.AreEqual(tzcnt(int2(2, 3)), int2(1, 0)); + TestUtils.AreEqual(tzcnt(int2(0x53210, 0x44420000)), int2(4, 17)); + TestUtils.AreEqual(tzcnt(int2(-2, -2147483647)), int2(1, 0)); + TestUtils.AreEqual(tzcnt(int2(-2147483648, 20)), int2(31, 2)); + } + + [TestCompiler] + public static void tzcnt_int3() + { + TestUtils.AreEqual(tzcnt(int3(0, 1, 2)), int3(32, 0, 1)); + TestUtils.AreEqual(tzcnt(int3(3, 0x53210, 0x44420000)), int3(0, 4, 17)); + TestUtils.AreEqual(tzcnt(int3(-2, -2147483647, -2147483648)), int3(1, 0, 31)); + } + + [TestCompiler] + public static void tzcnt_int4() + { + TestUtils.AreEqual(tzcnt(int4(0, 1, 2, 3)), int4(32, 0, 1, 0)); + TestUtils.AreEqual(tzcnt(int4(0x53210, 0x44420000, -2, -2147483647)), int4(4, 17, 1, 0)); + TestUtils.AreEqual(tzcnt(int4(-2147483648, 20, 4132, -8)), int4(31, 2, 2, 3)); + } + + [TestCompiler] + public static void tzcnt_uint() + { + TestUtils.AreEqual(tzcnt(0u), 32); + TestUtils.AreEqual(tzcnt(1u), 0); + TestUtils.AreEqual(tzcnt(2u), 1); + TestUtils.AreEqual(tzcnt(3u), 0); + TestUtils.AreEqual(tzcnt(0x53210u), 4); + TestUtils.AreEqual(tzcnt(0x44420000u), 17); + TestUtils.AreEqual(tzcnt(0xFFFFFFFEu), 1); + TestUtils.AreEqual(tzcnt(0x80000001u), 0); + TestUtils.AreEqual(tzcnt(0x80000000u), 31); + } + + [TestCompiler] + public static void tzcnt_uint2() + { + TestUtils.AreEqual(tzcnt(uint2(0u, 1u)), int2(32, 0)); + TestUtils.AreEqual(tzcnt(uint2(2u, 3u)), int2(1, 0)); + TestUtils.AreEqual(tzcnt(uint2(0x53210u, 0x44420000u)), int2(4, 17)); + TestUtils.AreEqual(tzcnt(uint2(0xFFFFFFFEu, 0x80000001u)), int2(1, 0)); + TestUtils.AreEqual(tzcnt(uint2(0x80000000u, 20u)), int2(31, 2)); + } + + [TestCompiler] + public static void tzcnt_uint3() + { + TestUtils.AreEqual(tzcnt(uint3(0u, 1u, 2u)), int3(32, 0, 1)); + TestUtils.AreEqual(tzcnt(uint3(3u, 0x53210u, 0x44420000u)), int3(0, 4, 17)); + TestUtils.AreEqual(tzcnt(uint3(0xFFFFFFFEu, 0x80000001u, 0x80000000u)), int3(1, 0, 31)); + } + + [TestCompiler] + public static void tzcnt_uint4() + { + TestUtils.AreEqual(tzcnt(uint4(0u, 1u, 2u, 3u)), int4(32, 0, 1, 0)); + TestUtils.AreEqual(tzcnt(uint4(0x53210u, 0x44420000u, 0xFFFFFFFE, 0x80000001u)), int4(4, 17, 1, 0)); + TestUtils.AreEqual(tzcnt(uint4(0x80000000u, 20u, 4132u, 0xFFFFFFF8u)), int4(31, 2, 2, 3)); + } + + [TestCompiler] + public static void tzcnt_long() + { + TestUtils.AreEqual(tzcnt(0L), 64); + TestUtils.AreEqual(tzcnt(1L), 0); + TestUtils.AreEqual(tzcnt(2L), 1); + TestUtils.AreEqual(tzcnt(0x44420000L), 17); + TestUtils.AreEqual(tzcnt(0x444200000000L), 33); + TestUtils.AreEqual(tzcnt(-9223372036854775808L), 63); + TestUtils.AreEqual(tzcnt(-9223372036854775807L), 0); + } + + [TestCompiler] + public static void tzcnt_ulong() + { + TestUtils.AreEqual(tzcnt(0UL), 64); + TestUtils.AreEqual(tzcnt(1UL), 0); + TestUtils.AreEqual(tzcnt(2UL), 1); + TestUtils.AreEqual(tzcnt(0x44420000UL), 17); + TestUtils.AreEqual(tzcnt(0x444200000000UL), 33); + TestUtils.AreEqual(tzcnt(0x8000000000000000UL), 63); + TestUtils.AreEqual(tzcnt(0x8000000000000001UL), 0); + } + + [TestCompiler] + public static void reversebits_int() + { + TestUtils.AreEqual(reversebits(-1872213312), 0x03521609); + TestUtils.AreEqual(reversebits(0x1260dafa), 0x5f5b0648); + TestUtils.AreEqual(reversebits(-1312858670), 0x4bbafd8d); + TestUtils.AreEqual(reversebits(0x74239b12), 0x48d9c42e); + } + + [TestCompiler] + public static void reversebits_int2() + { + TestUtils.AreEqual(reversebits(int2(-1872213312, 0x1260dafa)), int2(0x03521609, 0x5f5b0648)); + TestUtils.AreEqual(reversebits(int2(-1312858670, 0x74239b12)), int2(0x4bbafd8d, 0x48d9c42e)); + } + + [TestCompiler] + public static void reversebits_int3() + { + TestUtils.AreEqual(reversebits(int3(-1872213312, 0x1260dafa, -1312858670)), int3(0x03521609, 0x5f5b0648, 0x4bbafd8d)); + TestUtils.AreEqual(reversebits(int3(0x74239b12, 0, -1)), int3(0x48d9c42e, 0, -1)); + } + + [TestCompiler] + public static void reversebits_int4() + { + TestUtils.AreEqual(reversebits(int4(-1872213312, 0x1260dafa, -1312858670, 0x74239b12)), int4(0x03521609, 0x5f5b0648, 0x4bbafd8d, 0x48d9c42e)); + } + + [TestCompiler] + public static void reversebits_uint() + { + TestUtils.AreEqual(reversebits(0x90684ac0u), 0x03521609u); + TestUtils.AreEqual(reversebits(0x1260dafau), 0x5f5b0648u); + TestUtils.AreEqual(reversebits(0xb1bf5dd2u), 0x4bbafd8du); + TestUtils.AreEqual(reversebits(0x74239b12u), 0x48d9c42eu); + } + + [TestCompiler] + public static void reversebits_uint2() + { + TestUtils.AreEqual(reversebits(uint2(0x90684ac0u, 0x1260dafau)), uint2(0x03521609u, 0x5f5b0648u)); + TestUtils.AreEqual(reversebits(uint2(0xb1bf5dd2u, 0x74239b12u)), uint2(0x4bbafd8du, 0x48d9c42eu)); + } + + [TestCompiler] + public static void reversebits_uint3() + { + TestUtils.AreEqual(reversebits(uint3(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u)), uint3(0x03521609u, 0x5f5b0648u, 0x4bbafd8du)); + TestUtils.AreEqual(reversebits(uint3(0x74239b12u, 0u, 0xFFFFFFFF)), uint3(0x48d9c42eu, 0u, 0xFFFFFFFF)); + } + + [TestCompiler] + public static void reversebits_uint4() + { + TestUtils.AreEqual(reversebits(uint4(0x90684ac0u, 0x1260dafau, 0xb1bf5dd2u, 0x74239b12u)), uint4(0x03521609u, 0x5f5b0648u, 0x4bbafd8du, 0x48d9c42eu)); + } + + [TestCompiler] + public static void reversebits_long() + { + TestUtils.AreEqual(reversebits(0x1260dafab1bf5dd2L), 0x4bbafd8d5f5b0648L); + } + + [TestCompiler] + public static void reversebits_ulong() + { + TestUtils.AreEqual(reversebits(0x1260dafab1bf5dd2ul), 0x4bbafd8d5f5b0648ul); + } + + [TestCompiler] + public static void rol_int() + { + TestUtils.AreEqual(rol(219257022, 11), -1933184920); + TestUtils.AreEqual(rol(-1586446996, 11), -2048170741); + TestUtils.AreEqual(rol(-279484078, 11), -1152739462); + TestUtils.AreEqual(rol(-1692078607, 11), 661621977); + } + + [TestCompiler] + public static void rol_int2() + { + TestUtils.AreEqual(rol(int2(219257022, -1586446996), 11), int2(-1933184920, -2048170741)); + TestUtils.AreEqual(rol(int2(-279484078, -1692078607), 11), int2(-1152739462, 661621977)); + } + + [TestCompiler] + public static void rol_int3() + { + TestUtils.AreEqual(rol(int3(219257022, -1586446996, -279484078), 11), int3(-1933184920, -2048170741, -1152739462)); + } + + + [TestCompiler] + public static void rol_int4() + { + TestUtils.AreEqual(rol(int4(219257022, -1586446996, -279484078, -1692078607), 11), int4(-1933184920, -2048170741, -1152739462, 661621977)); + } + + [TestCompiler] + public static void rol_uint() + { + TestUtils.AreEqual(rol(219257022u, 11), 2361782376u); + TestUtils.AreEqual(rol(2708520300u, 11), 2246796555u); + TestUtils.AreEqual(rol(4015483218u, 11), 3142227834u); + TestUtils.AreEqual(rol(2602888689u, 11), 661621977u); + } + + [TestCompiler] + public static void rol_uint2() + { + TestUtils.AreEqual(rol(uint2(219257022u, 2708520300u), 11), uint2(2361782376u, 2246796555u)); + TestUtils.AreEqual(rol(uint2(4015483218u, 2602888689u), 11), uint2(3142227834u, 661621977u)); + } + + [TestCompiler] + public static void rol_uint3() + { + TestUtils.AreEqual(rol(uint3(219257022u, 2708520300u, 4015483218u), 11), uint3(2361782376u, 2246796555u, 3142227834u)); + } + + [TestCompiler] + public static void rol_uint4() + { + TestUtils.AreEqual(rol(uint4(219257022u, 2708520300u, 4015483218u, 2602888689u), 11), uint4(2361782376u, 2246796555u, 3142227834u, 661621977u)); + } + + + [TestCompiler] + public static void rol_long() + { + TestUtils.AreEqual(rol(6894885722123239465L, 37), 4769317691753349395L); + TestUtils.AreEqual(rol(9017875690541231318L, 37), 7702732954299909421L); + TestUtils.AreEqual(rol(-6252342588442027279L, 37), 4304137451269976409L); + TestUtils.AreEqual(rol(2788577329702376155L, 37), -5493728106787075631L); + } + + [TestCompiler] + public static void rol_ulong() + { + TestUtils.AreEqual(rol(6894885722123239465UL, 37), 4769317691753349395UL); + TestUtils.AreEqual(rol(9017875690541231318UL, 37), 7702732954299909421UL); + TestUtils.AreEqual(rol(12194401485267524337UL, 37), 4304137451269976409UL); + TestUtils.AreEqual(rol(2788577329702376155UL, 37), 12953015966922475985UL); + } + + + [TestCompiler] + public static void ror_int() + { + TestUtils.AreEqual(ror(-1710129111, 11), 87245360); + TestUtils.AreEqual(ror(1232136068, 11), -259445220); + TestUtils.AreEqual(ror(1800875222, 11), -1697813787); + TestUtils.AreEqual(ror(-98246768, 11), -232831845); + } + + [TestCompiler] + public static void ror_int2() + { + TestUtils.AreEqual(ror(int2(-1710129111, 1232136068), 11), int2(87245360, -259445220)); + TestUtils.AreEqual(ror(int2(1800875222, -98246768), 11), int2(-1697813787, -232831845)); + } + + [TestCompiler] + public static void ror_int3() + { + TestUtils.AreEqual(ror(int3(-1710129111, 1232136068, 1800875222), 11), int3(87245360, -259445220, -1697813787)); + } + + [TestCompiler] + public static void ror_int4() + { + TestUtils.AreEqual(ror(int4(-1710129111, 1232136068, 1800875222, -98246768), 11), int4(87245360, -259445220, -1697813787, -232831845)); + } + + + [TestCompiler] + public static void ror_uint() + { + TestUtils.AreEqual(ror(2584838185u, 11), 87245360u); + TestUtils.AreEqual(ror(1232136068u, 11), 4035522076u); + TestUtils.AreEqual(ror(1800875222u, 11), 2597153509u); + TestUtils.AreEqual(ror(4196720528u, 11), 4062135451u); + } + + [TestCompiler] + public static void ror_uint2() + { + TestUtils.AreEqual(ror(uint2(2584838185u, 1232136068u), 11), uint2(87245360u, 4035522076u)); + TestUtils.AreEqual(ror(uint2(1800875222u, 4196720528u), 11), uint2(2597153509u, 4062135451u)); + } + + [TestCompiler] + public static void ror_uint3() + { + TestUtils.AreEqual(ror(uint3(2584838185u, 1232136068u, 1800875222u), 11), uint3(87245360u, 4035522076u, 2597153509u)); + } + + [TestCompiler] + public static void ror_uint4() + { + TestUtils.AreEqual(ror(uint4(2584838185u, 1232136068u, 1800875222u, 4196720528u), 11), uint4(87245360u, 4035522076u, 2597153509u, 4062135451u)); + } + + [TestCompiler] + public static void ror_long() + { + TestUtils.AreEqual(ror(6894885722123239465L, 37), 4958617126915898480L); + TestUtils.AreEqual(ror(9017875690541231318L, 37), 5429856151504760689L); + TestUtils.AreEqual(ror(-6252342588442027279L, 37), 6219170745001040316L); + TestUtils.AreEqual(ror(2788577329702376155L, 37), 8389344736564320290L); + } + + [TestCompiler] + public static void ror_ulong() + { + TestUtils.AreEqual(ror(6894885722123239465UL, 37), 4958617126915898480UL); + TestUtils.AreEqual(ror(9017875690541231318UL, 37), 5429856151504760689UL); + TestUtils.AreEqual(ror(12194401485267524337UL, 37), 6219170745001040316UL); + TestUtils.AreEqual(ror(2788577329702376155UL, 37), 8389344736564320290UL); + } + + + } + + + class Assert2 + { + public static void AreEqual(object a, object b) + { + + } + } + +} 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/TestBitmanipulation.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/TestBitmanipulation.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..458cb4200398befa1741d559dfad5e962d70175f --- /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/TestBitmanipulation.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: e5e8e2bd97f047f4aa27c8449c8844a2 +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/TestBool2.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/TestBool2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..89d4ff29aebf6f5426a1362779a07fa134ca959d --- /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/TestBool2.gen.cs @@ -0,0 +1,432 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool2 + { + [TestCompiler] + public static void bool2_constructor() + { + bool2 a = new bool2(false, true); + TestUtils.AreEqual(a.x, false); + TestUtils.AreEqual(a.y, true); + } + + [TestCompiler] + public static void bool2_scalar_constructor() + { + bool2 a = new bool2(true); + TestUtils.AreEqual(a.x, true); + TestUtils.AreEqual(a.y, true); + } + + [TestCompiler] + public static void bool2_static_constructor() + { + bool2 a = bool2(false, true); + TestUtils.AreEqual(a.x, false); + TestUtils.AreEqual(a.y, true); + } + + [TestCompiler] + public static void bool2_static_scalar_constructor() + { + bool2 a = bool2(true); + TestUtils.AreEqual(a.x, true); + TestUtils.AreEqual(a.y, true); + } + + [TestCompiler] + public static void bool2_operator_equal_wide_wide() + { + bool2 a0 = bool2(false, false); + bool2 b0 = bool2(false, true); + bool2 r0 = bool2(true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool2 a1 = bool2(true, true); + bool2 b1 = bool2(true, false); + bool2 r1 = bool2(true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool2 a2 = bool2(true, true); + bool2 b2 = bool2(true, true); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool2 a3 = bool2(true, true); + bool2 b3 = bool2(false, true); + bool2 r3 = bool2(false, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2_operator_equal_wide_scalar() + { + bool2 a0 = bool2(true, true); + bool b0 = (false); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool2 a1 = bool2(false, true); + bool b1 = (true); + bool2 r1 = bool2(false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool2 a2 = bool2(false, true); + bool b2 = (true); + bool2 r2 = bool2(false, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool2 a3 = bool2(true, false); + bool b3 = (false); + bool2 r3 = bool2(false, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2_operator_equal_scalar_wide() + { + bool a0 = (true); + bool2 b0 = bool2(false, false); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (true); + bool2 b1 = bool2(false, true); + bool2 r1 = bool2(false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (false); + bool2 b2 = bool2(true, false); + bool2 r2 = bool2(false, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (false); + bool2 b3 = bool2(false, false); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2_operator_not_equal_wide_wide() + { + bool2 a0 = bool2(true, false); + bool2 b0 = bool2(false, false); + bool2 r0 = bool2(true, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool2 a1 = bool2(false, true); + bool2 b1 = bool2(true, false); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool2 a2 = bool2(true, true); + bool2 b2 = bool2(false, false); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool2 a3 = bool2(true, true); + bool2 b3 = bool2(false, false); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2_operator_not_equal_wide_scalar() + { + bool2 a0 = bool2(false, false); + bool b0 = (false); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool2 a1 = bool2(true, true); + bool b1 = (true); + bool2 r1 = bool2(false, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool2 a2 = bool2(true, false); + bool b2 = (false); + bool2 r2 = bool2(true, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool2 a3 = bool2(true, true); + bool b3 = (false); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool2 b0 = bool2(true, true); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool2 b1 = bool2(true, false); + bool2 r1 = bool2(true, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (true); + bool2 b2 = bool2(false, false); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (false); + bool2 b3 = bool2(true, true); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2_operator_bitwise_and_wide_wide() + { + bool2 a0 = bool2(false, true); + bool2 b0 = bool2(false, true); + bool2 r0 = bool2(false, true); + TestUtils.AreEqual(a0 & b0, r0); + + bool2 a1 = bool2(true, false); + bool2 b1 = bool2(false, false); + bool2 r1 = bool2(false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool2 a2 = bool2(false, false); + bool2 b2 = bool2(false, true); + bool2 r2 = bool2(false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool2 a3 = bool2(true, false); + bool2 b3 = bool2(true, false); + bool2 r3 = bool2(true, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2_operator_bitwise_and_wide_scalar() + { + bool2 a0 = bool2(false, false); + bool b0 = (false); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool2 a1 = bool2(true, true); + bool b1 = (true); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool2 a2 = bool2(false, true); + bool b2 = (true); + bool2 r2 = bool2(false, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool2 a3 = bool2(true, false); + bool b3 = (false); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool2 b0 = bool2(false, false); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (true); + bool2 b1 = bool2(true, false); + bool2 r1 = bool2(true, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (false); + bool2 b2 = bool2(true, true); + bool2 r2 = bool2(false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (true); + bool2 b3 = bool2(false, true); + bool2 r3 = bool2(false, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2_operator_bitwise_or_wide_wide() + { + bool2 a0 = bool2(true, false); + bool2 b0 = bool2(true, false); + bool2 r0 = bool2(true, false); + TestUtils.AreEqual(a0 | b0, r0); + + bool2 a1 = bool2(false, true); + bool2 b1 = bool2(true, true); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool2 a2 = bool2(true, false); + bool2 b2 = bool2(true, true); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool2 a3 = bool2(false, false); + bool2 b3 = bool2(true, true); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2_operator_bitwise_or_wide_scalar() + { + bool2 a0 = bool2(false, false); + bool b0 = (true); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool2 a1 = bool2(true, false); + bool b1 = (true); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool2 a2 = bool2(true, true); + bool b2 = (false); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool2 a3 = bool2(false, true); + bool b3 = (true); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool2 b0 = bool2(true, true); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (false); + bool2 b1 = bool2(false, false); + bool2 r1 = bool2(false, false); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (false); + bool2 b2 = bool2(true, true); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (false); + bool2 b3 = bool2(true, true); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2_operator_bitwise_xor_wide_wide() + { + bool2 a0 = bool2(true, false); + bool2 b0 = bool2(false, true); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool2 a1 = bool2(true, true); + bool2 b1 = bool2(false, false); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool2 a2 = bool2(true, true); + bool2 b2 = bool2(false, true); + bool2 r2 = bool2(true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool2 a3 = bool2(false, false); + bool2 b3 = bool2(false, false); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2_operator_bitwise_xor_wide_scalar() + { + bool2 a0 = bool2(true, false); + bool b0 = (false); + bool2 r0 = bool2(true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool2 a1 = bool2(false, true); + bool b1 = (true); + bool2 r1 = bool2(true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool2 a2 = bool2(false, false); + bool b2 = (false); + bool2 r2 = bool2(false, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool2 a3 = bool2(true, true); + bool b3 = (false); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool2 b0 = bool2(true, false); + bool2 r0 = bool2(false, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (false); + bool2 b1 = bool2(true, false); + bool2 r1 = bool2(true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (true); + bool2 b2 = bool2(true, true); + bool2 r2 = bool2(false, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (true); + bool2 b3 = bool2(true, true); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2_operator_logical_not() + { + bool2 a0 = bool2(false, true); + bool2 r0 = bool2(true, false); + TestUtils.AreEqual(!a0, r0); + + bool2 a1 = bool2(false, false); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(!a1, r1); + + bool2 a2 = bool2(false, true); + bool2 r2 = bool2(true, false); + TestUtils.AreEqual(!a2, r2); + + bool2 a3 = bool2(true, true); + bool2 r3 = bool2(false, false); + 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/TestBool2.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/TestBool2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..19502cb8f557350de41f321a8f01b4e728e92a4b --- /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/TestBool2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fc335ab357eef1346a23bc792570d94e +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/TestBool2x2.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/TestBool2x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..663c2ec81598fafe359e8b172020425e293cae26 --- /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/TestBool2x2.gen.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool2x2 + { + [TestCompiler] + public static void bool2x2_operator_equal_wide_wide() + { + bool2x2 a0 = bool2x2(false, false, true, true); + bool2x2 b0 = bool2x2(false, true, true, false); + bool2x2 r0 = bool2x2(true, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool2x2 a1 = bool2x2(true, true, true, true); + bool2x2 b1 = bool2x2(true, true, false, true); + bool2x2 r1 = bool2x2(true, true, false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool2x2 a2 = bool2x2(true, true, true, true); + bool2x2 b2 = bool2x2(true, true, false, false); + bool2x2 r2 = bool2x2(true, true, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool2x2 a3 = bool2x2(true, false, false, false); + bool2x2 b3 = bool2x2(false, false, true, true); + bool2x2 r3 = bool2x2(false, true, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_equal_wide_scalar() + { + bool2x2 a0 = bool2x2(true, true, false, true); + bool b0 = (false); + bool2x2 r0 = bool2x2(false, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool2x2 a1 = bool2x2(true, true, true, true); + bool b1 = (false); + bool2x2 r1 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool2x2 a2 = bool2x2(false, false, false, true); + bool b2 = (false); + bool2x2 r2 = bool2x2(true, true, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool2x2 a3 = bool2x2(false, false, false, true); + bool b3 = (false); + bool2x2 r3 = bool2x2(true, true, true, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_equal_scalar_wide() + { + bool a0 = (true); + bool2x2 b0 = bool2x2(false, false, true, false); + bool2x2 r0 = bool2x2(false, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (true); + bool2x2 b1 = bool2x2(false, true, false, false); + bool2x2 r1 = bool2x2(false, true, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (false); + bool2x2 b2 = bool2x2(false, true, false, true); + bool2x2 r2 = bool2x2(true, false, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (true); + bool2x2 b3 = bool2x2(true, false, true, true); + bool2x2 r3 = bool2x2(true, false, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_not_equal_wide_wide() + { + bool2x2 a0 = bool2x2(true, false, false, true); + bool2x2 b0 = bool2x2(false, false, true, false); + bool2x2 r0 = bool2x2(true, false, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool2x2 a1 = bool2x2(true, true, true, true); + bool2x2 b1 = bool2x2(false, false, false, false); + bool2x2 r1 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool2x2 a2 = bool2x2(true, true, false, true); + bool2x2 b2 = bool2x2(true, true, false, false); + bool2x2 r2 = bool2x2(false, false, false, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool2x2 a3 = bool2x2(true, false, true, false); + bool2x2 b3 = bool2x2(false, false, false, true); + bool2x2 r3 = bool2x2(true, false, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_not_equal_wide_scalar() + { + bool2x2 a0 = bool2x2(false, false, true, true); + bool b0 = (false); + bool2x2 r0 = bool2x2(false, false, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool2x2 a1 = bool2x2(true, false, false, true); + bool b1 = (true); + bool2x2 r1 = bool2x2(false, true, true, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool2x2 a2 = bool2x2(false, false, true, false); + bool b2 = (true); + bool2x2 r2 = bool2x2(true, true, false, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool2x2 a3 = bool2x2(true, true, true, false); + bool b3 = (true); + bool2x2 r3 = bool2x2(false, false, false, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool2x2 b0 = bool2x2(true, true, false, true); + bool2x2 r0 = bool2x2(false, false, true, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool2x2 b1 = bool2x2(true, false, false, false); + bool2x2 r1 = bool2x2(true, false, false, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (true); + bool2x2 b2 = bool2x2(true, true, false, true); + bool2x2 r2 = bool2x2(false, false, true, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (true); + bool2x2 b3 = bool2x2(false, false, false, true); + bool2x2 r3 = bool2x2(true, true, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_bitwise_and_wide_wide() + { + bool2x2 a0 = bool2x2(false, true, true, false); + bool2x2 b0 = bool2x2(false, true, false, false); + bool2x2 r0 = bool2x2(false, true, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool2x2 a1 = bool2x2(false, false, true, false); + bool2x2 b1 = bool2x2(false, true, true, false); + bool2x2 r1 = bool2x2(false, false, true, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool2x2 a2 = bool2x2(true, true, false, true); + bool2x2 b2 = bool2x2(false, true, false, true); + bool2x2 r2 = bool2x2(false, true, false, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool2x2 a3 = bool2x2(false, false, true, false); + bool2x2 b3 = bool2x2(true, false, true, true); + bool2x2 r3 = bool2x2(false, false, true, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_bitwise_and_wide_scalar() + { + bool2x2 a0 = bool2x2(false, false, true, true); + bool b0 = (false); + bool2x2 r0 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool2x2 a1 = bool2x2(true, true, true, true); + bool b1 = (false); + bool2x2 r1 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool2x2 a2 = bool2x2(false, false, true, false); + bool b2 = (false); + bool2x2 r2 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool2x2 a3 = bool2x2(true, false, true, false); + bool b3 = (false); + bool2x2 r3 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool2x2 b0 = bool2x2(false, false, true, true); + bool2x2 r0 = bool2x2(false, false, true, true); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (false); + bool2x2 b1 = bool2x2(false, true, true, true); + bool2x2 r1 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (false); + bool2x2 b2 = bool2x2(true, false, true, true); + bool2x2 r2 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (false); + bool2x2 b3 = bool2x2(false, true, true, false); + bool2x2 r3 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_bitwise_or_wide_wide() + { + bool2x2 a0 = bool2x2(true, false, false, true); + bool2x2 b0 = bool2x2(true, false, true, true); + bool2x2 r0 = bool2x2(true, false, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool2x2 a1 = bool2x2(true, false, false, false); + bool2x2 b1 = bool2x2(true, true, true, true); + bool2x2 r1 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool2x2 a2 = bool2x2(false, false, true, true); + bool2x2 b2 = bool2x2(true, true, false, false); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool2x2 a3 = bool2x2(false, false, true, true); + bool2x2 b3 = bool2x2(true, true, true, true); + bool2x2 r3 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_bitwise_or_wide_scalar() + { + bool2x2 a0 = bool2x2(false, false, true, true); + bool b0 = (true); + bool2x2 r0 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool2x2 a1 = bool2x2(false, false, true, false); + bool b1 = (true); + bool2x2 r1 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool2x2 a2 = bool2x2(true, false, false, true); + bool b2 = (true); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool2x2 a3 = bool2x2(false, false, true, false); + bool b3 = (true); + bool2x2 r3 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool2x2 b0 = bool2x2(true, true, false, false); + bool2x2 r0 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (false); + bool2x2 b1 = bool2x2(false, true, true, false); + bool2x2 r1 = bool2x2(false, true, true, false); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (true); + bool2x2 b2 = bool2x2(true, false, false, false); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (false); + bool2x2 b3 = bool2x2(false, false, false, false); + bool2x2 r3 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_bitwise_xor_wide_wide() + { + bool2x2 a0 = bool2x2(true, false, true, true); + bool2x2 b0 = bool2x2(false, true, false, false); + bool2x2 r0 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool2x2 a1 = bool2x2(true, true, false, false); + bool2x2 b1 = bool2x2(false, true, false, false); + bool2x2 r1 = bool2x2(true, false, false, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool2x2 a2 = bool2x2(false, false, true, false); + bool2x2 b2 = bool2x2(true, true, true, false); + bool2x2 r2 = bool2x2(true, true, false, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool2x2 a3 = bool2x2(false, false, true, false); + bool2x2 b3 = bool2x2(false, false, true, true); + bool2x2 r3 = bool2x2(false, false, false, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_bitwise_xor_wide_scalar() + { + bool2x2 a0 = bool2x2(true, false, false, true); + bool b0 = (false); + bool2x2 r0 = bool2x2(true, false, false, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool2x2 a1 = bool2x2(true, false, false, true); + bool b1 = (false); + bool2x2 r1 = bool2x2(true, false, false, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool2x2 a2 = bool2x2(false, true, false, true); + bool b2 = (true); + bool2x2 r2 = bool2x2(true, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool2x2 a3 = bool2x2(true, false, false, false); + bool b3 = (false); + bool2x2 r3 = bool2x2(true, false, false, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool2x2 b0 = bool2x2(true, false, false, true); + bool2x2 r0 = bool2x2(false, true, true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (false); + bool2x2 b1 = bool2x2(true, true, true, true); + bool2x2 r1 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (true); + bool2x2 b2 = bool2x2(true, true, true, true); + bool2x2 r2 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (true); + bool2x2 b3 = bool2x2(true, false, true, false); + bool2x2 r3 = bool2x2(false, true, false, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2x2_operator_logical_not() + { + bool2x2 a0 = bool2x2(false, true, false, true); + bool2x2 r0 = bool2x2(true, false, true, false); + TestUtils.AreEqual(!a0, r0); + + bool2x2 a1 = bool2x2(false, false, true, true); + bool2x2 r1 = bool2x2(true, true, false, false); + TestUtils.AreEqual(!a1, r1); + + bool2x2 a2 = bool2x2(false, true, true, false); + bool2x2 r2 = bool2x2(true, false, false, true); + TestUtils.AreEqual(!a2, r2); + + bool2x2 a3 = bool2x2(false, true, false, false); + bool2x2 r3 = bool2x2(true, false, true, true); + 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/TestBool2x2.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/TestBool2x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..4006bb9323488e461ca76d12490227d069d52316 --- /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/TestBool2x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 8ffa916172073c14499f3e88e1ddaccc +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/TestBool2x3.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/TestBool2x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..93dc17941d2b3c99a9cf98a6a40916403cd4deca --- /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/TestBool2x3.gen.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool2x3 + { + [TestCompiler] + public static void bool2x3_operator_equal_wide_wide() + { + bool2x3 a0 = bool2x3(false, false, true, true, true, true); + bool2x3 b0 = bool2x3(false, true, true, false, true, true); + bool2x3 r0 = bool2x3(true, false, true, false, true, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool2x3 a1 = bool2x3(true, true, true, true, true, true); + bool2x3 b1 = bool2x3(false, true, true, true, false, false); + bool2x3 r1 = bool2x3(false, true, true, true, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool2x3 a2 = bool2x3(true, false, false, false, true, true); + bool2x3 b2 = bool2x3(false, false, true, true, true, true); + bool2x3 r2 = bool2x3(false, true, false, false, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool2x3 a3 = bool2x3(true, true, true, false, false, false); + bool2x3 b3 = bool2x3(true, false, false, true, false, true); + bool2x3 r3 = bool2x3(true, false, false, false, true, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_equal_wide_scalar() + { + bool2x3 a0 = bool2x3(true, true, false, true, true, false); + bool b0 = (false); + bool2x3 r0 = bool2x3(false, false, true, false, false, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool2x3 a1 = bool2x3(true, true, false, false, false, false); + bool b1 = (true); + bool2x3 r1 = bool2x3(true, true, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool2x3 a2 = bool2x3(true, false, false, false, true, true); + bool b2 = (false); + bool2x3 r2 = bool2x3(false, true, true, true, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool2x3 a3 = bool2x3(false, true, false, true, false, true); + bool b3 = (false); + bool2x3 r3 = bool2x3(true, false, true, false, true, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_equal_scalar_wide() + { + bool a0 = (true); + bool2x3 b0 = bool2x3(false, false, true, false, true, false); + bool2x3 r0 = bool2x3(false, false, true, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (true); + bool2x3 b1 = bool2x3(false, false, false, false, true, false); + bool2x3 r1 = bool2x3(false, false, false, false, true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (true); + bool2x3 b2 = bool2x3(true, true, false, true, true, false); + bool2x3 r2 = bool2x3(true, true, false, true, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (false); + bool2x3 b3 = bool2x3(true, false, false, true, false, false); + bool2x3 r3 = bool2x3(false, true, true, false, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_not_equal_wide_wide() + { + bool2x3 a0 = bool2x3(true, false, false, true, true, true); + bool2x3 b0 = bool2x3(false, false, true, false, false, false); + bool2x3 r0 = bool2x3(true, false, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool2x3 a1 = bool2x3(true, true, true, true, false, true); + bool2x3 b1 = bool2x3(false, false, true, true, false, false); + bool2x3 r1 = bool2x3(true, true, false, false, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool2x3 a2 = bool2x3(true, false, true, false, false, true); + bool2x3 b2 = bool2x3(false, false, false, true, true, false); + bool2x3 r2 = bool2x3(true, false, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool2x3 a3 = bool2x3(true, true, false, true, false, false); + bool2x3 b3 = bool2x3(false, false, false, false, true, true); + bool2x3 r3 = bool2x3(true, true, false, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_not_equal_wide_scalar() + { + bool2x3 a0 = bool2x3(false, false, true, true, true, true); + bool b0 = (false); + bool2x3 r0 = bool2x3(false, false, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool2x3 a1 = bool2x3(false, true, false, true, false, true); + bool b1 = (false); + bool2x3 r1 = bool2x3(false, true, false, true, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool2x3 a2 = bool2x3(false, true, true, true, false, false); + bool b2 = (true); + bool2x3 r2 = bool2x3(true, false, false, false, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool2x3 a3 = bool2x3(true, true, true, false, false, false); + bool b3 = (true); + bool2x3 r3 = bool2x3(false, false, false, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool2x3 b0 = bool2x3(true, true, false, true, false, true); + bool2x3 r0 = bool2x3(false, false, true, false, true, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool2x3 b1 = bool2x3(false, false, true, true, true, false); + bool2x3 r1 = bool2x3(false, false, true, true, true, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (true); + bool2x3 b2 = bool2x3(true, false, false, false, true, true); + bool2x3 r2 = bool2x3(false, true, true, true, false, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (false); + bool2x3 b3 = bool2x3(false, true, false, true, false, false); + bool2x3 r3 = bool2x3(false, true, false, true, false, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_bitwise_and_wide_wide() + { + bool2x3 a0 = bool2x3(false, true, true, false, false, false); + bool2x3 b0 = bool2x3(false, true, false, false, false, true); + bool2x3 r0 = bool2x3(false, true, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool2x3 a1 = bool2x3(true, false, true, true, false, true); + bool2x3 b1 = bool2x3(true, false, false, true, false, true); + bool2x3 r1 = bool2x3(true, false, false, true, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool2x3 a2 = bool2x3(false, false, true, false, false, false); + bool2x3 b2 = bool2x3(true, false, true, true, false, false); + bool2x3 r2 = bool2x3(false, false, true, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool2x3 a3 = bool2x3(false, true, false, true, true, false); + bool2x3 b3 = bool2x3(false, true, false, false, false, true); + bool2x3 r3 = bool2x3(false, true, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_bitwise_and_wide_scalar() + { + bool2x3 a0 = bool2x3(false, false, true, true, true, false); + bool b0 = (false); + bool2x3 r0 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool2x3 a1 = bool2x3(true, true, false, false, false, true); + bool b1 = (true); + bool2x3 r1 = bool2x3(true, true, false, false, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool2x3 a2 = bool2x3(false, false, false, true, false, true); + bool b2 = (true); + bool2x3 r2 = bool2x3(false, false, false, true, false, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool2x3 a3 = bool2x3(true, true, false, true, false, true); + bool b3 = (false); + bool2x3 r3 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool2x3 b0 = bool2x3(false, false, true, true, false, false); + bool2x3 r0 = bool2x3(false, false, true, true, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (true); + bool2x3 b1 = bool2x3(true, true, false, true, false, true); + bool2x3 r1 = bool2x3(true, true, false, true, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (true); + bool2x3 b2 = bool2x3(false, false, true, true, false, true); + bool2x3 r2 = bool2x3(false, false, true, true, false, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (true); + bool2x3 b3 = bool2x3(false, true, true, true, true, true); + bool2x3 r3 = bool2x3(false, true, true, true, true, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_bitwise_or_wide_wide() + { + bool2x3 a0 = bool2x3(true, false, false, true, true, false); + bool2x3 b0 = bool2x3(true, false, true, true, true, true); + bool2x3 r0 = bool2x3(true, false, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool2x3 a1 = bool2x3(false, false, false, false, true, true); + bool2x3 b1 = bool2x3(true, true, true, true, false, false); + bool2x3 r1 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool2x3 a2 = bool2x3(false, false, true, true, true, false); + bool2x3 b2 = bool2x3(true, true, true, true, true, true); + bool2x3 r2 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool2x3 a3 = bool2x3(true, true, false, true, false, false); + bool2x3 b3 = bool2x3(false, false, false, false, true, false); + bool2x3 r3 = bool2x3(true, true, false, true, true, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_bitwise_or_wide_scalar() + { + bool2x3 a0 = bool2x3(false, false, true, true, false, true); + bool b0 = (true); + bool2x3 r0 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool2x3 a1 = bool2x3(false, false, true, true, false, false); + bool b1 = (true); + bool2x3 r1 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool2x3 a2 = bool2x3(true, true, false, true, false, false); + bool b2 = (false); + bool2x3 r2 = bool2x3(true, true, false, true, false, false); + TestUtils.AreEqual(a2 | b2, r2); + + bool2x3 a3 = bool2x3(false, true, false, true, true, true); + bool b3 = (true); + bool2x3 r3 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool2x3 b0 = bool2x3(true, true, false, false, false, false); + bool2x3 r0 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (true); + bool2x3 b1 = bool2x3(true, false, true, true, false, false); + bool2x3 r1 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (false); + bool2x3 b2 = bool2x3(false, false, false, false, false, true); + bool2x3 r2 = bool2x3(false, false, false, false, false, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (false); + bool2x3 b3 = bool2x3(true, true, true, true, true, false); + bool2x3 r3 = bool2x3(true, true, true, true, true, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_bitwise_xor_wide_wide() + { + bool2x3 a0 = bool2x3(true, false, true, true, true, true); + bool2x3 b0 = bool2x3(false, true, false, false, false, true); + bool2x3 r0 = bool2x3(true, true, true, true, true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool2x3 a1 = bool2x3(false, false, false, false, true, false); + bool2x3 b1 = bool2x3(false, false, true, true, true, false); + bool2x3 r1 = bool2x3(false, false, true, true, false, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool2x3 a2 = bool2x3(false, false, true, false, true, false); + bool2x3 b2 = bool2x3(false, false, true, true, false, false); + bool2x3 r2 = bool2x3(false, false, false, true, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool2x3 a3 = bool2x3(false, false, true, true, true, true); + bool2x3 b3 = bool2x3(true, true, true, true, false, true); + bool2x3 r3 = bool2x3(true, true, false, false, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_bitwise_xor_wide_scalar() + { + bool2x3 a0 = bool2x3(true, false, false, true, true, false); + bool b0 = (false); + bool2x3 r0 = bool2x3(true, false, false, true, true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool2x3 a1 = bool2x3(false, true, false, true, true, false); + bool b1 = (false); + bool2x3 r1 = bool2x3(false, true, false, true, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool2x3 a2 = bool2x3(true, false, false, false, false, false); + bool b2 = (true); + bool2x3 r2 = bool2x3(false, true, true, true, true, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool2x3 a3 = bool2x3(false, false, false, true, true, false); + bool b3 = (false); + bool2x3 r3 = bool2x3(false, false, false, true, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool2x3 b0 = bool2x3(true, false, false, true, false, true); + bool2x3 r0 = bool2x3(false, true, true, false, true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (true); + bool2x3 b1 = bool2x3(true, true, true, true, true, true); + bool2x3 r1 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (true); + bool2x3 b2 = bool2x3(true, true, false, true, false, true); + bool2x3 r2 = bool2x3(false, false, true, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (false); + bool2x3 b3 = bool2x3(false, false, false, true, false, true); + bool2x3 r3 = bool2x3(false, false, false, true, false, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2x3_operator_logical_not() + { + bool2x3 a0 = bool2x3(false, true, false, true, false, false); + bool2x3 r0 = bool2x3(true, false, true, false, true, true); + TestUtils.AreEqual(!a0, r0); + + bool2x3 a1 = bool2x3(false, true, false, true, true, true); + bool2x3 r1 = bool2x3(true, false, true, false, false, false); + TestUtils.AreEqual(!a1, r1); + + bool2x3 a2 = bool2x3(false, false, true, false, false, true); + bool2x3 r2 = bool2x3(true, true, false, true, true, false); + TestUtils.AreEqual(!a2, r2); + + bool2x3 a3 = bool2x3(false, false, false, true, true, true); + bool2x3 r3 = bool2x3(true, true, true, false, false, false); + 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/TestBool2x3.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/TestBool2x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f7b3ffb52fd8cb72bba4cba7b3350682a1e64b60 --- /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/TestBool2x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: a058a163908539c4d9aa34e925e16c84 +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/TestBool2x4.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/TestBool2x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..7112e448c72070b1a66b89c05eedf1c993ca0953 --- /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/TestBool2x4.gen.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool2x4 + { + [TestCompiler] + public static void bool2x4_operator_equal_wide_wide() + { + bool2x4 a0 = bool2x4(false, false, true, true, true, true, true, true); + bool2x4 b0 = bool2x4(false, true, true, false, true, true, false, true); + bool2x4 r0 = bool2x4(true, false, true, false, true, true, false, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool2x4 a1 = bool2x4(true, true, true, true, true, false, false, false); + bool2x4 b1 = bool2x4(true, true, false, false, false, false, true, true); + bool2x4 r1 = bool2x4(true, true, false, false, false, true, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool2x4 a2 = bool2x4(true, true, true, true, true, false, false, false); + bool2x4 b2 = bool2x4(true, true, true, false, false, true, false, true); + bool2x4 r2 = bool2x4(true, true, true, false, false, false, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool2x4 a3 = bool2x4(false, true, false, true, true, true, true, true); + bool2x4 b3 = bool2x4(false, true, true, false, false, true, false, false); + bool2x4 r3 = bool2x4(true, true, false, false, false, true, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_equal_wide_scalar() + { + bool2x4 a0 = bool2x4(true, true, false, true, true, false, true, true); + bool b0 = (false); + bool2x4 r0 = bool2x4(false, false, true, false, false, true, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool2x4 a1 = bool2x4(true, false, false, false, true, false, false, false); + bool b1 = (false); + bool2x4 r1 = bool2x4(false, true, true, true, false, true, true, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool2x4 a2 = bool2x4(false, true, false, false, true, false, true, false); + bool b2 = (true); + bool2x4 r2 = bool2x4(false, true, false, false, true, false, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool2x4 a3 = bool2x4(true, true, false, false, true, false, true, true); + bool b3 = (false); + bool2x4 r3 = bool2x4(false, false, true, true, false, true, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_equal_scalar_wide() + { + bool a0 = (true); + bool2x4 b0 = bool2x4(false, false, true, false, true, false, true, false); + bool2x4 r0 = bool2x4(false, false, true, false, true, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (false); + bool2x4 b1 = bool2x4(false, false, true, false, true, true, true, false); + bool2x4 r1 = bool2x4(true, true, false, true, false, false, false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (true); + bool2x4 b2 = bool2x4(true, false, false, true, false, false, true, false); + bool2x4 r2 = bool2x4(true, false, false, true, false, false, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (false); + bool2x4 b3 = bool2x4(true, false, false, true, false, true, true, true); + bool2x4 r3 = bool2x4(false, true, true, false, true, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_not_equal_wide_wide() + { + bool2x4 a0 = bool2x4(true, false, false, true, true, true, true, true); + bool2x4 b0 = bool2x4(false, false, true, false, false, false, false, false); + bool2x4 r0 = bool2x4(true, false, true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool2x4 a1 = bool2x4(true, true, false, true, true, false, true, false); + bool2x4 b1 = bool2x4(true, true, false, false, false, false, false, true); + bool2x4 r1 = bool2x4(false, false, false, true, true, false, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool2x4 a2 = bool2x4(false, true, true, true, false, true, false, false); + bool2x4 b2 = bool2x4(true, false, false, false, false, false, true, true); + bool2x4 r2 = bool2x4(true, true, true, true, false, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool2x4 a3 = bool2x4(false, true, true, true, false, false, true, false); + bool2x4 b3 = bool2x4(true, false, false, false, true, true, false, false); + bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_not_equal_wide_scalar() + { + bool2x4 a0 = bool2x4(false, false, true, true, true, true, false, false); + bool b0 = (false); + bool2x4 r0 = bool2x4(false, false, true, true, true, true, false, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool2x4 a1 = bool2x4(true, true, false, true, false, true, true, true); + bool b1 = (false); + bool2x4 r1 = bool2x4(true, true, false, true, false, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool2x4 a2 = bool2x4(true, false, true, true, true, true, false, false); + bool b2 = (false); + bool2x4 r2 = bool2x4(true, false, true, true, true, true, false, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool2x4 a3 = bool2x4(false, false, true, true, true, false, true, false); + bool b3 = (false); + bool2x4 r3 = bool2x4(false, false, true, true, true, false, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool2x4 b0 = bool2x4(true, true, false, true, false, true, false, false); + bool2x4 r0 = bool2x4(false, false, true, false, true, false, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool2x4 b1 = bool2x4(true, true, true, false, true, true, false, false); + bool2x4 r1 = bool2x4(true, true, true, false, true, true, false, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (false); + bool2x4 b2 = bool2x4(true, true, false, false, true, false, true, false); + bool2x4 r2 = bool2x4(true, true, false, false, true, false, true, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (false); + bool2x4 b3 = bool2x4(true, true, true, false, false, true, false, false); + bool2x4 r3 = bool2x4(true, true, true, false, false, true, false, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_bitwise_and_wide_wide() + { + bool2x4 a0 = bool2x4(false, true, true, false, false, false, true, false); + bool2x4 b0 = bool2x4(false, true, false, false, false, true, true, false); + bool2x4 r0 = bool2x4(false, true, false, false, false, false, true, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool2x4 a1 = bool2x4(true, true, false, true, false, false, true, false); + bool2x4 b1 = bool2x4(false, true, false, true, true, false, true, true); + bool2x4 r1 = bool2x4(false, true, false, true, false, false, true, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool2x4 a2 = bool2x4(false, false, false, true, false, true, true, false); + bool2x4 b2 = bool2x4(false, false, false, true, false, false, false, true); + bool2x4 r2 = bool2x4(false, false, false, true, false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool2x4 a3 = bool2x4(false, false, true, false, false, true, false, false); + bool2x4 b3 = bool2x4(true, false, false, false, true, false, false, true); + bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_bitwise_and_wide_scalar() + { + bool2x4 a0 = bool2x4(false, false, true, true, true, false, true, true); + bool b0 = (false); + bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool2x4 a1 = bool2x4(true, false, false, true, false, true, false, false); + bool b1 = (false); + bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool2x4 a2 = bool2x4(true, true, true, false, true, false, true, false); + bool b2 = (false); + bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool2x4 a3 = bool2x4(true, true, false, false, true, false, false, true); + bool b3 = (true); + bool2x4 r3 = bool2x4(true, true, false, false, true, false, false, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool2x4 b0 = bool2x4(false, false, true, true, false, false, true, true); + bool2x4 r0 = bool2x4(false, false, true, true, false, false, true, true); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (true); + bool2x4 b1 = bool2x4(false, true, false, true, true, false, false, true); + bool2x4 r1 = bool2x4(false, true, false, true, true, false, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (true); + bool2x4 b2 = bool2x4(false, true, true, false, true, true, true, true); + bool2x4 r2 = bool2x4(false, true, true, false, true, true, true, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (true); + bool2x4 b3 = bool2x4(false, true, true, true, false, true, false, true); + bool2x4 r3 = bool2x4(false, true, true, true, false, true, false, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_bitwise_or_wide_wide() + { + bool2x4 a0 = bool2x4(true, false, false, true, true, false, false, false); + bool2x4 b0 = bool2x4(true, false, true, true, true, true, true, true); + bool2x4 r0 = bool2x4(true, false, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool2x4 a1 = bool2x4(false, false, true, true, false, false, true, true); + bool2x4 b1 = bool2x4(true, true, false, false, true, true, true, true); + bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool2x4 a2 = bool2x4(true, false, true, true, false, true, false, false); + bool2x4 b2 = bool2x4(true, true, false, false, false, false, true, false); + bool2x4 r2 = bool2x4(true, true, true, true, false, true, true, false); + TestUtils.AreEqual(a2 | b2, r2); + + bool2x4 a3 = bool2x4(false, false, true, false, true, false, false, true); + bool2x4 b3 = bool2x4(false, true, false, true, false, false, true, true); + bool2x4 r3 = bool2x4(false, true, true, true, true, false, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_bitwise_or_wide_scalar() + { + bool2x4 a0 = bool2x4(false, false, true, true, false, true, false, true); + bool b0 = (true); + bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool2x4 a1 = bool2x4(false, true, false, false, true, false, true, false); + bool b1 = (true); + bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool2x4 a2 = bool2x4(true, false, false, true, true, false, true, true); + bool b2 = (false); + bool2x4 r2 = bool2x4(true, false, false, true, true, false, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool2x4 a3 = bool2x4(true, true, true, true, true, false, false, false); + bool b3 = (true); + bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool2x4 b0 = bool2x4(true, true, false, false, false, false, true, true); + bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (false); + bool2x4 b1 = bool2x4(true, true, false, false, false, false, false, false); + bool2x4 r1 = bool2x4(true, true, false, false, false, false, false, false); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (false); + bool2x4 b2 = bool2x4(false, true, false, true, true, true, true, true); + bool2x4 r2 = bool2x4(false, true, false, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (false); + bool2x4 b3 = bool2x4(true, false, false, true, true, false, false, false); + bool2x4 r3 = bool2x4(true, false, false, true, true, false, false, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_bitwise_xor_wide_wide() + { + bool2x4 a0 = bool2x4(true, false, true, true, true, true, false, false); + bool2x4 b0 = bool2x4(false, true, false, false, false, true, false, false); + bool2x4 r0 = bool2x4(true, true, true, true, true, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool2x4 a1 = bool2x4(false, false, true, false, false, false, true, false); + bool2x4 b1 = bool2x4(true, true, true, false, false, false, true, true); + bool2x4 r1 = bool2x4(true, true, false, false, false, false, false, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool2x4 a2 = bool2x4(true, false, false, false, true, true, true, true); + bool2x4 b2 = bool2x4(false, false, true, true, true, true, false, true); + bool2x4 r2 = bool2x4(true, false, true, true, false, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool2x4 a3 = bool2x4(true, false, true, true, false, false, true, false); + bool2x4 b3 = bool2x4(true, false, false, false, true, false, false, false); + bool2x4 r3 = bool2x4(false, false, true, true, true, false, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_bitwise_xor_wide_scalar() + { + bool2x4 a0 = bool2x4(true, false, false, true, true, false, false, false); + bool b0 = (false); + bool2x4 r0 = bool2x4(true, false, false, true, true, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool2x4 a1 = bool2x4(true, true, true, false, true, true, false, false); + bool b1 = (false); + bool2x4 r1 = bool2x4(true, true, true, false, true, true, false, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool2x4 a2 = bool2x4(false, false, false, false, false, false, true, true); + bool b2 = (false); + bool2x4 r2 = bool2x4(false, false, false, false, false, false, true, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool2x4 a3 = bool2x4(false, false, false, false, true, true, false, false); + bool b3 = (false); + bool2x4 r3 = bool2x4(false, false, false, false, true, true, false, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool2x4 b0 = bool2x4(true, false, false, true, false, true, true, true); + bool2x4 r0 = bool2x4(false, true, true, false, true, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (true); + bool2x4 b1 = bool2x4(true, true, true, true, true, true, true, false); + bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (true); + bool2x4 b2 = bool2x4(false, true, false, false, false, false, true, false); + bool2x4 r2 = bool2x4(true, false, true, true, true, true, false, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (true); + bool2x4 b3 = bool2x4(false, true, true, false, true, false, false, false); + bool2x4 r3 = bool2x4(true, false, false, true, false, true, true, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool2x4_operator_logical_not() + { + bool2x4 a0 = bool2x4(false, true, false, true, false, false, false, true); + bool2x4 r0 = bool2x4(true, false, true, false, true, true, true, false); + TestUtils.AreEqual(!a0, r0); + + bool2x4 a1 = bool2x4(true, true, true, true, false, false, false, true); + bool2x4 r1 = bool2x4(false, false, false, false, true, true, true, false); + TestUtils.AreEqual(!a1, r1); + + bool2x4 a2 = bool2x4(false, true, false, true, false, false, true, true); + bool2x4 r2 = bool2x4(true, false, true, false, true, true, false, false); + TestUtils.AreEqual(!a2, r2); + + bool2x4 a3 = bool2x4(true, true, true, false, true, false, false, true); + bool2x4 r3 = bool2x4(false, false, false, true, false, true, true, false); + 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/TestBool2x4.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/TestBool2x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..96b1e80ac9008f26fff451a7dc799c1d20e85b05 --- /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/TestBool2x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fa56fbe206d514b43a4f21c1ecd2a9bd +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/TestBool3.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/TestBool3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..a3fcfc51c50a815a82e464ca543022ba1ef2f28b --- /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/TestBool3.gen.cs @@ -0,0 +1,436 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool3 + { + [TestCompiler] + public static void bool3_constructor() + { + bool3 a = new bool3(false, true, false); + TestUtils.AreEqual(a.x, false); + TestUtils.AreEqual(a.y, true); + TestUtils.AreEqual(a.z, false); + } + + [TestCompiler] + public static void bool3_scalar_constructor() + { + bool3 a = new bool3(true); + TestUtils.AreEqual(a.x, true); + TestUtils.AreEqual(a.y, true); + TestUtils.AreEqual(a.z, true); + } + + [TestCompiler] + public static void bool3_static_constructor() + { + bool3 a = bool3(false, true, false); + TestUtils.AreEqual(a.x, false); + TestUtils.AreEqual(a.y, true); + TestUtils.AreEqual(a.z, false); + } + + [TestCompiler] + public static void bool3_static_scalar_constructor() + { + bool3 a = bool3(true); + TestUtils.AreEqual(a.x, true); + TestUtils.AreEqual(a.y, true); + TestUtils.AreEqual(a.z, true); + } + + [TestCompiler] + public static void bool3_operator_equal_wide_wide() + { + bool3 a0 = bool3(false, false, true); + bool3 b0 = bool3(false, true, true); + bool3 r0 = bool3(true, false, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool3 a1 = bool3(true, true, true); + bool3 b1 = bool3(false, true, true); + bool3 r1 = bool3(false, true, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool3 a2 = bool3(true, true, true); + bool3 b2 = bool3(false, true, true); + bool3 r2 = bool3(false, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool3 a3 = bool3(true, true, true); + bool3 b3 = bool3(true, false, false); + bool3 r3 = bool3(true, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3_operator_equal_wide_scalar() + { + bool3 a0 = bool3(true, true, false); + bool b0 = (false); + bool3 r0 = bool3(false, false, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool3 a1 = bool3(true, false, true); + bool b1 = (true); + bool3 r1 = bool3(true, false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool3 a2 = bool3(true, false, false); + bool b2 = (true); + bool3 r2 = bool3(true, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool3 a3 = bool3(false, true, false); + bool b3 = (false); + bool3 r3 = bool3(true, false, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3_operator_equal_scalar_wide() + { + bool a0 = (true); + bool3 b0 = bool3(false, false, true); + bool3 r0 = bool3(false, false, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (false); + bool3 b1 = bool3(true, false, true); + bool3 r1 = bool3(false, true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (false); + bool3 b2 = bool3(false, false, false); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (true); + bool3 b3 = bool3(false, true, true); + bool3 r3 = bool3(false, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3_operator_not_equal_wide_wide() + { + bool3 a0 = bool3(true, false, false); + bool3 b0 = bool3(false, false, true); + bool3 r0 = bool3(true, false, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool3 a1 = bool3(true, true, true); + bool3 b1 = bool3(false, false, false); + bool3 r1 = bool3(true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool3 a2 = bool3(true, true, true); + bool3 b2 = bool3(false, false, true); + bool3 r2 = bool3(true, true, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool3 a3 = bool3(true, false, true); + bool3 b3 = bool3(true, false, false); + bool3 r3 = bool3(false, false, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3_operator_not_equal_wide_scalar() + { + bool3 a0 = bool3(false, false, true); + bool b0 = (false); + bool3 r0 = bool3(false, false, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool3 a1 = bool3(true, true, false); + bool b1 = (true); + bool3 r1 = bool3(false, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool3 a2 = bool3(false, false, true); + bool b2 = (true); + bool3 r2 = bool3(true, true, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool3 a3 = bool3(false, false, true); + bool b3 = (true); + bool3 r3 = bool3(true, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool3 b0 = bool3(true, true, false); + bool3 r0 = bool3(false, false, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (true); + bool3 b1 = bool3(false, true, false); + bool3 r1 = bool3(true, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (false); + bool3 b2 = bool3(false, true, true); + bool3 r2 = bool3(false, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (true); + bool3 b3 = bool3(false, true, true); + bool3 r3 = bool3(true, false, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3_operator_bitwise_and_wide_wide() + { + bool3 a0 = bool3(false, true, true); + bool3 b0 = bool3(false, true, false); + bool3 r0 = bool3(false, true, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool3 a1 = bool3(false, false, false); + bool3 b1 = bool3(false, false, true); + bool3 r1 = bool3(false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool3 a2 = bool3(true, false, true); + bool3 b2 = bool3(true, false, false); + bool3 r2 = bool3(true, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool3 a3 = bool3(true, false, true); + bool3 b3 = bool3(true, false, true); + bool3 r3 = bool3(true, false, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3_operator_bitwise_and_wide_scalar() + { + bool3 a0 = bool3(false, false, true); + bool b0 = (false); + bool3 r0 = bool3(false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool3 a1 = bool3(true, false, true); + bool b1 = (true); + bool3 r1 = bool3(true, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool3 a2 = bool3(true, false, false); + bool b2 = (true); + bool3 r2 = bool3(true, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool3 a3 = bool3(false, false, true); + bool b3 = (true); + bool3 r3 = bool3(false, false, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool3 b0 = bool3(false, false, true); + bool3 r0 = bool3(false, false, true); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (true); + bool3 b1 = bool3(false, false, true); + bool3 r1 = bool3(false, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (true); + bool3 b2 = bool3(true, false, true); + bool3 r2 = bool3(true, false, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (false); + bool3 b3 = bool3(true, true, false); + bool3 r3 = bool3(false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3_operator_bitwise_or_wide_wide() + { + bool3 a0 = bool3(true, false, false); + bool3 b0 = bool3(true, false, true); + bool3 r0 = bool3(true, false, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool3 a1 = bool3(true, true, false); + bool3 b1 = bool3(true, true, true); + bool3 r1 = bool3(true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool3 a2 = bool3(false, false, false); + bool3 b2 = bool3(true, true, true); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool3 a3 = bool3(false, true, true); + bool3 b3 = bool3(true, false, false); + bool3 r3 = bool3(true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3_operator_bitwise_or_wide_scalar() + { + bool3 a0 = bool3(false, false, true); + bool b0 = (true); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool3 a1 = bool3(true, true, false); + bool b1 = (false); + bool3 r1 = bool3(true, true, false); + TestUtils.AreEqual(a1 | b1, r1); + + bool3 a2 = bool3(true, true, true); + bool b2 = (false); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool3 a3 = bool3(false, true, false); + bool b3 = (false); + bool3 r3 = bool3(false, true, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool3 b0 = bool3(true, true, false); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (false); + bool3 b1 = bool3(false, false, true); + bool3 r1 = bool3(false, false, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (true); + bool3 b2 = bool3(false, true, true); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (false); + bool3 b3 = bool3(false, false, false); + bool3 r3 = bool3(false, false, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3_operator_bitwise_xor_wide_wide() + { + bool3 a0 = bool3(true, false, true); + bool3 b0 = bool3(false, true, false); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool3 a1 = bool3(true, true, true); + bool3 b1 = bool3(false, false, true); + bool3 r1 = bool3(true, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool3 a2 = bool3(false, false, false); + bool3 b2 = bool3(false, false, true); + bool3 r2 = bool3(false, false, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool3 a3 = bool3(false, true, false); + bool3 b3 = bool3(true, true, false); + bool3 r3 = bool3(true, false, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3_operator_bitwise_xor_wide_scalar() + { + bool3 a0 = bool3(true, false, false); + bool b0 = (false); + bool3 r0 = bool3(true, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool3 a1 = bool3(true, false, false); + bool b1 = (true); + bool3 r1 = bool3(false, true, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool3 a2 = bool3(false, false, true); + bool b2 = (true); + bool3 r2 = bool3(true, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool3 a3 = bool3(true, true, true); + bool b3 = (false); + bool3 r3 = bool3(true, true, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool3 b0 = bool3(true, false, false); + bool3 r0 = bool3(false, true, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (true); + bool3 b1 = bool3(false, true, true); + bool3 r1 = bool3(true, false, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (true); + bool3 b2 = bool3(true, true, true); + bool3 r2 = bool3(false, false, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (true); + bool3 b3 = bool3(true, true, true); + bool3 r3 = bool3(false, false, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3_operator_logical_not() + { + bool3 a0 = bool3(false, true, false); + bool3 r0 = bool3(true, false, true); + TestUtils.AreEqual(!a0, r0); + + bool3 a1 = bool3(true, false, false); + bool3 r1 = bool3(false, true, true); + TestUtils.AreEqual(!a1, r1); + + bool3 a2 = bool3(true, false, true); + bool3 r2 = bool3(false, true, false); + TestUtils.AreEqual(!a2, r2); + + bool3 a3 = bool3(true, false, false); + bool3 r3 = bool3(false, true, true); + 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/TestBool3.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/TestBool3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..32e56c8e88a3698c3b37327969aea6730dae6186 --- /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/TestBool3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: d208b4e1c03551a499e9169aac737e5b +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/TestBool3x2.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/TestBool3x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..e0af4f7507d8080a0f52a0b108778e6e670f0e35 --- /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/TestBool3x2.gen.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool3x2 + { + [TestCompiler] + public static void bool3x2_operator_equal_wide_wide() + { + bool3x2 a0 = bool3x2(false, false, true, true, true, true); + bool3x2 b0 = bool3x2(false, true, true, false, true, true); + bool3x2 r0 = bool3x2(true, false, true, false, true, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool3x2 a1 = bool3x2(true, true, true, true, true, true); + bool3x2 b1 = bool3x2(false, true, true, true, false, false); + bool3x2 r1 = bool3x2(false, true, true, true, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool3x2 a2 = bool3x2(true, false, false, false, true, true); + bool3x2 b2 = bool3x2(false, false, true, true, true, true); + bool3x2 r2 = bool3x2(false, true, false, false, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool3x2 a3 = bool3x2(true, true, true, false, false, false); + bool3x2 b3 = bool3x2(true, false, false, true, false, true); + bool3x2 r3 = bool3x2(true, false, false, false, true, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_equal_wide_scalar() + { + bool3x2 a0 = bool3x2(true, true, false, true, true, false); + bool b0 = (false); + bool3x2 r0 = bool3x2(false, false, true, false, false, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool3x2 a1 = bool3x2(true, true, false, false, false, false); + bool b1 = (true); + bool3x2 r1 = bool3x2(true, true, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool3x2 a2 = bool3x2(true, false, false, false, true, true); + bool b2 = (false); + bool3x2 r2 = bool3x2(false, true, true, true, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool3x2 a3 = bool3x2(false, true, false, true, false, true); + bool b3 = (false); + bool3x2 r3 = bool3x2(true, false, true, false, true, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_equal_scalar_wide() + { + bool a0 = (true); + bool3x2 b0 = bool3x2(false, false, true, false, true, false); + bool3x2 r0 = bool3x2(false, false, true, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (true); + bool3x2 b1 = bool3x2(false, false, false, false, true, false); + bool3x2 r1 = bool3x2(false, false, false, false, true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (true); + bool3x2 b2 = bool3x2(true, true, false, true, true, false); + bool3x2 r2 = bool3x2(true, true, false, true, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (false); + bool3x2 b3 = bool3x2(true, false, false, true, false, false); + bool3x2 r3 = bool3x2(false, true, true, false, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_not_equal_wide_wide() + { + bool3x2 a0 = bool3x2(true, false, false, true, true, true); + bool3x2 b0 = bool3x2(false, false, true, false, false, false); + bool3x2 r0 = bool3x2(true, false, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool3x2 a1 = bool3x2(true, true, true, true, false, true); + bool3x2 b1 = bool3x2(false, false, true, true, false, false); + bool3x2 r1 = bool3x2(true, true, false, false, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool3x2 a2 = bool3x2(true, false, true, false, false, true); + bool3x2 b2 = bool3x2(false, false, false, true, true, false); + bool3x2 r2 = bool3x2(true, false, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool3x2 a3 = bool3x2(true, true, false, true, false, false); + bool3x2 b3 = bool3x2(false, false, false, false, true, true); + bool3x2 r3 = bool3x2(true, true, false, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_not_equal_wide_scalar() + { + bool3x2 a0 = bool3x2(false, false, true, true, true, true); + bool b0 = (false); + bool3x2 r0 = bool3x2(false, false, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool3x2 a1 = bool3x2(false, true, false, true, false, true); + bool b1 = (false); + bool3x2 r1 = bool3x2(false, true, false, true, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool3x2 a2 = bool3x2(false, true, true, true, false, false); + bool b2 = (true); + bool3x2 r2 = bool3x2(true, false, false, false, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool3x2 a3 = bool3x2(true, true, true, false, false, false); + bool b3 = (true); + bool3x2 r3 = bool3x2(false, false, false, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool3x2 b0 = bool3x2(true, true, false, true, false, true); + bool3x2 r0 = bool3x2(false, false, true, false, true, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool3x2 b1 = bool3x2(false, false, true, true, true, false); + bool3x2 r1 = bool3x2(false, false, true, true, true, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (true); + bool3x2 b2 = bool3x2(true, false, false, false, true, true); + bool3x2 r2 = bool3x2(false, true, true, true, false, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (false); + bool3x2 b3 = bool3x2(false, true, false, true, false, false); + bool3x2 r3 = bool3x2(false, true, false, true, false, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_bitwise_and_wide_wide() + { + bool3x2 a0 = bool3x2(false, true, true, false, false, false); + bool3x2 b0 = bool3x2(false, true, false, false, false, true); + bool3x2 r0 = bool3x2(false, true, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool3x2 a1 = bool3x2(true, false, true, true, false, true); + bool3x2 b1 = bool3x2(true, false, false, true, false, true); + bool3x2 r1 = bool3x2(true, false, false, true, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool3x2 a2 = bool3x2(false, false, true, false, false, false); + bool3x2 b2 = bool3x2(true, false, true, true, false, false); + bool3x2 r2 = bool3x2(false, false, true, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool3x2 a3 = bool3x2(false, true, false, true, true, false); + bool3x2 b3 = bool3x2(false, true, false, false, false, true); + bool3x2 r3 = bool3x2(false, true, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_bitwise_and_wide_scalar() + { + bool3x2 a0 = bool3x2(false, false, true, true, true, false); + bool b0 = (false); + bool3x2 r0 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool3x2 a1 = bool3x2(true, true, false, false, false, true); + bool b1 = (true); + bool3x2 r1 = bool3x2(true, true, false, false, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool3x2 a2 = bool3x2(false, false, false, true, false, true); + bool b2 = (true); + bool3x2 r2 = bool3x2(false, false, false, true, false, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool3x2 a3 = bool3x2(true, true, false, true, false, true); + bool b3 = (false); + bool3x2 r3 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool3x2 b0 = bool3x2(false, false, true, true, false, false); + bool3x2 r0 = bool3x2(false, false, true, true, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (true); + bool3x2 b1 = bool3x2(true, true, false, true, false, true); + bool3x2 r1 = bool3x2(true, true, false, true, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (true); + bool3x2 b2 = bool3x2(false, false, true, true, false, true); + bool3x2 r2 = bool3x2(false, false, true, true, false, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (true); + bool3x2 b3 = bool3x2(false, true, true, true, true, true); + bool3x2 r3 = bool3x2(false, true, true, true, true, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_bitwise_or_wide_wide() + { + bool3x2 a0 = bool3x2(true, false, false, true, true, false); + bool3x2 b0 = bool3x2(true, false, true, true, true, true); + bool3x2 r0 = bool3x2(true, false, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool3x2 a1 = bool3x2(false, false, false, false, true, true); + bool3x2 b1 = bool3x2(true, true, true, true, false, false); + bool3x2 r1 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool3x2 a2 = bool3x2(false, false, true, true, true, false); + bool3x2 b2 = bool3x2(true, true, true, true, true, true); + bool3x2 r2 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool3x2 a3 = bool3x2(true, true, false, true, false, false); + bool3x2 b3 = bool3x2(false, false, false, false, true, false); + bool3x2 r3 = bool3x2(true, true, false, true, true, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_bitwise_or_wide_scalar() + { + bool3x2 a0 = bool3x2(false, false, true, true, false, true); + bool b0 = (true); + bool3x2 r0 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool3x2 a1 = bool3x2(false, false, true, true, false, false); + bool b1 = (true); + bool3x2 r1 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool3x2 a2 = bool3x2(true, true, false, true, false, false); + bool b2 = (false); + bool3x2 r2 = bool3x2(true, true, false, true, false, false); + TestUtils.AreEqual(a2 | b2, r2); + + bool3x2 a3 = bool3x2(false, true, false, true, true, true); + bool b3 = (true); + bool3x2 r3 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool3x2 b0 = bool3x2(true, true, false, false, false, false); + bool3x2 r0 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (true); + bool3x2 b1 = bool3x2(true, false, true, true, false, false); + bool3x2 r1 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (false); + bool3x2 b2 = bool3x2(false, false, false, false, false, true); + bool3x2 r2 = bool3x2(false, false, false, false, false, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (false); + bool3x2 b3 = bool3x2(true, true, true, true, true, false); + bool3x2 r3 = bool3x2(true, true, true, true, true, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_bitwise_xor_wide_wide() + { + bool3x2 a0 = bool3x2(true, false, true, true, true, true); + bool3x2 b0 = bool3x2(false, true, false, false, false, true); + bool3x2 r0 = bool3x2(true, true, true, true, true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool3x2 a1 = bool3x2(false, false, false, false, true, false); + bool3x2 b1 = bool3x2(false, false, true, true, true, false); + bool3x2 r1 = bool3x2(false, false, true, true, false, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool3x2 a2 = bool3x2(false, false, true, false, true, false); + bool3x2 b2 = bool3x2(false, false, true, true, false, false); + bool3x2 r2 = bool3x2(false, false, false, true, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool3x2 a3 = bool3x2(false, false, true, true, true, true); + bool3x2 b3 = bool3x2(true, true, true, true, false, true); + bool3x2 r3 = bool3x2(true, true, false, false, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_bitwise_xor_wide_scalar() + { + bool3x2 a0 = bool3x2(true, false, false, true, true, false); + bool b0 = (false); + bool3x2 r0 = bool3x2(true, false, false, true, true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool3x2 a1 = bool3x2(false, true, false, true, true, false); + bool b1 = (false); + bool3x2 r1 = bool3x2(false, true, false, true, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool3x2 a2 = bool3x2(true, false, false, false, false, false); + bool b2 = (true); + bool3x2 r2 = bool3x2(false, true, true, true, true, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool3x2 a3 = bool3x2(false, false, false, true, true, false); + bool b3 = (false); + bool3x2 r3 = bool3x2(false, false, false, true, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool3x2 b0 = bool3x2(true, false, false, true, false, true); + bool3x2 r0 = bool3x2(false, true, true, false, true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (true); + bool3x2 b1 = bool3x2(true, true, true, true, true, true); + bool3x2 r1 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (true); + bool3x2 b2 = bool3x2(true, true, false, true, false, true); + bool3x2 r2 = bool3x2(false, false, true, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (false); + bool3x2 b3 = bool3x2(false, false, false, true, false, true); + bool3x2 r3 = bool3x2(false, false, false, true, false, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3x2_operator_logical_not() + { + bool3x2 a0 = bool3x2(false, true, false, true, false, false); + bool3x2 r0 = bool3x2(true, false, true, false, true, true); + TestUtils.AreEqual(!a0, r0); + + bool3x2 a1 = bool3x2(false, true, false, true, true, true); + bool3x2 r1 = bool3x2(true, false, true, false, false, false); + TestUtils.AreEqual(!a1, r1); + + bool3x2 a2 = bool3x2(false, false, true, false, false, true); + bool3x2 r2 = bool3x2(true, true, false, true, true, false); + TestUtils.AreEqual(!a2, r2); + + bool3x2 a3 = bool3x2(false, false, false, true, true, true); + bool3x2 r3 = bool3x2(true, true, true, false, false, false); + 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/TestBool3x2.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/TestBool3x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..f8b84ee7e34b938069a40b71cf5e4cde1bbcb2cc --- /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/TestBool3x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 2bbc879646b3ce649a77073d236979fc +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/TestBool3x3.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/TestBool3x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..fc49a39ed5728c77668fa5ecc5cfd582cf68a207 --- /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/TestBool3x3.gen.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool3x3 + { + [TestCompiler] + public static void bool3x3_operator_equal_wide_wide() + { + bool3x3 a0 = bool3x3(false, false, true, true, true, true, true, true, true); + bool3x3 b0 = bool3x3(false, true, true, false, true, true, false, true, true); + bool3x3 r0 = bool3x3(true, false, true, false, true, true, false, true, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool3x3 a1 = bool3x3(true, true, true, true, false, false, false, true, true); + bool3x3 b1 = bool3x3(true, false, false, false, false, true, true, true, true); + bool3x3 r1 = bool3x3(true, false, false, false, true, false, false, true, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool3x3 a2 = bool3x3(true, true, true, false, false, false, false, true, false); + bool3x3 b2 = bool3x3(true, false, false, true, false, true, false, true, true); + bool3x3 r2 = bool3x3(true, false, false, false, true, false, true, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool3x3 a3 = bool3x3(true, true, true, true, true, false, true, true, false); + bool3x3 b3 = bool3x3(false, false, true, false, false, false, true, true, false); + bool3x3 r3 = bool3x3(false, false, true, false, false, true, true, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_equal_wide_scalar() + { + bool3x3 a0 = bool3x3(true, true, false, true, true, false, true, true, true); + bool b0 = (false); + bool3x3 r0 = bool3x3(false, false, true, false, false, true, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool3x3 a1 = bool3x3(false, false, false, true, false, false, false, false, true); + bool b1 = (false); + bool3x3 r1 = bool3x3(true, true, true, false, true, true, true, true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool3x3 a2 = bool3x3(true, false, true, false, true, false, true, false, true); + bool b2 = (false); + bool3x3 r2 = bool3x3(false, true, false, true, false, true, false, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool3x3 a3 = bool3x3(false, true, false, true, true, false, false, false, false); + bool b3 = (false); + bool3x3 r3 = bool3x3(true, false, true, false, false, true, true, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_equal_scalar_wide() + { + bool a0 = (true); + bool3x3 b0 = bool3x3(false, false, true, false, true, false, true, false, false); + bool3x3 r0 = bool3x3(false, false, true, false, true, false, true, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (false); + bool3x3 b1 = bool3x3(false, true, false, true, true, true, false, true, true); + bool3x3 r1 = bool3x3(true, false, true, false, false, false, true, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (false); + bool3x3 b2 = bool3x3(false, true, false, false, true, false, false, true, false); + bool3x3 r2 = bool3x3(true, false, true, true, false, true, true, false, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (false); + bool3x3 b3 = bool3x3(true, false, true, true, true, true, false, false, true); + bool3x3 r3 = bool3x3(false, true, false, false, false, false, true, true, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_not_equal_wide_wide() + { + bool3x3 a0 = bool3x3(true, false, false, true, true, true, true, true, true); + bool3x3 b0 = bool3x3(false, false, true, false, false, false, false, false, true); + bool3x3 r0 = bool3x3(true, false, true, true, true, true, true, true, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool3x3 a1 = bool3x3(true, false, true, true, false, true, false, false, true); + bool3x3 b1 = bool3x3(true, false, false, false, false, false, true, true, false); + bool3x3 r1 = bool3x3(false, false, true, true, false, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool3x3 a2 = bool3x3(true, true, false, true, false, false, false, true, true); + bool3x3 b2 = bool3x3(false, false, false, false, true, true, true, false, false); + bool3x3 r2 = bool3x3(true, true, false, true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool3x3 a3 = bool3x3(true, false, false, true, false, false, true, false, true); + bool3x3 b3 = bool3x3(false, true, true, false, false, true, false, false, true); + bool3x3 r3 = bool3x3(true, true, true, true, false, true, true, false, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_not_equal_wide_scalar() + { + bool3x3 a0 = bool3x3(false, false, true, true, true, true, false, false, true); + bool b0 = (false); + bool3x3 r0 = bool3x3(false, false, true, true, true, true, false, false, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool3x3 a1 = bool3x3(false, false, true, false, true, true, true, true, false); + bool b1 = (true); + bool3x3 r1 = bool3x3(true, true, false, true, false, false, false, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool3x3 a2 = bool3x3(false, true, true, true, false, false, false, false, false); + bool b2 = (true); + bool3x3 r2 = bool3x3(true, false, false, false, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool3x3 a3 = bool3x3(true, true, false, true, false, true, true, true, false); + bool b3 = (true); + bool3x3 r3 = bool3x3(false, false, true, false, true, false, false, false, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool3x3 b0 = bool3x3(true, true, false, true, false, true, false, false, false); + bool3x3 r0 = bool3x3(false, false, true, false, true, false, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (true); + bool3x3 b1 = bool3x3(true, true, false, true, true, false, false, false, true); + bool3x3 r1 = bool3x3(false, false, true, false, false, true, true, true, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (true); + bool3x3 b2 = bool3x3(false, false, true, false, true, false, false, true, true); + bool3x3 r2 = bool3x3(true, true, false, true, false, true, true, false, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (true); + bool3x3 b3 = bool3x3(false, false, true, false, false, true, false, true, false); + bool3x3 r3 = bool3x3(true, true, false, true, true, false, true, false, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_bitwise_and_wide_wide() + { + bool3x3 a0 = bool3x3(false, true, true, false, false, false, true, false, true); + bool3x3 b0 = bool3x3(false, true, false, false, false, true, true, false, false); + bool3x3 r0 = bool3x3(false, true, false, false, false, false, true, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool3x3 a1 = bool3x3(true, false, true, false, false, true, false, false, false); + bool3x3 b1 = bool3x3(true, false, true, true, false, true, true, false, false); + bool3x3 r1 = bool3x3(true, false, true, false, false, true, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool3x3 a2 = bool3x3(false, true, false, true, true, false, false, false, true); + bool3x3 b2 = bool3x3(false, true, false, false, false, true, true, false, false); + bool3x3 r2 = bool3x3(false, true, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool3x3 a3 = bool3x3(false, false, true, false, false, true, true, true, false); + bool3x3 b3 = bool3x3(false, true, false, false, true, false, false, false, true); + bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_bitwise_and_wide_scalar() + { + bool3x3 a0 = bool3x3(false, false, true, true, true, false, true, true, true); + bool b0 = (false); + bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool3x3 a1 = bool3x3(false, false, true, false, true, false, false, true, false); + bool b1 = (false); + bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool3x3 a2 = bool3x3(true, false, true, false, true, false, true, true, true); + bool b2 = (true); + bool3x3 r2 = bool3x3(true, false, true, false, true, false, true, true, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool3x3 a3 = bool3x3(false, true, false, false, true, false, true, true, false); + bool b3 = (false); + bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool3x3 b0 = bool3x3(false, false, true, true, false, false, true, true, true); + bool3x3 r0 = bool3x3(false, false, true, true, false, false, true, true, true); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (false); + bool3x3 b1 = bool3x3(true, false, true, true, false, false, true, true, false); + bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (true); + bool3x3 b2 = bool3x3(true, false, true, true, true, true, true, false, true); + bool3x3 r2 = bool3x3(true, false, true, true, true, true, true, false, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (true); + bool3x3 b3 = bool3x3(true, false, true, false, true, false, true, false, true); + bool3x3 r3 = bool3x3(true, false, true, false, true, false, true, false, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_bitwise_or_wide_wide() + { + bool3x3 a0 = bool3x3(true, false, false, true, true, false, false, false, false); + bool3x3 b0 = bool3x3(true, false, true, true, true, true, true, true, true); + bool3x3 r0 = bool3x3(true, false, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool3x3 a1 = bool3x3(false, true, true, false, false, true, true, true, false); + bool3x3 b1 = bool3x3(true, false, false, true, true, true, true, true, true); + bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool3x3 a2 = bool3x3(true, true, false, true, false, false, false, false, true); + bool3x3 b2 = bool3x3(false, false, false, false, true, false, false, true, false); + bool3x3 r2 = bool3x3(true, true, false, true, true, false, false, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool3x3 a3 = bool3x3(false, true, false, false, true, false, false, false, true); + bool3x3 b3 = bool3x3(true, false, false, true, true, true, true, true, false); + bool3x3 r3 = bool3x3(true, true, false, true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_bitwise_or_wide_scalar() + { + bool3x3 a0 = bool3x3(false, false, true, true, false, true, false, true, false); + bool b0 = (true); + bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool3x3 a1 = bool3x3(true, false, false, true, false, true, false, true, false); + bool b1 = (true); + bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool3x3 a2 = bool3x3(false, true, true, false, true, true, true, true, true); + bool b2 = (false); + bool3x3 r2 = bool3x3(false, true, true, false, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool3x3 a3 = bool3x3(true, true, false, false, false, true, false, false, true); + bool b3 = (true); + bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool3x3 b0 = bool3x3(true, true, false, false, false, false, true, true, false); + bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (true); + bool3x3 b1 = bool3x3(true, false, false, false, false, false, false, false, false); + bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (true); + bool3x3 b2 = bool3x3(false, true, true, true, true, true, false, true, false); + bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (false); + bool3x3 b3 = bool3x3(true, true, false, false, false, true, false, true, true); + bool3x3 r3 = bool3x3(true, true, false, false, false, true, false, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_bitwise_xor_wide_wide() + { + bool3x3 a0 = bool3x3(true, false, true, true, true, true, false, false, false); + bool3x3 b0 = bool3x3(false, true, false, false, false, true, false, false, true); + bool3x3 r0 = bool3x3(true, true, true, true, true, false, false, false, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool3x3 a1 = bool3x3(false, true, false, false, false, true, false, true, false); + bool3x3 b1 = bool3x3(true, true, false, false, false, true, true, false, false); + bool3x3 r1 = bool3x3(true, false, false, false, false, false, true, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool3x3 a2 = bool3x3(false, false, true, true, true, true, true, false, true); + bool3x3 b2 = bool3x3(true, true, true, true, false, true, true, false, false); + bool3x3 r2 = bool3x3(true, true, false, false, true, false, false, false, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool3x3 a3 = bool3x3(true, false, false, true, false, false, true, true, true); + bool3x3 b3 = bool3x3(false, true, false, false, false, false, false, true, false); + bool3x3 r3 = bool3x3(true, true, false, true, false, false, true, false, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_bitwise_xor_wide_scalar() + { + bool3x3 a0 = bool3x3(true, false, false, true, true, false, false, false, true); + bool b0 = (false); + bool3x3 r0 = bool3x3(true, false, false, true, true, false, false, false, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool3x3 a1 = bool3x3(false, true, false, true, true, false, false, false, false); + bool b1 = (true); + bool3x3 r1 = bool3x3(true, false, true, false, false, true, true, true, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool3x3 a2 = bool3x3(false, false, false, false, true, true, false, false, false); + bool b2 = (false); + bool3x3 r2 = bool3x3(false, false, false, false, true, true, false, false, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool3x3 a3 = bool3x3(false, true, true, false, false, false, true, false, false); + bool b3 = (false); + bool3x3 r3 = bool3x3(false, true, true, false, false, false, true, false, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool3x3 b0 = bool3x3(true, false, false, true, false, true, true, true, true); + bool3x3 r0 = bool3x3(false, true, true, false, true, false, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (true); + bool3x3 b1 = bool3x3(true, true, true, true, true, true, false, true, false); + bool3x3 r1 = bool3x3(false, false, false, false, false, false, true, false, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (true); + bool3x3 b2 = bool3x3(false, false, false, false, true, false, true, false, true); + bool3x3 r2 = bool3x3(true, true, true, true, false, true, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (true); + bool3x3 b3 = bool3x3(false, true, false, false, false, false, true, false, false); + bool3x3 r3 = bool3x3(true, false, true, true, true, true, false, true, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3x3_operator_logical_not() + { + bool3x3 a0 = bool3x3(false, true, false, true, false, false, false, true, true); + bool3x3 r0 = bool3x3(true, false, true, false, true, true, true, false, false); + TestUtils.AreEqual(!a0, r0); + + bool3x3 a1 = bool3x3(false, true, true, false, false, false, true, false, false); + bool3x3 r1 = bool3x3(true, false, false, true, true, true, false, true, true); + TestUtils.AreEqual(!a1, r1); + + bool3x3 a2 = bool3x3(true, true, false, false, true, true, true, true, true); + bool3x3 r2 = bool3x3(false, false, true, true, false, false, false, false, false); + TestUtils.AreEqual(!a2, r2); + + bool3x3 a3 = bool3x3(true, true, false, false, true, false, false, false, true); + bool3x3 r3 = bool3x3(false, false, true, true, false, true, true, true, false); + 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/TestBool3x3.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/TestBool3x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..070d46422c9fd753451bbeab868e656fa8161575 --- /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/TestBool3x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 16fef77cdd788b54983aea9d37b2efb1 +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/TestBool3x4.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/TestBool3x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..dae375024f6a04a85871e16056bede902071720f --- /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/TestBool3x4.gen.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool3x4 + { + [TestCompiler] + public static void bool3x4_operator_equal_wide_wide() + { + bool3x4 a0 = bool3x4(false, false, true, true, true, true, true, true, true, true, true, true); + bool3x4 b0 = bool3x4(false, true, true, false, true, true, false, true, true, true, false, false); + bool3x4 r0 = bool3x4(true, false, true, false, true, true, false, true, true, true, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool3x4 a1 = bool3x4(true, false, false, false, true, true, true, true, true, false, false, false); + bool3x4 b1 = bool3x4(false, false, true, true, true, true, true, false, false, true, false, true); + bool3x4 r1 = bool3x4(false, true, false, false, true, true, true, false, false, false, true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool3x4 a2 = bool3x4(false, true, false, true, true, true, true, true, false, true, true, false); + bool3x4 b2 = bool3x4(false, true, true, false, false, true, false, false, false, true, true, false); + bool3x4 r2 = bool3x4(true, true, false, false, false, true, false, false, true, true, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool3x4 a3 = bool3x4(false, true, true, false, false, true, true, true, true, false, true, false); + bool3x4 b3 = bool3x4(true, false, true, true, false, true, false, false, false, true, true, false); + bool3x4 r3 = bool3x4(false, false, true, false, true, true, false, false, false, false, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_equal_wide_scalar() + { + bool3x4 a0 = bool3x4(true, true, false, true, true, false, true, true, true, false, false, false); + bool b0 = (false); + bool3x4 r0 = bool3x4(false, false, true, false, false, true, false, false, false, true, true, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool3x4 a1 = bool3x4(false, false, false, false, false, true, true, false, false, true, false, true); + bool b1 = (true); + bool3x4 r1 = bool3x4(false, false, false, false, false, true, true, false, false, true, false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool3x4 a2 = bool3x4(false, false, true, false, false, true, false, true, true, false, false, false); + bool b2 = (true); + bool3x4 r2 = bool3x4(false, false, true, false, false, true, false, true, true, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool3x4 a3 = bool3x4(false, true, false, true, true, false, false, false, true, true, true, false); + bool b3 = (false); + bool3x4 r3 = bool3x4(true, false, true, false, false, true, true, true, false, false, false, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_equal_scalar_wide() + { + bool a0 = (true); + bool3x4 b0 = bool3x4(false, false, true, false, true, false, true, false, false, false, false, true); + bool3x4 r0 = bool3x4(false, false, true, false, true, false, true, false, false, false, false, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (false); + bool3x4 b1 = bool3x4(true, true, true, false, true, true, false, false, true, false, false, true); + bool3x4 r1 = bool3x4(false, false, false, true, false, false, true, true, false, true, true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (false); + bool3x4 b2 = bool3x4(false, true, false, false, true, false, true, true, true, true, false, false); + bool3x4 r2 = bool3x4(true, false, true, true, false, true, false, false, false, false, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (true); + bool3x4 b3 = bool3x4(false, false, true, true, true, false, true, false, false, true, true, true); + bool3x4 r3 = bool3x4(false, false, true, true, true, false, true, false, false, true, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_not_equal_wide_wide() + { + bool3x4 a0 = bool3x4(true, false, false, true, true, true, true, true, true, true, false, true); + bool3x4 b0 = bool3x4(false, false, true, false, false, false, false, false, true, true, false, false); + bool3x4 r0 = bool3x4(true, false, true, true, true, true, true, true, false, false, false, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool3x4 a1 = bool3x4(true, false, true, false, false, true, true, true, false, true, false, false); + bool3x4 b1 = bool3x4(false, false, false, true, true, false, false, false, false, false, true, true); + bool3x4 r1 = bool3x4(true, false, true, true, true, true, true, true, false, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool3x4 a2 = bool3x4(false, true, true, true, false, false, true, false, false, true, false, true); + bool3x4 b2 = bool3x4(true, false, false, false, true, true, false, false, true, false, false, true); + bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, false, true, true, false, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool3x4 a3 = bool3x4(true, true, true, false, true, true, true, false, true, false, false, false); + bool3x4 b3 = bool3x4(true, true, true, false, false, true, false, false, false, true, true, true); + bool3x4 r3 = bool3x4(false, false, false, false, true, false, true, false, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_not_equal_wide_scalar() + { + bool3x4 a0 = bool3x4(false, false, true, true, true, true, false, false, true, false, true, false); + bool b0 = (false); + bool3x4 r0 = bool3x4(false, false, true, true, true, true, false, false, true, false, true, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool3x4 a1 = bool3x4(true, true, true, true, true, false, false, true, true, true, true, false); + bool b1 = (false); + bool3x4 r1 = bool3x4(true, true, true, true, true, false, false, true, true, true, true, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool3x4 a2 = bool3x4(false, false, false, true, true, true, false, true, false, true, true, true); + bool b2 = (false); + bool3x4 r2 = bool3x4(false, false, false, true, true, true, false, true, false, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool3x4 a3 = bool3x4(false, true, true, false, true, false, false, false, false, true, true, false); + bool b3 = (false); + bool3x4 r3 = bool3x4(false, true, true, false, true, false, false, false, false, true, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool3x4 b0 = bool3x4(true, true, false, true, false, true, false, false, false, true, true, true); + bool3x4 r0 = bool3x4(false, false, true, false, true, false, true, true, true, false, false, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool3x4 b1 = bool3x4(true, true, false, false, false, true, true, false, false, true, false, true); + bool3x4 r1 = bool3x4(true, true, false, false, false, true, true, false, false, true, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (false); + bool3x4 b2 = bool3x4(false, true, true, true, false, false, true, false, false, true, false, true); + bool3x4 r2 = bool3x4(false, true, true, true, false, false, true, false, false, true, false, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (false); + bool3x4 b3 = bool3x4(false, false, false, true, false, false, true, false, false, false, false, false); + bool3x4 r3 = bool3x4(false, false, false, true, false, false, true, false, false, false, false, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_bitwise_and_wide_wide() + { + bool3x4 a0 = bool3x4(false, true, true, false, false, false, true, false, true, true, false, true); + bool3x4 b0 = bool3x4(false, true, false, false, false, true, true, false, false, true, false, true); + bool3x4 r0 = bool3x4(false, true, false, false, false, false, true, false, false, true, false, true); + TestUtils.AreEqual(a0 & b0, r0); + + bool3x4 a1 = bool3x4(false, false, true, false, false, false, false, true, false, true, true, false); + bool3x4 b1 = bool3x4(true, false, true, true, false, false, false, true, false, false, false, true); + bool3x4 r1 = bool3x4(false, false, true, false, false, false, false, true, false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool3x4 a2 = bool3x4(false, false, true, false, false, true, false, false, true, true, true, false); + bool3x4 b2 = bool3x4(true, false, false, false, true, false, false, true, false, false, false, true); + bool3x4 r2 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool3x4 a3 = bool3x4(false, false, false, true, true, false, true, false, false, true, true, true); + bool3x4 b3 = bool3x4(true, true, false, true, false, false, false, true, false, false, true, true); + bool3x4 r3 = bool3x4(false, false, false, true, false, false, false, false, false, false, true, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_bitwise_and_wide_scalar() + { + bool3x4 a0 = bool3x4(false, false, true, true, true, false, true, true, true, false, false, false); + bool b0 = (false); + bool3x4 r0 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool3x4 a1 = bool3x4(true, true, false, false, true, false, true, true, false, true, false, true); + bool b1 = (false); + bool3x4 r1 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool3x4 a2 = bool3x4(false, true, true, false, false, true, false, false, true, false, true, true); + bool b2 = (true); + bool3x4 r2 = bool3x4(false, true, true, false, false, true, false, false, true, false, true, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool3x4 a3 = bool3x4(false, false, true, false, false, true, true, false, true, false, false, true); + bool b3 = (false); + bool3x4 r3 = bool3x4(false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool3x4 b0 = bool3x4(false, false, true, true, false, false, true, true, true, false, true, false); + bool3x4 r0 = bool3x4(false, false, true, true, false, false, true, true, true, false, true, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (true); + bool3x4 b1 = bool3x4(true, false, false, true, true, false, true, true, false, true, true, true); + bool3x4 r1 = bool3x4(true, false, false, true, true, false, true, true, false, true, true, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (true); + bool3x4 b2 = bool3x4(true, false, true, true, true, false, true, false, true, false, true, false); + bool3x4 r2 = bool3x4(true, false, true, true, true, false, true, false, true, false, true, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (true); + bool3x4 b3 = bool3x4(true, true, false, true, true, false, true, false, false, false, true, true); + bool3x4 r3 = bool3x4(true, true, false, true, true, false, true, false, false, false, true, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_bitwise_or_wide_wide() + { + bool3x4 a0 = bool3x4(true, false, false, true, true, false, false, false, false, false, true, true); + bool3x4 b0 = bool3x4(true, false, true, true, true, true, true, true, true, true, false, false); + bool3x4 r0 = bool3x4(true, false, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool3x4 a1 = bool3x4(false, false, true, true, true, false, true, true, false, true, false, false); + bool3x4 b1 = bool3x4(true, true, true, true, true, true, false, false, false, false, true, false); + bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, false, true, true, false); + TestUtils.AreEqual(a1 | b1, r1); + + bool3x4 a2 = bool3x4(false, false, true, false, true, false, false, true, false, false, false, true); + bool3x4 b2 = bool3x4(false, true, false, true, false, false, true, true, true, true, true, false); + bool3x4 r2 = bool3x4(false, true, true, true, true, false, true, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool3x4 a3 = bool3x4(false, false, false, false, false, true, false, true, true, true, true, false); + bool3x4 b3 = bool3x4(true, true, true, true, true, true, true, false, true, true, false, false); + bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_bitwise_or_wide_scalar() + { + bool3x4 a0 = bool3x4(false, false, true, true, false, true, false, true, false, true, true, false); + bool b0 = (true); + bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool3x4 a1 = bool3x4(false, false, true, false, true, false, false, false, true, true, false, true); + bool b1 = (true); + bool3x4 r1 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool3x4 a2 = bool3x4(true, true, true, true, true, true, false, false, false, true, false, false); + bool b2 = (true); + bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool3x4 a3 = bool3x4(true, true, true, false, false, false, false, true, true, true, true, false); + bool b3 = (true); + bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool3x4 b0 = bool3x4(true, true, false, false, false, false, true, true, false, true, true, false); + bool3x4 r0 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (false); + bool3x4 b1 = bool3x4(false, false, false, false, false, false, true, false, true, true, true, true); + bool3x4 r1 = bool3x4(false, false, false, false, false, false, true, false, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (true); + bool3x4 b2 = bool3x4(false, true, false, false, true, true, false, false, false, true, false, true); + bool3x4 r2 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (true); + bool3x4 b3 = bool3x4(false, true, false, false, true, true, true, false, false, true, true, true); + bool3x4 r3 = bool3x4(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_bitwise_xor_wide_wide() + { + bool3x4 a0 = bool3x4(true, false, true, true, true, true, false, false, false, false, true, false); + bool3x4 b0 = bool3x4(false, true, false, false, false, true, false, false, true, true, true, false); + bool3x4 r0 = bool3x4(true, true, true, true, true, false, false, false, true, true, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool3x4 a1 = bool3x4(false, false, true, false, true, false, false, false, true, true, true, true); + bool3x4 b1 = bool3x4(false, false, true, true, false, false, true, true, true, true, false, true); + bool3x4 r1 = bool3x4(false, false, false, true, true, false, true, true, false, false, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool3x4 a2 = bool3x4(true, false, true, true, false, false, true, false, false, true, true, true); + bool3x4 b2 = bool3x4(true, false, false, false, true, false, false, false, false, false, true, false); + bool3x4 r2 = bool3x4(false, false, true, true, true, false, true, false, false, true, false, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool3x4 a3 = bool3x4(true, false, true, true, true, true, false, true, false, true, false, true); + bool3x4 b3 = bool3x4(true, true, false, false, false, false, true, false, false, false, true, false); + bool3x4 r3 = bool3x4(false, true, true, true, true, true, true, true, false, true, true, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_bitwise_xor_wide_scalar() + { + bool3x4 a0 = bool3x4(true, false, false, true, true, false, false, false, true, false, true, true); + bool b0 = (false); + bool3x4 r0 = bool3x4(true, false, false, true, true, false, false, false, true, false, true, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool3x4 a1 = bool3x4(false, true, false, false, false, false, false, false, false, false, false, true); + bool b1 = (true); + bool3x4 r1 = bool3x4(true, false, true, true, true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool3x4 a2 = bool3x4(true, false, false, false, false, true, true, false, false, false, true, false); + bool b2 = (false); + bool3x4 r2 = bool3x4(true, false, false, false, false, true, true, false, false, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool3x4 a3 = bool3x4(false, true, false, true, true, false, false, true, true, true, false, true); + bool b3 = (false); + bool3x4 r3 = bool3x4(false, true, false, true, true, false, false, true, true, true, false, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool3x4 b0 = bool3x4(true, false, false, true, false, true, true, true, true, true, true, true); + bool3x4 r0 = bool3x4(false, true, true, false, true, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (true); + bool3x4 b1 = bool3x4(true, true, true, false, true, false, true, false, false, false, false, true); + bool3x4 r1 = bool3x4(false, false, false, true, false, true, false, true, true, true, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (false); + bool3x4 b2 = bool3x4(true, false, true, true, false, true, false, false, false, false, true, false); + bool3x4 r2 = bool3x4(true, false, true, true, false, true, false, false, false, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (false); + bool3x4 b3 = bool3x4(false, false, false, true, false, false, true, true, false, false, true, false); + bool3x4 r3 = bool3x4(false, false, false, true, false, false, true, true, false, false, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool3x4_operator_logical_not() + { + bool3x4 a0 = bool3x4(false, true, false, true, false, false, false, true, true, false, true, true); + bool3x4 r0 = bool3x4(true, false, true, false, true, true, true, false, false, true, false, false); + TestUtils.AreEqual(!a0, r0); + + bool3x4 a1 = bool3x4(true, false, false, true, false, false, true, false, true, false, false, true); + bool3x4 r1 = bool3x4(false, true, true, false, true, true, false, true, false, true, true, false); + TestUtils.AreEqual(!a1, r1); + + bool3x4 a2 = bool3x4(true, true, true, true, false, true, false, false, true, false, false, false); + bool3x4 r2 = bool3x4(false, false, false, false, true, false, true, true, false, true, true, true); + TestUtils.AreEqual(!a2, r2); + + bool3x4 a3 = bool3x4(true, false, false, false, false, true, false, true, true, true, false, true); + bool3x4 r3 = bool3x4(false, true, true, true, true, false, true, false, false, false, true, false); + 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/TestBool3x4.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/TestBool3x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..3a7091709e4654680a46d72880a8e4ef7d4ba4fd --- /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/TestBool3x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ce96cd62cfbd7e24c9173437069a42ad +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/TestBool4.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/TestBool4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..229870ae3628d1600f1c6fcba4f5f0172d8213a7 --- /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/TestBool4.gen.cs @@ -0,0 +1,440 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool4 + { + [TestCompiler] + public static void bool4_constructor() + { + bool4 a = new bool4(false, true, false, true); + TestUtils.AreEqual(a.x, false); + TestUtils.AreEqual(a.y, true); + TestUtils.AreEqual(a.z, false); + TestUtils.AreEqual(a.w, true); + } + + [TestCompiler] + public static void bool4_scalar_constructor() + { + bool4 a = new bool4(true); + TestUtils.AreEqual(a.x, true); + TestUtils.AreEqual(a.y, true); + TestUtils.AreEqual(a.z, true); + TestUtils.AreEqual(a.w, true); + } + + [TestCompiler] + public static void bool4_static_constructor() + { + bool4 a = bool4(false, true, false, true); + TestUtils.AreEqual(a.x, false); + TestUtils.AreEqual(a.y, true); + TestUtils.AreEqual(a.z, false); + TestUtils.AreEqual(a.w, true); + } + + [TestCompiler] + public static void bool4_static_scalar_constructor() + { + bool4 a = bool4(true); + TestUtils.AreEqual(a.x, true); + TestUtils.AreEqual(a.y, true); + TestUtils.AreEqual(a.z, true); + TestUtils.AreEqual(a.w, true); + } + + [TestCompiler] + public static void bool4_operator_equal_wide_wide() + { + bool4 a0 = bool4(false, false, true, true); + bool4 b0 = bool4(false, true, true, false); + bool4 r0 = bool4(true, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool4 a1 = bool4(true, true, true, true); + bool4 b1 = bool4(true, true, false, true); + bool4 r1 = bool4(true, true, false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool4 a2 = bool4(true, true, true, true); + bool4 b2 = bool4(true, true, false, false); + bool4 r2 = bool4(true, true, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool4 a3 = bool4(true, false, false, false); + bool4 b3 = bool4(false, false, true, true); + bool4 r3 = bool4(false, true, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4_operator_equal_wide_scalar() + { + bool4 a0 = bool4(true, true, false, true); + bool b0 = (false); + bool4 r0 = bool4(false, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool4 a1 = bool4(true, true, true, true); + bool b1 = (false); + bool4 r1 = bool4(false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool4 a2 = bool4(false, false, false, true); + bool b2 = (false); + bool4 r2 = bool4(true, true, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool4 a3 = bool4(false, false, false, true); + bool b3 = (false); + bool4 r3 = bool4(true, true, true, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4_operator_equal_scalar_wide() + { + bool a0 = (true); + bool4 b0 = bool4(false, false, true, false); + bool4 r0 = bool4(false, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (true); + bool4 b1 = bool4(false, true, false, false); + bool4 r1 = bool4(false, true, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (false); + bool4 b2 = bool4(false, true, false, true); + bool4 r2 = bool4(true, false, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (true); + bool4 b3 = bool4(true, false, true, true); + bool4 r3 = bool4(true, false, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4_operator_not_equal_wide_wide() + { + bool4 a0 = bool4(true, false, false, true); + bool4 b0 = bool4(false, false, true, false); + bool4 r0 = bool4(true, false, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool4 a1 = bool4(true, true, true, true); + bool4 b1 = bool4(false, false, false, false); + bool4 r1 = bool4(true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool4 a2 = bool4(true, true, false, true); + bool4 b2 = bool4(true, true, false, false); + bool4 r2 = bool4(false, false, false, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool4 a3 = bool4(true, false, true, false); + bool4 b3 = bool4(false, false, false, true); + bool4 r3 = bool4(true, false, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4_operator_not_equal_wide_scalar() + { + bool4 a0 = bool4(false, false, true, true); + bool b0 = (false); + bool4 r0 = bool4(false, false, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool4 a1 = bool4(true, false, false, true); + bool b1 = (true); + bool4 r1 = bool4(false, true, true, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool4 a2 = bool4(false, false, true, false); + bool b2 = (true); + bool4 r2 = bool4(true, true, false, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool4 a3 = bool4(true, true, true, false); + bool b3 = (true); + bool4 r3 = bool4(false, false, false, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool4 b0 = bool4(true, true, false, true); + bool4 r0 = bool4(false, false, true, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool4 b1 = bool4(true, false, false, false); + bool4 r1 = bool4(true, false, false, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (true); + bool4 b2 = bool4(true, true, false, true); + bool4 r2 = bool4(false, false, true, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (true); + bool4 b3 = bool4(false, false, false, true); + bool4 r3 = bool4(true, true, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4_operator_bitwise_and_wide_wide() + { + bool4 a0 = bool4(false, true, true, false); + bool4 b0 = bool4(false, true, false, false); + bool4 r0 = bool4(false, true, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool4 a1 = bool4(false, false, true, false); + bool4 b1 = bool4(false, true, true, false); + bool4 r1 = bool4(false, false, true, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool4 a2 = bool4(true, true, false, true); + bool4 b2 = bool4(false, true, false, true); + bool4 r2 = bool4(false, true, false, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool4 a3 = bool4(false, false, true, false); + bool4 b3 = bool4(true, false, true, true); + bool4 r3 = bool4(false, false, true, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4_operator_bitwise_and_wide_scalar() + { + bool4 a0 = bool4(false, false, true, true); + bool b0 = (false); + bool4 r0 = bool4(false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool4 a1 = bool4(true, true, true, true); + bool b1 = (false); + bool4 r1 = bool4(false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool4 a2 = bool4(false, false, true, false); + bool b2 = (false); + bool4 r2 = bool4(false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool4 a3 = bool4(true, false, true, false); + bool b3 = (false); + bool4 r3 = bool4(false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool4 b0 = bool4(false, false, true, true); + bool4 r0 = bool4(false, false, true, true); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (false); + bool4 b1 = bool4(false, true, true, true); + bool4 r1 = bool4(false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (false); + bool4 b2 = bool4(true, false, true, true); + bool4 r2 = bool4(false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (false); + bool4 b3 = bool4(false, true, true, false); + bool4 r3 = bool4(false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4_operator_bitwise_or_wide_wide() + { + bool4 a0 = bool4(true, false, false, true); + bool4 b0 = bool4(true, false, true, true); + bool4 r0 = bool4(true, false, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool4 a1 = bool4(true, false, false, false); + bool4 b1 = bool4(true, true, true, true); + bool4 r1 = bool4(true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool4 a2 = bool4(false, false, true, true); + bool4 b2 = bool4(true, true, false, false); + bool4 r2 = bool4(true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool4 a3 = bool4(false, false, true, true); + bool4 b3 = bool4(true, true, true, true); + bool4 r3 = bool4(true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4_operator_bitwise_or_wide_scalar() + { + bool4 a0 = bool4(false, false, true, true); + bool b0 = (true); + bool4 r0 = bool4(true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool4 a1 = bool4(false, false, true, false); + bool b1 = (true); + bool4 r1 = bool4(true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool4 a2 = bool4(true, false, false, true); + bool b2 = (true); + bool4 r2 = bool4(true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool4 a3 = bool4(false, false, true, false); + bool b3 = (true); + bool4 r3 = bool4(true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool4 b0 = bool4(true, true, false, false); + bool4 r0 = bool4(true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (false); + bool4 b1 = bool4(false, true, true, false); + bool4 r1 = bool4(false, true, true, false); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (true); + bool4 b2 = bool4(true, false, false, false); + bool4 r2 = bool4(true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (false); + bool4 b3 = bool4(false, false, false, false); + bool4 r3 = bool4(false, false, false, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4_operator_bitwise_xor_wide_wide() + { + bool4 a0 = bool4(true, false, true, true); + bool4 b0 = bool4(false, true, false, false); + bool4 r0 = bool4(true, true, true, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool4 a1 = bool4(true, true, false, false); + bool4 b1 = bool4(false, true, false, false); + bool4 r1 = bool4(true, false, false, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool4 a2 = bool4(false, false, true, false); + bool4 b2 = bool4(true, true, true, false); + bool4 r2 = bool4(true, true, false, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool4 a3 = bool4(false, false, true, false); + bool4 b3 = bool4(false, false, true, true); + bool4 r3 = bool4(false, false, false, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4_operator_bitwise_xor_wide_scalar() + { + bool4 a0 = bool4(true, false, false, true); + bool b0 = (false); + bool4 r0 = bool4(true, false, false, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool4 a1 = bool4(true, false, false, true); + bool b1 = (false); + bool4 r1 = bool4(true, false, false, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool4 a2 = bool4(false, true, false, true); + bool b2 = (true); + bool4 r2 = bool4(true, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool4 a3 = bool4(true, false, false, false); + bool b3 = (false); + bool4 r3 = bool4(true, false, false, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool4 b0 = bool4(true, false, false, true); + bool4 r0 = bool4(false, true, true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (false); + bool4 b1 = bool4(true, true, true, true); + bool4 r1 = bool4(true, true, true, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (true); + bool4 b2 = bool4(true, true, true, true); + bool4 r2 = bool4(false, false, false, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (true); + bool4 b3 = bool4(true, false, true, false); + bool4 r3 = bool4(false, true, false, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4_operator_logical_not() + { + bool4 a0 = bool4(false, true, false, true); + bool4 r0 = bool4(true, false, true, false); + TestUtils.AreEqual(!a0, r0); + + bool4 a1 = bool4(false, false, true, true); + bool4 r1 = bool4(true, true, false, false); + TestUtils.AreEqual(!a1, r1); + + bool4 a2 = bool4(false, true, true, false); + bool4 r2 = bool4(true, false, false, true); + TestUtils.AreEqual(!a2, r2); + + bool4 a3 = bool4(false, true, false, false); + bool4 r3 = bool4(true, false, true, true); + 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/TestBool4.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/TestBool4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..0cecba96d383b7cf103118efbc07c4fe208925ca --- /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/TestBool4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 33a8df9e636ae004ba204e2a6b925b42 +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/TestBool4x2.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/TestBool4x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..e91b5ffe68ce67534b8b123d1669a07ca8d2e757 --- /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/TestBool4x2.gen.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool4x2 + { + [TestCompiler] + public static void bool4x2_operator_equal_wide_wide() + { + bool4x2 a0 = bool4x2(false, false, true, true, true, true, true, true); + bool4x2 b0 = bool4x2(false, true, true, false, true, true, false, true); + bool4x2 r0 = bool4x2(true, false, true, false, true, true, false, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool4x2 a1 = bool4x2(true, true, true, true, true, false, false, false); + bool4x2 b1 = bool4x2(true, true, false, false, false, false, true, true); + bool4x2 r1 = bool4x2(true, true, false, false, false, true, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool4x2 a2 = bool4x2(true, true, true, true, true, false, false, false); + bool4x2 b2 = bool4x2(true, true, true, false, false, true, false, true); + bool4x2 r2 = bool4x2(true, true, true, false, false, false, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool4x2 a3 = bool4x2(false, true, false, true, true, true, true, true); + bool4x2 b3 = bool4x2(false, true, true, false, false, true, false, false); + bool4x2 r3 = bool4x2(true, true, false, false, false, true, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_equal_wide_scalar() + { + bool4x2 a0 = bool4x2(true, true, false, true, true, false, true, true); + bool b0 = (false); + bool4x2 r0 = bool4x2(false, false, true, false, false, true, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool4x2 a1 = bool4x2(true, false, false, false, true, false, false, false); + bool b1 = (false); + bool4x2 r1 = bool4x2(false, true, true, true, false, true, true, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool4x2 a2 = bool4x2(false, true, false, false, true, false, true, false); + bool b2 = (true); + bool4x2 r2 = bool4x2(false, true, false, false, true, false, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool4x2 a3 = bool4x2(true, true, false, false, true, false, true, true); + bool b3 = (false); + bool4x2 r3 = bool4x2(false, false, true, true, false, true, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_equal_scalar_wide() + { + bool a0 = (true); + bool4x2 b0 = bool4x2(false, false, true, false, true, false, true, false); + bool4x2 r0 = bool4x2(false, false, true, false, true, false, true, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (false); + bool4x2 b1 = bool4x2(false, false, true, false, true, true, true, false); + bool4x2 r1 = bool4x2(true, true, false, true, false, false, false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (true); + bool4x2 b2 = bool4x2(true, false, false, true, false, false, true, false); + bool4x2 r2 = bool4x2(true, false, false, true, false, false, true, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (false); + bool4x2 b3 = bool4x2(true, false, false, true, false, true, true, true); + bool4x2 r3 = bool4x2(false, true, true, false, true, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_not_equal_wide_wide() + { + bool4x2 a0 = bool4x2(true, false, false, true, true, true, true, true); + bool4x2 b0 = bool4x2(false, false, true, false, false, false, false, false); + bool4x2 r0 = bool4x2(true, false, true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool4x2 a1 = bool4x2(true, true, false, true, true, false, true, false); + bool4x2 b1 = bool4x2(true, true, false, false, false, false, false, true); + bool4x2 r1 = bool4x2(false, false, false, true, true, false, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool4x2 a2 = bool4x2(false, true, true, true, false, true, false, false); + bool4x2 b2 = bool4x2(true, false, false, false, false, false, true, true); + bool4x2 r2 = bool4x2(true, true, true, true, false, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool4x2 a3 = bool4x2(false, true, true, true, false, false, true, false); + bool4x2 b3 = bool4x2(true, false, false, false, true, true, false, false); + bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_not_equal_wide_scalar() + { + bool4x2 a0 = bool4x2(false, false, true, true, true, true, false, false); + bool b0 = (false); + bool4x2 r0 = bool4x2(false, false, true, true, true, true, false, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool4x2 a1 = bool4x2(true, true, false, true, false, true, true, true); + bool b1 = (false); + bool4x2 r1 = bool4x2(true, true, false, true, false, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool4x2 a2 = bool4x2(true, false, true, true, true, true, false, false); + bool b2 = (false); + bool4x2 r2 = bool4x2(true, false, true, true, true, true, false, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool4x2 a3 = bool4x2(false, false, true, true, true, false, true, false); + bool b3 = (false); + bool4x2 r3 = bool4x2(false, false, true, true, true, false, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool4x2 b0 = bool4x2(true, true, false, true, false, true, false, false); + bool4x2 r0 = bool4x2(false, false, true, false, true, false, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool4x2 b1 = bool4x2(true, true, true, false, true, true, false, false); + bool4x2 r1 = bool4x2(true, true, true, false, true, true, false, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (false); + bool4x2 b2 = bool4x2(true, true, false, false, true, false, true, false); + bool4x2 r2 = bool4x2(true, true, false, false, true, false, true, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (false); + bool4x2 b3 = bool4x2(true, true, true, false, false, true, false, false); + bool4x2 r3 = bool4x2(true, true, true, false, false, true, false, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_bitwise_and_wide_wide() + { + bool4x2 a0 = bool4x2(false, true, true, false, false, false, true, false); + bool4x2 b0 = bool4x2(false, true, false, false, false, true, true, false); + bool4x2 r0 = bool4x2(false, true, false, false, false, false, true, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool4x2 a1 = bool4x2(true, true, false, true, false, false, true, false); + bool4x2 b1 = bool4x2(false, true, false, true, true, false, true, true); + bool4x2 r1 = bool4x2(false, true, false, true, false, false, true, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool4x2 a2 = bool4x2(false, false, false, true, false, true, true, false); + bool4x2 b2 = bool4x2(false, false, false, true, false, false, false, true); + bool4x2 r2 = bool4x2(false, false, false, true, false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool4x2 a3 = bool4x2(false, false, true, false, false, true, false, false); + bool4x2 b3 = bool4x2(true, false, false, false, true, false, false, true); + bool4x2 r3 = bool4x2(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_bitwise_and_wide_scalar() + { + bool4x2 a0 = bool4x2(false, false, true, true, true, false, true, true); + bool b0 = (false); + bool4x2 r0 = bool4x2(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool4x2 a1 = bool4x2(true, false, false, true, false, true, false, false); + bool b1 = (false); + bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool4x2 a2 = bool4x2(true, true, true, false, true, false, true, false); + bool b2 = (false); + bool4x2 r2 = bool4x2(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool4x2 a3 = bool4x2(true, true, false, false, true, false, false, true); + bool b3 = (true); + bool4x2 r3 = bool4x2(true, true, false, false, true, false, false, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool4x2 b0 = bool4x2(false, false, true, true, false, false, true, true); + bool4x2 r0 = bool4x2(false, false, true, true, false, false, true, true); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (true); + bool4x2 b1 = bool4x2(false, true, false, true, true, false, false, true); + bool4x2 r1 = bool4x2(false, true, false, true, true, false, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (true); + bool4x2 b2 = bool4x2(false, true, true, false, true, true, true, true); + bool4x2 r2 = bool4x2(false, true, true, false, true, true, true, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (true); + bool4x2 b3 = bool4x2(false, true, true, true, false, true, false, true); + bool4x2 r3 = bool4x2(false, true, true, true, false, true, false, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_bitwise_or_wide_wide() + { + bool4x2 a0 = bool4x2(true, false, false, true, true, false, false, false); + bool4x2 b0 = bool4x2(true, false, true, true, true, true, true, true); + bool4x2 r0 = bool4x2(true, false, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool4x2 a1 = bool4x2(false, false, true, true, false, false, true, true); + bool4x2 b1 = bool4x2(true, true, false, false, true, true, true, true); + bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool4x2 a2 = bool4x2(true, false, true, true, false, true, false, false); + bool4x2 b2 = bool4x2(true, true, false, false, false, false, true, false); + bool4x2 r2 = bool4x2(true, true, true, true, false, true, true, false); + TestUtils.AreEqual(a2 | b2, r2); + + bool4x2 a3 = bool4x2(false, false, true, false, true, false, false, true); + bool4x2 b3 = bool4x2(false, true, false, true, false, false, true, true); + bool4x2 r3 = bool4x2(false, true, true, true, true, false, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_bitwise_or_wide_scalar() + { + bool4x2 a0 = bool4x2(false, false, true, true, false, true, false, true); + bool b0 = (true); + bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool4x2 a1 = bool4x2(false, true, false, false, true, false, true, false); + bool b1 = (true); + bool4x2 r1 = bool4x2(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool4x2 a2 = bool4x2(true, false, false, true, true, false, true, true); + bool b2 = (false); + bool4x2 r2 = bool4x2(true, false, false, true, true, false, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool4x2 a3 = bool4x2(true, true, true, true, true, false, false, false); + bool b3 = (true); + bool4x2 r3 = bool4x2(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool4x2 b0 = bool4x2(true, true, false, false, false, false, true, true); + bool4x2 r0 = bool4x2(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (false); + bool4x2 b1 = bool4x2(true, true, false, false, false, false, false, false); + bool4x2 r1 = bool4x2(true, true, false, false, false, false, false, false); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (false); + bool4x2 b2 = bool4x2(false, true, false, true, true, true, true, true); + bool4x2 r2 = bool4x2(false, true, false, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (false); + bool4x2 b3 = bool4x2(true, false, false, true, true, false, false, false); + bool4x2 r3 = bool4x2(true, false, false, true, true, false, false, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_bitwise_xor_wide_wide() + { + bool4x2 a0 = bool4x2(true, false, true, true, true, true, false, false); + bool4x2 b0 = bool4x2(false, true, false, false, false, true, false, false); + bool4x2 r0 = bool4x2(true, true, true, true, true, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool4x2 a1 = bool4x2(false, false, true, false, false, false, true, false); + bool4x2 b1 = bool4x2(true, true, true, false, false, false, true, true); + bool4x2 r1 = bool4x2(true, true, false, false, false, false, false, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool4x2 a2 = bool4x2(true, false, false, false, true, true, true, true); + bool4x2 b2 = bool4x2(false, false, true, true, true, true, false, true); + bool4x2 r2 = bool4x2(true, false, true, true, false, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool4x2 a3 = bool4x2(true, false, true, true, false, false, true, false); + bool4x2 b3 = bool4x2(true, false, false, false, true, false, false, false); + bool4x2 r3 = bool4x2(false, false, true, true, true, false, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_bitwise_xor_wide_scalar() + { + bool4x2 a0 = bool4x2(true, false, false, true, true, false, false, false); + bool b0 = (false); + bool4x2 r0 = bool4x2(true, false, false, true, true, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool4x2 a1 = bool4x2(true, true, true, false, true, true, false, false); + bool b1 = (false); + bool4x2 r1 = bool4x2(true, true, true, false, true, true, false, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool4x2 a2 = bool4x2(false, false, false, false, false, false, true, true); + bool b2 = (false); + bool4x2 r2 = bool4x2(false, false, false, false, false, false, true, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool4x2 a3 = bool4x2(false, false, false, false, true, true, false, false); + bool b3 = (false); + bool4x2 r3 = bool4x2(false, false, false, false, true, true, false, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool4x2 b0 = bool4x2(true, false, false, true, false, true, true, true); + bool4x2 r0 = bool4x2(false, true, true, false, true, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (true); + bool4x2 b1 = bool4x2(true, true, true, true, true, true, true, false); + bool4x2 r1 = bool4x2(false, false, false, false, false, false, false, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (true); + bool4x2 b2 = bool4x2(false, true, false, false, false, false, true, false); + bool4x2 r2 = bool4x2(true, false, true, true, true, true, false, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (true); + bool4x2 b3 = bool4x2(false, true, true, false, true, false, false, false); + bool4x2 r3 = bool4x2(true, false, false, true, false, true, true, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4x2_operator_logical_not() + { + bool4x2 a0 = bool4x2(false, true, false, true, false, false, false, true); + bool4x2 r0 = bool4x2(true, false, true, false, true, true, true, false); + TestUtils.AreEqual(!a0, r0); + + bool4x2 a1 = bool4x2(true, true, true, true, false, false, false, true); + bool4x2 r1 = bool4x2(false, false, false, false, true, true, true, false); + TestUtils.AreEqual(!a1, r1); + + bool4x2 a2 = bool4x2(false, true, false, true, false, false, true, true); + bool4x2 r2 = bool4x2(true, false, true, false, true, true, false, false); + TestUtils.AreEqual(!a2, r2); + + bool4x2 a3 = bool4x2(true, true, true, false, true, false, false, true); + bool4x2 r3 = bool4x2(false, false, false, true, false, true, true, false); + 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/TestBool4x2.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/TestBool4x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1893ebc02e483c81d27713527f8cb274e38d9b3b --- /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/TestBool4x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: c7ec685ec2ccae14a851a50b1bcbebfa +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/TestBool4x3.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/TestBool4x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..aa0ad8b3e3cccd3cdf0c7b1a8a431f7770fa7946 --- /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/TestBool4x3.gen.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool4x3 + { + [TestCompiler] + public static void bool4x3_operator_equal_wide_wide() + { + bool4x3 a0 = bool4x3(false, false, true, true, true, true, true, true, true, true, true, true); + bool4x3 b0 = bool4x3(false, true, true, false, true, true, false, true, true, true, false, false); + bool4x3 r0 = bool4x3(true, false, true, false, true, true, false, true, true, true, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool4x3 a1 = bool4x3(true, false, false, false, true, true, true, true, true, false, false, false); + bool4x3 b1 = bool4x3(false, false, true, true, true, true, true, false, false, true, false, true); + bool4x3 r1 = bool4x3(false, true, false, false, true, true, true, false, false, false, true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool4x3 a2 = bool4x3(false, true, false, true, true, true, true, true, false, true, true, false); + bool4x3 b2 = bool4x3(false, true, true, false, false, true, false, false, false, true, true, false); + bool4x3 r2 = bool4x3(true, true, false, false, false, true, false, false, true, true, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool4x3 a3 = bool4x3(false, true, true, false, false, true, true, true, true, false, true, false); + bool4x3 b3 = bool4x3(true, false, true, true, false, true, false, false, false, true, true, false); + bool4x3 r3 = bool4x3(false, false, true, false, true, true, false, false, false, false, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_equal_wide_scalar() + { + bool4x3 a0 = bool4x3(true, true, false, true, true, false, true, true, true, false, false, false); + bool b0 = (false); + bool4x3 r0 = bool4x3(false, false, true, false, false, true, false, false, false, true, true, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool4x3 a1 = bool4x3(false, false, false, false, false, true, true, false, false, true, false, true); + bool b1 = (true); + bool4x3 r1 = bool4x3(false, false, false, false, false, true, true, false, false, true, false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool4x3 a2 = bool4x3(false, false, true, false, false, true, false, true, true, false, false, false); + bool b2 = (true); + bool4x3 r2 = bool4x3(false, false, true, false, false, true, false, true, true, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + bool4x3 a3 = bool4x3(false, true, false, true, true, false, false, false, true, true, true, false); + bool b3 = (false); + bool4x3 r3 = bool4x3(true, false, true, false, false, true, true, true, false, false, false, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_equal_scalar_wide() + { + bool a0 = (true); + bool4x3 b0 = bool4x3(false, false, true, false, true, false, true, false, false, false, false, true); + bool4x3 r0 = bool4x3(false, false, true, false, true, false, true, false, false, false, false, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (false); + bool4x3 b1 = bool4x3(true, true, true, false, true, true, false, false, true, false, false, true); + bool4x3 r1 = bool4x3(false, false, false, true, false, false, true, true, false, true, true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (false); + bool4x3 b2 = bool4x3(false, true, false, false, true, false, true, true, true, true, false, false); + bool4x3 r2 = bool4x3(true, false, true, true, false, true, false, false, false, false, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (true); + bool4x3 b3 = bool4x3(false, false, true, true, true, false, true, false, false, true, true, true); + bool4x3 r3 = bool4x3(false, false, true, true, true, false, true, false, false, true, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_not_equal_wide_wide() + { + bool4x3 a0 = bool4x3(true, false, false, true, true, true, true, true, true, true, false, true); + bool4x3 b0 = bool4x3(false, false, true, false, false, false, false, false, true, true, false, false); + bool4x3 r0 = bool4x3(true, false, true, true, true, true, true, true, false, false, false, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool4x3 a1 = bool4x3(true, false, true, false, false, true, true, true, false, true, false, false); + bool4x3 b1 = bool4x3(false, false, false, true, true, false, false, false, false, false, true, true); + bool4x3 r1 = bool4x3(true, false, true, true, true, true, true, true, false, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool4x3 a2 = bool4x3(false, true, true, true, false, false, true, false, false, true, false, true); + bool4x3 b2 = bool4x3(true, false, false, false, true, true, false, false, true, false, false, true); + bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, false, true, true, false, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool4x3 a3 = bool4x3(true, true, true, false, true, true, true, false, true, false, false, false); + bool4x3 b3 = bool4x3(true, true, true, false, false, true, false, false, false, true, true, true); + bool4x3 r3 = bool4x3(false, false, false, false, true, false, true, false, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_not_equal_wide_scalar() + { + bool4x3 a0 = bool4x3(false, false, true, true, true, true, false, false, true, false, true, false); + bool b0 = (false); + bool4x3 r0 = bool4x3(false, false, true, true, true, true, false, false, true, false, true, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool4x3 a1 = bool4x3(true, true, true, true, true, false, false, true, true, true, true, false); + bool b1 = (false); + bool4x3 r1 = bool4x3(true, true, true, true, true, false, false, true, true, true, true, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool4x3 a2 = bool4x3(false, false, false, true, true, true, false, true, false, true, true, true); + bool b2 = (false); + bool4x3 r2 = bool4x3(false, false, false, true, true, true, false, true, false, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool4x3 a3 = bool4x3(false, true, true, false, true, false, false, false, false, true, true, false); + bool b3 = (false); + bool4x3 r3 = bool4x3(false, true, true, false, true, false, false, false, false, true, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool4x3 b0 = bool4x3(true, true, false, true, false, true, false, false, false, true, true, true); + bool4x3 r0 = bool4x3(false, false, true, false, true, false, true, true, true, false, false, false); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool4x3 b1 = bool4x3(true, true, false, false, false, true, true, false, false, true, false, true); + bool4x3 r1 = bool4x3(true, true, false, false, false, true, true, false, false, true, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (false); + bool4x3 b2 = bool4x3(false, true, true, true, false, false, true, false, false, true, false, true); + bool4x3 r2 = bool4x3(false, true, true, true, false, false, true, false, false, true, false, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (false); + bool4x3 b3 = bool4x3(false, false, false, true, false, false, true, false, false, false, false, false); + bool4x3 r3 = bool4x3(false, false, false, true, false, false, true, false, false, false, false, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_bitwise_and_wide_wide() + { + bool4x3 a0 = bool4x3(false, true, true, false, false, false, true, false, true, true, false, true); + bool4x3 b0 = bool4x3(false, true, false, false, false, true, true, false, false, true, false, true); + bool4x3 r0 = bool4x3(false, true, false, false, false, false, true, false, false, true, false, true); + TestUtils.AreEqual(a0 & b0, r0); + + bool4x3 a1 = bool4x3(false, false, true, false, false, false, false, true, false, true, true, false); + bool4x3 b1 = bool4x3(true, false, true, true, false, false, false, true, false, false, false, true); + bool4x3 r1 = bool4x3(false, false, true, false, false, false, false, true, false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool4x3 a2 = bool4x3(false, false, true, false, false, true, false, false, true, true, true, false); + bool4x3 b2 = bool4x3(true, false, false, false, true, false, false, true, false, false, false, true); + bool4x3 r2 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool4x3 a3 = bool4x3(false, false, false, true, true, false, true, false, false, true, true, true); + bool4x3 b3 = bool4x3(true, true, false, true, false, false, false, true, false, false, true, true); + bool4x3 r3 = bool4x3(false, false, false, true, false, false, false, false, false, false, true, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_bitwise_and_wide_scalar() + { + bool4x3 a0 = bool4x3(false, false, true, true, true, false, true, true, true, false, false, false); + bool b0 = (false); + bool4x3 r0 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool4x3 a1 = bool4x3(true, true, false, false, true, false, true, true, false, true, false, true); + bool b1 = (false); + bool4x3 r1 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool4x3 a2 = bool4x3(false, true, true, false, false, true, false, false, true, false, true, true); + bool b2 = (true); + bool4x3 r2 = bool4x3(false, true, true, false, false, true, false, false, true, false, true, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool4x3 a3 = bool4x3(false, false, true, false, false, true, true, false, true, false, false, true); + bool b3 = (false); + bool4x3 r3 = bool4x3(false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool4x3 b0 = bool4x3(false, false, true, true, false, false, true, true, true, false, true, false); + bool4x3 r0 = bool4x3(false, false, true, true, false, false, true, true, true, false, true, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (true); + bool4x3 b1 = bool4x3(true, false, false, true, true, false, true, true, false, true, true, true); + bool4x3 r1 = bool4x3(true, false, false, true, true, false, true, true, false, true, true, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (true); + bool4x3 b2 = bool4x3(true, false, true, true, true, false, true, false, true, false, true, false); + bool4x3 r2 = bool4x3(true, false, true, true, true, false, true, false, true, false, true, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (true); + bool4x3 b3 = bool4x3(true, true, false, true, true, false, true, false, false, false, true, true); + bool4x3 r3 = bool4x3(true, true, false, true, true, false, true, false, false, false, true, true); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_bitwise_or_wide_wide() + { + bool4x3 a0 = bool4x3(true, false, false, true, true, false, false, false, false, false, true, true); + bool4x3 b0 = bool4x3(true, false, true, true, true, true, true, true, true, true, false, false); + bool4x3 r0 = bool4x3(true, false, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool4x3 a1 = bool4x3(false, false, true, true, true, false, true, true, false, true, false, false); + bool4x3 b1 = bool4x3(true, true, true, true, true, true, false, false, false, false, true, false); + bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, false, true, true, false); + TestUtils.AreEqual(a1 | b1, r1); + + bool4x3 a2 = bool4x3(false, false, true, false, true, false, false, true, false, false, false, true); + bool4x3 b2 = bool4x3(false, true, false, true, false, false, true, true, true, true, true, false); + bool4x3 r2 = bool4x3(false, true, true, true, true, false, true, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool4x3 a3 = bool4x3(false, false, false, false, false, true, false, true, true, true, true, false); + bool4x3 b3 = bool4x3(true, true, true, true, true, true, true, false, true, true, false, false); + bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_bitwise_or_wide_scalar() + { + bool4x3 a0 = bool4x3(false, false, true, true, false, true, false, true, false, true, true, false); + bool b0 = (true); + bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool4x3 a1 = bool4x3(false, false, true, false, true, false, false, false, true, true, false, true); + bool b1 = (true); + bool4x3 r1 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool4x3 a2 = bool4x3(true, true, true, true, true, true, false, false, false, true, false, false); + bool b2 = (true); + bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool4x3 a3 = bool4x3(true, true, true, false, false, false, false, true, true, true, true, false); + bool b3 = (true); + bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool4x3 b0 = bool4x3(true, true, false, false, false, false, true, true, false, true, true, false); + bool4x3 r0 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (false); + bool4x3 b1 = bool4x3(false, false, false, false, false, false, true, false, true, true, true, true); + bool4x3 r1 = bool4x3(false, false, false, false, false, false, true, false, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (true); + bool4x3 b2 = bool4x3(false, true, false, false, true, true, false, false, false, true, false, true); + bool4x3 r2 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (true); + bool4x3 b3 = bool4x3(false, true, false, false, true, true, true, false, false, true, true, true); + bool4x3 r3 = bool4x3(true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_bitwise_xor_wide_wide() + { + bool4x3 a0 = bool4x3(true, false, true, true, true, true, false, false, false, false, true, false); + bool4x3 b0 = bool4x3(false, true, false, false, false, true, false, false, true, true, true, false); + bool4x3 r0 = bool4x3(true, true, true, true, true, false, false, false, true, true, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool4x3 a1 = bool4x3(false, false, true, false, true, false, false, false, true, true, true, true); + bool4x3 b1 = bool4x3(false, false, true, true, false, false, true, true, true, true, false, true); + bool4x3 r1 = bool4x3(false, false, false, true, true, false, true, true, false, false, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool4x3 a2 = bool4x3(true, false, true, true, false, false, true, false, false, true, true, true); + bool4x3 b2 = bool4x3(true, false, false, false, true, false, false, false, false, false, true, false); + bool4x3 r2 = bool4x3(false, false, true, true, true, false, true, false, false, true, false, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool4x3 a3 = bool4x3(true, false, true, true, true, true, false, true, false, true, false, true); + bool4x3 b3 = bool4x3(true, true, false, false, false, false, true, false, false, false, true, false); + bool4x3 r3 = bool4x3(false, true, true, true, true, true, true, true, false, true, true, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_bitwise_xor_wide_scalar() + { + bool4x3 a0 = bool4x3(true, false, false, true, true, false, false, false, true, false, true, true); + bool b0 = (false); + bool4x3 r0 = bool4x3(true, false, false, true, true, false, false, false, true, false, true, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool4x3 a1 = bool4x3(false, true, false, false, false, false, false, false, false, false, false, true); + bool b1 = (true); + bool4x3 r1 = bool4x3(true, false, true, true, true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool4x3 a2 = bool4x3(true, false, false, false, false, true, true, false, false, false, true, false); + bool b2 = (false); + bool4x3 r2 = bool4x3(true, false, false, false, false, true, true, false, false, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool4x3 a3 = bool4x3(false, true, false, true, true, false, false, true, true, true, false, true); + bool b3 = (false); + bool4x3 r3 = bool4x3(false, true, false, true, true, false, false, true, true, true, false, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool4x3 b0 = bool4x3(true, false, false, true, false, true, true, true, true, true, true, true); + bool4x3 r0 = bool4x3(false, true, true, false, true, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (true); + bool4x3 b1 = bool4x3(true, true, true, false, true, false, true, false, false, false, false, true); + bool4x3 r1 = bool4x3(false, false, false, true, false, true, false, true, true, true, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (false); + bool4x3 b2 = bool4x3(true, false, true, true, false, true, false, false, false, false, true, false); + bool4x3 r2 = bool4x3(true, false, true, true, false, true, false, false, false, false, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (false); + bool4x3 b3 = bool4x3(false, false, false, true, false, false, true, true, false, false, true, false); + bool4x3 r3 = bool4x3(false, false, false, true, false, false, true, true, false, false, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4x3_operator_logical_not() + { + bool4x3 a0 = bool4x3(false, true, false, true, false, false, false, true, true, false, true, true); + bool4x3 r0 = bool4x3(true, false, true, false, true, true, true, false, false, true, false, false); + TestUtils.AreEqual(!a0, r0); + + bool4x3 a1 = bool4x3(true, false, false, true, false, false, true, false, true, false, false, true); + bool4x3 r1 = bool4x3(false, true, true, false, true, true, false, true, false, true, true, false); + TestUtils.AreEqual(!a1, r1); + + bool4x3 a2 = bool4x3(true, true, true, true, false, true, false, false, true, false, false, false); + bool4x3 r2 = bool4x3(false, false, false, false, true, false, true, true, false, true, true, true); + TestUtils.AreEqual(!a2, r2); + + bool4x3 a3 = bool4x3(true, false, false, false, false, true, false, true, true, true, false, true); + bool4x3 r3 = bool4x3(false, true, true, true, true, false, true, false, false, false, true, false); + 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/TestBool4x3.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/TestBool4x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..95824aa2610602cef5c864d3baa6f0d0d618f6fb --- /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/TestBool4x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 58c624ce115ab234d9a595288af4c5e0 +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/TestBool4x4.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/TestBool4x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..b0eead2ad00827fc6ecdf5fc70a25a4ca19bcd0b --- /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/TestBool4x4.gen.cs @@ -0,0 +1,400 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestBool4x4 + { + [TestCompiler] + public static void bool4x4_operator_equal_wide_wide() + { + bool4x4 a0 = bool4x4(false, false, true, true, true, true, true, true, true, true, true, true, true, false, false, false); + bool4x4 b0 = bool4x4(false, true, true, false, true, true, false, true, true, true, false, false, false, false, true, true); + bool4x4 r0 = bool4x4(true, false, true, false, true, true, false, true, true, true, false, false, false, true, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + bool4x4 a1 = bool4x4(true, true, true, true, true, false, false, false, false, true, false, true, true, true, true, true); + bool4x4 b1 = bool4x4(true, true, true, false, false, true, false, true, false, true, true, false, false, true, false, false); + bool4x4 r1 = bool4x4(true, true, true, false, false, false, true, false, true, true, false, false, false, true, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool4x4 a2 = bool4x4(false, true, true, false, false, true, true, false, false, true, true, true, true, false, true, false); + bool4x4 b2 = bool4x4(false, true, true, false, true, false, true, true, false, true, false, false, false, true, true, false); + bool4x4 r2 = bool4x4(true, true, true, true, false, false, true, false, true, true, false, false, false, false, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool4x4 a3 = bool4x4(false, false, false, false, false, true, true, false, false, true, true, false, false, true, true, false); + bool4x4 b3 = bool4x4(false, false, false, true, true, false, false, false, false, false, false, false, true, true, false, false); + bool4x4 r3 = bool4x4(true, true, true, false, false, false, false, true, true, false, false, true, false, true, false, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_equal_wide_scalar() + { + bool4x4 a0 = bool4x4(true, true, false, true, true, false, true, true, true, false, false, false, false, true, false, false); + bool b0 = (false); + bool4x4 r0 = bool4x4(false, false, true, false, false, true, false, false, false, true, true, true, true, false, true, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool4x4 a1 = bool4x4(false, true, true, false, false, true, false, true, false, true, false, true, false, false, true, false); + bool b1 = (false); + bool4x4 r1 = bool4x4(true, false, false, true, true, false, true, false, true, false, true, false, true, true, false, true); + TestUtils.AreEqual(a1 == b1, r1); + + bool4x4 a2 = bool4x4(true, false, false, false, false, false, true, false, true, true, false, false, false, true, true, true); + bool b2 = (true); + bool4x4 r2 = bool4x4(true, false, false, false, false, false, true, false, true, true, false, false, false, true, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool4x4 a3 = bool4x4(false, true, false, false, false, false, true, true, true, true, true, false, true, false, true, false); + bool b3 = (false); + bool4x4 r3 = bool4x4(true, false, true, true, true, true, false, false, false, false, false, true, false, true, false, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_equal_scalar_wide() + { + bool a0 = (true); + bool4x4 b0 = bool4x4(false, false, true, false, true, false, true, false, false, false, false, true, false, true, true, true); + bool4x4 r0 = bool4x4(false, false, true, false, true, false, true, false, false, false, false, true, false, true, true, true); + TestUtils.AreEqual(a0 == b0, r0); + + bool a1 = (false); + bool4x4 b1 = bool4x4(true, true, false, false, true, false, false, true, false, false, true, false, false, true, false, true); + bool4x4 r1 = bool4x4(false, false, true, true, false, true, true, false, true, true, false, true, true, false, true, false); + TestUtils.AreEqual(a1 == b1, r1); + + bool a2 = (true); + bool4x4 b2 = bool4x4(true, true, false, false, true, false, false, true, true, true, false, true, false, false, true, true); + bool4x4 r2 = bool4x4(true, true, false, false, true, false, false, true, true, true, false, true, false, false, true, true); + TestUtils.AreEqual(a2 == b2, r2); + + bool a3 = (true); + bool4x4 b3 = bool4x4(false, true, false, false, false, true, false, false, true, false, false, true, false, true, true, true); + bool4x4 r3 = bool4x4(false, true, false, false, false, true, false, false, true, false, false, true, false, true, true, true); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_not_equal_wide_wide() + { + bool4x4 a0 = bool4x4(true, false, false, true, true, true, true, true, true, true, false, true, true, false, true, false); + bool4x4 b0 = bool4x4(false, false, true, false, false, false, false, false, true, true, false, false, false, false, false, true); + bool4x4 r0 = bool4x4(true, false, true, true, true, true, true, true, false, false, false, true, true, false, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool4x4 a1 = bool4x4(false, true, true, true, false, true, false, false, false, true, true, true, false, false, true, false); + bool4x4 b1 = bool4x4(true, false, false, false, false, false, true, true, true, false, false, false, true, true, false, false); + bool4x4 r1 = bool4x4(true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a1 != b1, r1); + + bool4x4 a2 = bool4x4(false, true, false, true, true, true, true, false, true, true, true, false, true, false, false, false); + bool4x4 b2 = bool4x4(true, false, false, true, true, true, true, false, false, true, false, false, false, true, true, true); + bool4x4 r2 = bool4x4(true, true, false, false, false, false, false, false, true, false, true, false, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool4x4 a3 = bool4x4(true, false, true, false, false, false, true, false, true, false, false, true, true, true, false, false); + bool4x4 b3 = bool4x4(false, false, true, false, false, true, true, false, true, true, true, true, true, true, false, true); + bool4x4 r3 = bool4x4(true, false, false, false, false, true, false, false, false, true, true, false, false, false, false, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_not_equal_wide_scalar() + { + bool4x4 a0 = bool4x4(false, false, true, true, true, true, false, false, true, false, true, false, true, false, true, true); + bool b0 = (false); + bool4x4 r0 = bool4x4(false, false, true, true, true, true, false, false, true, false, true, false, true, false, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool4x4 a1 = bool4x4(true, false, false, true, true, true, true, false, false, false, false, false, true, true, true, false); + bool b1 = (true); + bool4x4 r1 = bool4x4(false, true, true, false, false, false, false, true, true, true, true, true, false, false, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool4x4 a2 = bool4x4(true, true, true, true, false, false, true, true, false, true, false, false, false, false, true, true); + bool b2 = (false); + bool4x4 r2 = bool4x4(true, true, true, true, false, false, true, true, false, true, false, false, false, false, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + bool4x4 a3 = bool4x4(false, true, true, true, false, true, true, true, true, false, false, false, false, true, false, true); + bool b3 = (true); + bool4x4 r3 = bool4x4(true, false, false, false, true, false, false, false, false, true, true, true, true, false, true, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_not_equal_scalar_wide() + { + bool a0 = (true); + bool4x4 b0 = bool4x4(true, true, false, true, false, true, false, false, false, true, true, true, false, true, true, false); + bool4x4 r0 = bool4x4(false, false, true, false, true, false, true, true, true, false, false, false, true, false, false, true); + TestUtils.AreEqual(a0 != b0, r0); + + bool a1 = (false); + bool4x4 b1 = bool4x4(false, true, true, false, false, true, false, true, false, false, true, true, true, false, false, true); + bool4x4 r1 = bool4x4(false, true, true, false, false, true, false, true, false, false, true, true, true, false, false, true); + TestUtils.AreEqual(a1 != b1, r1); + + bool a2 = (false); + bool4x4 b2 = bool4x4(false, true, false, true, false, false, false, false, true, false, false, true, false, false, false, false); + bool4x4 r2 = bool4x4(false, true, false, true, false, false, false, false, true, false, false, true, false, false, false, false); + TestUtils.AreEqual(a2 != b2, r2); + + bool a3 = (false); + bool4x4 b3 = bool4x4(true, true, true, false, true, true, true, true, false, true, false, true, false, false, false, false); + bool4x4 r3 = bool4x4(true, true, true, false, true, true, true, true, false, true, false, true, false, false, false, false); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_bitwise_and_wide_wide() + { + bool4x4 a0 = bool4x4(false, true, true, false, false, false, true, false, true, true, false, true, false, false, true, false); + bool4x4 b0 = bool4x4(false, true, false, false, false, true, true, false, false, true, false, true, true, false, true, true); + bool4x4 r0 = bool4x4(false, true, false, false, false, false, true, false, false, true, false, true, false, false, true, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool4x4 a1 = bool4x4(false, false, false, true, false, true, true, false, false, false, true, false, false, true, false, false); + bool4x4 b1 = bool4x4(false, false, false, true, false, false, false, true, true, false, false, false, true, false, false, true); + bool4x4 r1 = bool4x4(false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool4x4 a2 = bool4x4(true, true, true, false, false, false, false, true, true, false, true, false, false, true, true, true); + bool4x4 b2 = bool4x4(false, false, false, true, true, true, false, true, false, false, false, true, false, false, true, true); + bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, true, false, false, false, false, false, false, true, true); + TestUtils.AreEqual(a2 & b2, r2); + + bool4x4 a3 = bool4x4(false, true, true, false, true, true, true, true, false, false, false, false, true, false, false, false); + bool4x4 b3 = bool4x4(false, false, true, false, false, true, false, true, true, true, false, false, false, false, true, true); + bool4x4 r3 = bool4x4(false, false, true, false, false, true, false, true, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_bitwise_and_wide_scalar() + { + bool4x4 a0 = bool4x4(false, false, true, true, true, false, true, true, true, false, false, false, true, false, true, false); + bool b0 = (false); + bool4x4 r0 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool4x4 a1 = bool4x4(false, false, true, true, false, true, false, true, false, true, true, true, false, false, true, false); + bool b1 = (true); + bool4x4 r1 = bool4x4(false, false, true, true, false, true, false, true, false, true, true, true, false, false, true, false); + TestUtils.AreEqual(a1 & b1, r1); + + bool4x4 a2 = bool4x4(false, false, true, true, false, false, false, true, false, false, true, true, false, true, false, false); + bool b2 = (true); + bool4x4 r2 = bool4x4(false, false, true, true, false, false, false, true, false, false, true, true, false, true, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool4x4 a3 = bool4x4(true, false, false, true, true, false, true, false, false, false, false, true, false, true, true, false); + bool b3 = (false); + 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 bool4x4_operator_bitwise_and_scalar_wide() + { + bool a0 = (true); + bool4x4 b0 = bool4x4(false, false, true, true, false, false, true, true, true, false, true, false, true, true, false, false); + bool4x4 r0 = bool4x4(false, false, true, true, false, false, true, true, true, false, true, false, true, true, false, false); + TestUtils.AreEqual(a0 & b0, r0); + + bool a1 = (true); + bool4x4 b1 = bool4x4(true, false, true, true, false, true, true, true, true, true, false, true, true, true, false, true); + bool4x4 r1 = bool4x4(true, false, true, true, false, true, true, true, true, true, false, true, true, true, false, true); + TestUtils.AreEqual(a1 & b1, r1); + + bool a2 = (false); + bool4x4 b2 = bool4x4(true, false, true, false, true, true, true, false, true, true, false, true, false, false, false, true); + bool4x4 r2 = bool4x4(false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 & b2, r2); + + bool a3 = (true); + bool4x4 b3 = bool4x4(true, false, true, true, false, false, true, false, true, true, true, false, true, true, false, false); + bool4x4 r3 = bool4x4(true, false, true, true, false, false, true, false, true, true, true, false, true, true, false, false); + TestUtils.AreEqual(a3 & b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_bitwise_or_wide_wide() + { + bool4x4 a0 = bool4x4(true, false, false, true, true, false, false, false, false, false, true, true, false, false, true, true); + bool4x4 b0 = bool4x4(true, false, true, true, true, true, true, true, true, true, false, false, true, true, true, true); + bool4x4 r0 = bool4x4(true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool4x4 a1 = bool4x4(true, false, true, true, false, true, false, false, false, false, true, false, true, false, false, true); + bool4x4 b1 = bool4x4(true, true, false, false, false, false, true, false, false, true, false, true, false, false, true, true); + bool4x4 r1 = bool4x4(true, true, true, true, false, true, true, false, false, true, true, true, true, false, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool4x4 a2 = bool4x4(false, false, false, true, false, false, false, false, false, true, false, true, true, true, true, false); + bool4x4 b2 = bool4x4(true, true, true, false, true, true, true, true, true, true, true, false, true, true, false, false); + bool4x4 r2 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a2 | b2, r2); + + bool4x4 a3 = bool4x4(false, false, false, true, false, true, true, false, true, false, false, false, false, false, true, false); + bool4x4 b3 = bool4x4(false, false, true, true, false, false, false, false, true, false, false, false, true, true, true, false); + bool4x4 r3 = bool4x4(false, false, true, true, false, true, true, false, true, false, false, false, true, true, true, false); + TestUtils.AreEqual(a3 | b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_bitwise_or_wide_scalar() + { + bool4x4 a0 = bool4x4(false, false, true, true, false, true, false, true, false, true, true, false, false, true, false, true); + bool b0 = (true); + bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool4x4 a1 = bool4x4(false, false, false, false, true, true, false, true, true, true, true, true, true, true, true, false); + bool b1 = (true); + bool4x4 r1 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 | b1, r1); + + bool4x4 a2 = bool4x4(false, true, false, false, true, true, true, true, false, false, false, false, true, true, true, true); + bool b2 = (false); + bool4x4 r2 = bool4x4(false, true, false, false, true, true, true, true, false, false, false, false, true, true, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool4x4 a3 = bool4x4(false, false, true, false, false, false, true, true, false, true, true, false, true, false, true, false); + bool b3 = (true); + 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 bool4x4_operator_bitwise_or_scalar_wide() + { + bool a0 = (true); + bool4x4 b0 = bool4x4(true, true, false, false, false, false, true, true, false, true, true, false, false, false, false, false); + bool4x4 r0 = bool4x4(true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 | b0, r0); + + bool a1 = (false); + bool4x4 b1 = bool4x4(false, false, true, false, true, true, true, true, true, false, true, false, false, true, true, false); + bool4x4 r1 = bool4x4(false, false, true, false, true, true, true, true, true, false, true, false, false, true, true, false); + TestUtils.AreEqual(a1 | b1, r1); + + bool a2 = (false); + bool4x4 b2 = bool4x4(false, true, false, true, true, false, true, false, false, true, true, true, false, false, true, true); + bool4x4 r2 = bool4x4(false, true, false, true, true, false, true, false, false, true, true, true, false, false, true, true); + TestUtils.AreEqual(a2 | b2, r2); + + bool a3 = (true); + bool4x4 b3 = bool4x4(true, true, true, false, true, true, true, true, true, false, true, true, false, true, false, true); + 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 bool4x4_operator_bitwise_xor_wide_wide() + { + bool4x4 a0 = bool4x4(true, false, true, true, true, true, false, false, false, false, true, false, false, false, true, false); + bool4x4 b0 = bool4x4(false, true, false, false, false, true, false, false, true, true, true, false, false, false, true, true); + bool4x4 r0 = bool4x4(true, true, true, true, true, false, false, false, true, true, false, false, false, false, false, true); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool4x4 a1 = bool4x4(true, false, false, false, true, true, true, true, true, false, true, true, false, false, true, false); + bool4x4 b1 = bool4x4(false, false, true, true, true, true, false, true, true, false, false, false, true, false, false, false); + bool4x4 r1 = bool4x4(true, false, true, true, false, false, true, false, false, false, true, true, true, false, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool4x4 a2 = bool4x4(false, true, true, true, true, false, true, true, true, true, false, true, false, true, false, true); + bool4x4 b2 = bool4x4(false, false, true, false, true, true, false, false, false, false, true, false, false, false, true, false); + bool4x4 r2 = bool4x4(false, true, false, true, false, true, true, true, true, true, true, true, false, true, true, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool4x4 a3 = bool4x4(true, true, false, true, true, true, false, false, false, true, true, true, false, true, false, false); + bool4x4 b3 = bool4x4(true, false, true, false, true, false, true, false, false, true, true, false, true, true, true, true); + bool4x4 r3 = bool4x4(false, true, true, true, false, true, true, false, false, false, false, true, true, false, true, true); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_bitwise_xor_wide_scalar() + { + bool4x4 a0 = bool4x4(true, false, false, true, true, false, false, false, true, false, true, true, false, true, true, false); + bool b0 = (false); + bool4x4 r0 = bool4x4(true, false, false, true, true, false, false, false, true, false, true, true, false, true, true, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool4x4 a1 = bool4x4(false, false, false, false, false, false, false, true, true, false, false, false, false, false, true, true); + bool b1 = (false); + bool4x4 r1 = bool4x4(false, false, false, false, false, false, false, true, true, false, false, false, false, false, true, true); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool4x4 a2 = bool4x4(false, false, true, false, false, false, true, false, true, true, false, false, true, true, true, false); + bool b2 = (false); + bool4x4 r2 = bool4x4(false, false, true, false, false, false, true, false, true, true, false, false, true, true, true, false); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool4x4 a3 = bool4x4(true, false, false, true, true, true, false, false, true, true, true, true, false, true, true, false); + bool b3 = (false); + bool4x4 r3 = bool4x4(true, false, false, true, true, true, false, false, true, true, true, true, false, true, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_bitwise_xor_scalar_wide() + { + bool a0 = (true); + bool4x4 b0 = bool4x4(true, false, false, true, false, true, true, true, true, true, true, true, true, true, true, true); + bool4x4 r0 = bool4x4(false, true, true, false, true, false, false, false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 ^ b0, r0); + + bool a1 = (false); + bool4x4 b1 = bool4x4(true, false, true, false, false, false, false, true, false, true, false, true, true, false, true, false); + bool4x4 r1 = bool4x4(true, false, true, false, false, false, false, true, false, true, false, true, true, false, true, false); + TestUtils.AreEqual(a1 ^ b1, r1); + + bool a2 = (false); + bool4x4 b2 = bool4x4(false, false, true, false, false, false, false, false, true, false, false, true, true, false, false, true); + bool4x4 r2 = bool4x4(false, false, true, false, false, false, false, false, true, false, false, true, true, false, false, true); + TestUtils.AreEqual(a2 ^ b2, r2); + + bool a3 = (false); + bool4x4 b3 = bool4x4(true, false, false, false, false, false, false, false, true, true, true, true, false, false, true, false); + bool4x4 r3 = bool4x4(true, false, false, false, false, false, false, false, true, true, true, true, false, false, true, false); + TestUtils.AreEqual(a3 ^ b3, r3); + } + + [TestCompiler] + public static void bool4x4_operator_logical_not() + { + bool4x4 a0 = bool4x4(false, true, false, true, false, false, false, true, true, false, true, true, true, false, false, false); + bool4x4 r0 = bool4x4(true, false, true, false, true, true, true, false, false, true, false, false, false, true, true, true); + TestUtils.AreEqual(!a0, r0); + + bool4x4 a1 = bool4x4(true, false, true, false, true, false, false, true, true, true, true, true, true, false, true, false); + bool4x4 r1 = bool4x4(false, true, false, true, false, true, true, false, false, false, false, false, false, true, false, true); + TestUtils.AreEqual(!a1, r1); + + bool4x4 a2 = bool4x4(false, false, false, false, true, true, false, false, false, false, true, false, true, true, true, false); + bool4x4 r2 = bool4x4(true, true, true, true, false, false, true, true, true, true, false, true, false, false, false, true); + TestUtils.AreEqual(!a2, r2); + + bool4x4 a3 = bool4x4(true, false, true, true, true, false, true, false, true, true, false, true, true, false, true, true); + bool4x4 r3 = bool4x4(false, true, false, false, false, true, false, true, false, false, true, false, false, true, false, false); + 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/TestBool4x4.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/TestBool4x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..65dfed00d3104cd79f938f2eacc2374b495d53ec --- /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/TestBool4x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0d44f89a4f95a124b9fc8296247d76d9 +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/TestDouble2.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/TestDouble2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..64be2a11638d61f762c30c2eb1de1ebb8ffaceed --- /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/TestDouble2.gen.cs @@ -0,0 +1,1055 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestDouble2 + { + [TestCompiler] + public static void double2_zero() + { + TestUtils.AreEqual(double2.zero.x, 0.0); + TestUtils.AreEqual(double2.zero.y, 0.0); + } + + [TestCompiler] + public static void double2_constructor() + { + double2 a = new double2(1, 2); + TestUtils.AreEqual(a.x, 1); + TestUtils.AreEqual(a.y, 2); + } + + [TestCompiler] + public static void double2_scalar_constructor() + { + double2 a = new double2(17.0); + TestUtils.AreEqual(a.x, 17.0); + TestUtils.AreEqual(a.y, 17.0); + } + + [TestCompiler] + public static void double2_static_constructor() + { + double2 a = double2(1, 2); + TestUtils.AreEqual(a.x, 1); + TestUtils.AreEqual(a.y, 2); + } + + [TestCompiler] + public static void double2_static_scalar_constructor() + { + double2 a = double2(17.0); + TestUtils.AreEqual(a.x, 17.0); + TestUtils.AreEqual(a.y, 17.0); + } + + [TestCompiler] + public static void double2_operator_equal_wide_wide() + { + double2 a0 = double2(-135.18925172425304, -49.094127439471947); + double2 b0 = double2(-220.01464591734793, 66.980020792679852); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double2 a1 = double2(169.12980778940482, 240.80529772527757); + double2 b1 = double2(499.20158576369363, -371.113114291389); + bool2 r1 = bool2(false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double2 a2 = double2(314.73919382446411, 442.39301916695808); + double2 b2 = double2(208.44865212610398, 390.80369133074009); + bool2 r2 = bool2(false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double2 a3 = double2(177.92444881141398, 335.53340283759564); + double2 b3 = double2(-72.443806920407269, 362.97643273089841); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2_operator_equal_wide_scalar() + { + double2 a0 = double2(65.671194345537174, 404.41550440546848); + double b0 = (-155.8157547245807); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double2 a1 = double2(-269.7301577393572, 152.99450476141385); + double b1 = (83.630607882342588); + bool2 r1 = bool2(false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double2 a2 = double2(-155.86829836474186, 386.36515325417986); + double b2 = (314.67125597348024); + bool2 r2 = bool2(false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double2 a3 = double2(290.04894007837811, -65.667489797653388); + double b3 = (-132.63519460178691); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2_operator_equal_scalar_wide() + { + double a0 = (36.383921878591195); + double2 b0 = double2(-400.48919958644046, -71.286823544319191); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double a1 = (156.97811491646712); + double2 b1 = double2(-225.23872791288363, 499.14180993435059); + bool2 r1 = bool2(false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double a2 = (-211.97992358542047); + double2 b2 = double2(428.31192394174263, -489.50133322621758); + bool2 r2 = bool2(false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double a3 = (-5.6915457275190988); + double2 b3 = double2(-30.865948453017495, -362.98307221149241); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2_operator_not_equal_wide_wide() + { + double2 a0 = double2(279.99414576217259, -43.342018386042696); + double2 b0 = double2(-460.912120318465, -476.00904844515446); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double2 a1 = double2(-465.72473523846116, 317.46655645848557); + double2 b1 = double2(468.13642070635058, -341.01254312182431); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double2 a2 = double2(85.714987079480238, 360.89050572034466); + double2 b2 = double2(-62.658060341448561, -458.80166718866752); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double2 a3 = double2(366.08152668833804, 154.5428384070018); + double2 b3 = double2(-457.73023316717251, -59.523265627922171); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2_operator_not_equal_wide_scalar() + { + double2 a0 = double2(-155.44111282911206, -19.426602134214079); + double b0 = (-393.41354173860213); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double2 a1 = double2(174.63305409934048, 59.177048472304364); + double b1 = (507.9207296352464); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double2 a2 = double2(171.15146430356026, -398.17684835855704); + double b2 = (-58.923273352404692); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double2 a3 = double2(492.20105361016522, 270.34102333259818); + double b3 = (-165.24150879925185); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2_operator_not_equal_scalar_wide() + { + double a0 = (478.35313938481409); + double2 b0 = double2(459.55319592894671, 436.45324369727314); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double a1 = (-488.71416806090349); + double2 b1 = double2(392.76794475725296, -266.73665369056937); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double a2 = (338.55788270503183); + double2 b2 = double2(-338.10012475498957, -152.3145445102428); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double a3 = (-452.82067868338); + double2 b3 = double2(209.43931422449612, 50.107968592135194); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2_operator_less_wide_wide() + { + double2 a0 = double2(51.710243010758518, -313.85556450200062); + double2 b0 = double2(-261.83523881707117, -19.810742149041403); + bool2 r0 = bool2(false, true); + TestUtils.AreEqual(a0 < b0, r0); + + double2 a1 = double2(283.04767359562572, 235.02188621974642); + double2 b1 = double2(-149.25882084167506, 205.99822316225539); + bool2 r1 = bool2(false, false); + TestUtils.AreEqual(a1 < b1, r1); + + double2 a2 = double2(44.0783565249659, -207.25566659088042); + double2 b2 = double2(-306.02438535635565, 102.12168006884008); + bool2 r2 = bool2(false, true); + TestUtils.AreEqual(a2 < b2, r2); + + double2 a3 = double2(3.3829410091894943, -144.30134326978651); + double2 b3 = double2(231.90633760760829, 179.49885305180158); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2_operator_less_wide_scalar() + { + double2 a0 = double2(-221.86977325280651, -121.54646807608498); + double b0 = (199.06751808853244); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 < b0, r0); + + double2 a1 = double2(-97.52392511140738, 67.118990214131259); + double b1 = (479.88107775146193); + bool2 r1 = bool2(true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double2 a2 = double2(137.32880574899207, 258.27909362422258); + double b2 = (282.96659601990439); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double2 a3 = double2(-111.41316061439608, 82.665427008022334); + double b3 = (-288.08113278452356); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2_operator_less_scalar_wide() + { + double a0 = (-250.4849370692321); + double2 b0 = double2(-377.19654887597846, -505.14754104295167); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 < b0, r0); + + double a1 = (375.92672198634909); + double2 b1 = double2(110.17393474940855, -118.09757452742082); + bool2 r1 = bool2(false, false); + TestUtils.AreEqual(a1 < b1, r1); + + double a2 = (-40.45089079833167); + double2 b2 = double2(-299.74430932651478, 31.437125935888389); + bool2 r2 = bool2(false, true); + TestUtils.AreEqual(a2 < b2, r2); + + double a3 = (-458.904539560389); + double2 b3 = double2(13.684679276163024, -458.50690839183841); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2_operator_greater_wide_wide() + { + double2 a0 = double2(-229.29066501804192, 505.536608216137); + double2 b0 = double2(-445.84502407808088, -420.03529210576568); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 > b0, r0); + + double2 a1 = double2(-73.80706862071861, 100.29203777215071); + double2 b1 = double2(299.02440108872224, -13.880978829171966); + bool2 r1 = bool2(false, true); + TestUtils.AreEqual(a1 > b1, r1); + + double2 a2 = double2(-419.21478124112582, -159.55974753180504); + double2 b2 = double2(151.56173593903043, -163.5094302461992); + bool2 r2 = bool2(false, true); + TestUtils.AreEqual(a2 > b2, r2); + + double2 a3 = double2(-396.7703608929973, 127.03739482119556); + double2 b3 = double2(-391.09603733154762, 479.2837710228207); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2_operator_greater_wide_scalar() + { + double2 a0 = double2(11.156317000815761, -411.02322382993214); + double b0 = (-302.81693877969724); + bool2 r0 = bool2(true, false); + TestUtils.AreEqual(a0 > b0, r0); + + double2 a1 = double2(385.88556188432756, -491.18003033622171); + double b1 = (-485.10304831206008); + bool2 r1 = bool2(true, false); + TestUtils.AreEqual(a1 > b1, r1); + + double2 a2 = double2(405.17534632476759, 69.269281181166548); + double b2 = (173.57509740329124); + bool2 r2 = bool2(true, false); + TestUtils.AreEqual(a2 > b2, r2); + + double2 a3 = double2(501.30683183172107, -86.124509613087639); + double b3 = (-367.027771405423); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2_operator_greater_scalar_wide() + { + double a0 = (453.54610201974685); + double2 b0 = double2(-226.20441423459187, -423.46500487973213); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 > b0, r0); + + double a1 = (409.40550227156166); + double2 b1 = double2(453.87706277048073, 87.475727837288673); + bool2 r1 = bool2(false, true); + TestUtils.AreEqual(a1 > b1, r1); + + double a2 = (113.79560308987072); + double2 b2 = double2(176.40926154721956, -140.44002944810319); + bool2 r2 = bool2(false, true); + TestUtils.AreEqual(a2 > b2, r2); + + double a3 = (-182.48286804113673); + double2 b3 = double2(-158.29329188088576, -162.68531830733889); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2_operator_less_equal_wide_wide() + { + double2 a0 = double2(240.09053169940159, 462.2131528622532); + double2 b0 = double2(-81.203838624620744, 493.63743876555816); + bool2 r0 = bool2(false, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double2 a1 = double2(293.08251561461134, -427.87067361728782); + double2 b1 = double2(-411.47211451617636, 99.164449499530974); + bool2 r1 = bool2(false, true); + TestUtils.AreEqual(a1 <= b1, r1); + + double2 a2 = double2(-405.5227226715175, 204.59190211286386); + double2 b2 = double2(-295.66769875943089, -480.46254824123463); + bool2 r2 = bool2(true, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double2 a3 = double2(294.670105832941, -327.56444445604666); + double2 b3 = double2(74.414040361723892, 260.916124226952); + bool2 r3 = bool2(false, true); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2_operator_less_equal_wide_scalar() + { + double2 a0 = double2(309.1924356469849, 69.673792633076118); + double b0 = (292.92427148154206); + bool2 r0 = bool2(false, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double2 a1 = double2(-101.72418622939114, -346.01106731314724); + double b1 = (-315.97240629604664); + bool2 r1 = bool2(false, true); + TestUtils.AreEqual(a1 <= b1, r1); + + double2 a2 = double2(424.15386577330241, -483.90265320423185); + double b2 = (-410.87006945669191); + bool2 r2 = bool2(false, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double2 a3 = double2(183.82114538169515, -257.87003791419329); + double b3 = (320.44249287268258); + bool2 r3 = bool2(true, true); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2_operator_less_equal_scalar_wide() + { + double a0 = (-511.15238141974078); + double2 b0 = double2(51.159012579898786, 340.44369022010062); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double a1 = (312.81429519914752); + double2 b1 = double2(354.19252626699983, 136.39671165142056); + bool2 r1 = bool2(true, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double a2 = (-94.767871185563422); + double2 b2 = double2(288.544332877055, 304.04282369466625); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double a3 = (-148.61806089646092); + double2 b3 = double2(-506.30010127755816, 27.581254256694251); + bool2 r3 = bool2(false, true); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2_operator_greater_equal_wide_wide() + { + double2 a0 = double2(-386.59181302906563, -157.12078221008215); + double2 b0 = double2(153.44301350109424, 49.892483019219981); + bool2 r0 = bool2(false, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double2 a1 = double2(391.01526445477054, -511.88687133783793); + double2 b1 = double2(78.025787628267835, 138.81373292711271); + bool2 r1 = bool2(true, false); + TestUtils.AreEqual(a1 >= b1, r1); + + double2 a2 = double2(-5.4220387960886569, 287.64527501149348); + double2 b2 = double2(-225.51057802211056, -339.35611335344436); + bool2 r2 = bool2(true, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double2 a3 = double2(-122.53520184500849, 7.4814426933794493); + double2 b3 = double2(-373.302078182484, 364.9358934671319); + bool2 r3 = bool2(true, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2_operator_greater_equal_wide_scalar() + { + double2 a0 = double2(495.457423679278, -14.345115906719627); + double b0 = (189.20512804258851); + bool2 r0 = bool2(true, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double2 a1 = double2(-463.47478053694346, -246.86571776441565); + double b1 = (217.51749215718246); + bool2 r1 = bool2(false, false); + TestUtils.AreEqual(a1 >= b1, r1); + + double2 a2 = double2(-377.65869706573835, -123.33294373533357); + double b2 = (53.815095211293169); + bool2 r2 = bool2(false, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double2 a3 = double2(-221.50546441856096, -116.44038277326172); + double b3 = (252.99433410027734); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2_operator_greater_equal_scalar_wide() + { + double a0 = (215.43534169692327); + double2 b0 = double2(204.80295310020585, -101.10404853760451); + bool2 r0 = bool2(true, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double a1 = (-122.05503827056617); + double2 b1 = double2(-70.456147941973143, -239.62025677395064); + bool2 r1 = bool2(false, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double a2 = (-185.99272426683115); + double2 b2 = double2(-455.61258027312, 276.66581476697036); + bool2 r2 = bool2(true, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double a3 = (79.39918831707871); + double2 b3 = double2(416.42054791768112, 379.27350801009379); + bool2 r3 = bool2(false, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2_operator_add_wide_wide() + { + double2 a0 = double2(465.14837644302679, 278.91072548502621); + double2 b0 = double2(483.99436186440028, -204.07667193379098); + double2 r0 = double2(949.14273830742707, 74.834053551235229); + TestUtils.AreEqual(a0 + b0, r0); + + double2 a1 = double2(-277.52992237616792, -65.197214395365336); + double2 b1 = double2(-365.67356007437854, -509.92086076639634); + double2 r1 = double2(-643.20348245054652, -575.11807516176168); + TestUtils.AreEqual(a1 + b1, r1); + + double2 a2 = double2(-473.32437561141529, -4.6955420992782138); + double2 b2 = double2(-270.69751108377125, 486.76397846954126); + double2 r2 = double2(-744.02188669518659, 482.06843637026304); + TestUtils.AreEqual(a2 + b2, r2); + + double2 a3 = double2(-470.53676698661258, -109.95011453980118); + double2 b3 = double2(267.49177587567442, 251.6425212601398); + double2 r3 = double2(-203.04499111093816, 141.69240672033862); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2_operator_add_wide_scalar() + { + double2 a0 = double2(459.89829728561369, -447.66336104258119); + double b0 = (500.99725913489112); + double2 r0 = double2(960.89555642050482, 53.333898092309937); + TestUtils.AreEqual(a0 + b0, r0); + + double2 a1 = double2(-94.438627525436971, -36.254356162741033); + double b1 = (126.42986279652916); + double2 r1 = double2(31.991235271092194, 90.175506633788132); + TestUtils.AreEqual(a1 + b1, r1); + + double2 a2 = double2(-349.64130060264904, -478.41478489265535); + double b2 = (-2.7912590516690443); + double2 r2 = double2(-352.43255965431808, -481.20604394432439); + TestUtils.AreEqual(a2 + b2, r2); + + double2 a3 = double2(443.11525246273504, 41.32102133767728); + double b3 = (268.092225914864); + double2 r3 = double2(711.207478377599, 309.41324725254128); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2_operator_add_scalar_wide() + { + double a0 = (-325.51276484388518); + double2 b0 = double2(-264.08813178915909, -106.00925998855814); + double2 r0 = double2(-589.60089663304427, -431.52202483244332); + TestUtils.AreEqual(a0 + b0, r0); + + double a1 = (-355.44729320865463); + double2 b1 = double2(-447.33029362528134, -158.70021040677102); + double2 r1 = double2(-802.777586833936, -514.14750361542565); + TestUtils.AreEqual(a1 + b1, r1); + + double a2 = (-199.48369154682553); + double2 b2 = double2(180.31809123806568, 337.57936898692481); + double2 r2 = double2(-19.165600308759849, 138.09567744009928); + TestUtils.AreEqual(a2 + b2, r2); + + double a3 = (-37.05501486596421); + double2 b3 = double2(230.80498014707348, -140.17433339924287); + double2 r3 = double2(193.74996528110927, -177.22934826520708); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2_operator_sub_wide_wide() + { + double2 a0 = double2(133.37101680290471, -131.8321183341705); + double2 b0 = double2(123.46028739002543, 359.56010048443454); + double2 r0 = double2(9.9107294128792773, -491.39221881860504); + TestUtils.AreEqual(a0 - b0, r0); + + double2 a1 = double2(-197.29314407952739, -485.286571013409); + double2 b1 = double2(-48.24847819667707, 478.97904680621764); + double2 r1 = double2(-149.04466588285032, -964.26561781962664); + TestUtils.AreEqual(a1 - b1, r1); + + double2 a2 = double2(-337.55033103448818, 471.66710470228782); + double2 b2 = double2(207.15832886805686, 142.36730462981723); + double2 r2 = double2(-544.708659902545, 329.29980007247059); + TestUtils.AreEqual(a2 - b2, r2); + + double2 a3 = double2(146.5066197600712, -130.58504372955537); + double2 b3 = double2(-125.60551005490379, -65.299004823574307); + double2 r3 = double2(272.112129814975, -65.286038905981059); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2_operator_sub_wide_scalar() + { + double2 a0 = double2(48.936717294592768, 410.45158953706346); + double b0 = (-291.59041442144212); + double2 r0 = double2(340.52713171603489, 702.04200395850557); + TestUtils.AreEqual(a0 - b0, r0); + + double2 a1 = double2(-364.44171612544062, -460.06732318367222); + double b1 = (163.98060353285666); + double2 r1 = double2(-528.42231965829728, -624.04792671652888); + TestUtils.AreEqual(a1 - b1, r1); + + double2 a2 = double2(110.91942339340198, 180.26971420099483); + double b2 = (204.35834441164434); + double2 r2 = double2(-93.438921018242354, -24.088630210649512); + TestUtils.AreEqual(a2 - b2, r2); + + double2 a3 = double2(-377.92569344952972, 400.53491968686455); + double b3 = (-470.26204297983185); + double2 r3 = double2(92.33634953030213, 870.79696266669634); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2_operator_sub_scalar_wide() + { + double a0 = (294.58645905861); + double2 b0 = double2(452.35251757705237, 256.98980891750648); + double2 r0 = double2(-157.76605851844238, 37.59665014110351); + TestUtils.AreEqual(a0 - b0, r0); + + double a1 = (-275.159888634067); + double2 b1 = double2(-89.027518075437968, 488.22838829840919); + double2 r1 = double2(-186.13237055862902, -763.38827693247617); + TestUtils.AreEqual(a1 - b1, r1); + + double a2 = (-333.21728030462623); + double2 b2 = double2(-64.232989102710519, -66.041730196234653); + double2 r2 = double2(-268.98429120191571, -267.17555010839158); + TestUtils.AreEqual(a2 - b2, r2); + + double a3 = (341.20492831859963); + double2 b3 = double2(-385.775056303374, 75.394746577085357); + double2 r3 = double2(726.9799846219737, 265.81018174151427); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2_operator_mul_wide_wide() + { + double2 a0 = double2(-394.78053898121254, -412.37219519744264); + double2 b0 = double2(-149.76397831261346, -345.04538671348496); + double2 r0 = double2(59123.904078224172, 142287.1235617903); + TestUtils.AreEqual(a0 * b0, r0); + + double2 a1 = double2(-25.874570143350638, -241.04595886964626); + double2 b1 = double2(-284.33404721148963, 267.97923648915219); + double2 r1 = double2(7357.0212487164608, -64595.312016683383); + TestUtils.AreEqual(a1 * b1, r1); + + double2 a2 = double2(-93.675987525692221, 244.15999257013198); + double2 b2 = double2(-326.64849558782225, -150.68967754705329); + double2 r2 = double2(30599.120397970968, -36792.390550284115); + TestUtils.AreEqual(a2 * b2, r2); + + double2 a3 = double2(494.68846606402121, 53.537962700025105); + double2 b3 = double2(207.73243794577775, 366.19289248352538); + double2 r3 = double2(102762.84107913627, 19605.221418797286); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2_operator_mul_wide_scalar() + { + double2 a0 = double2(328.20302191758674, -290.10672272839895); + double b0 = (192.21119055161773); + double2 r0 = double2(63084.293585418032, -55761.758562653624); + TestUtils.AreEqual(a0 * b0, r0); + + double2 a1 = double2(236.99572454998065, 357.90315811610924); + double b1 = (120.48136692889102); + double2 r1 = double2(28553.568850084604, 43120.661717995856); + TestUtils.AreEqual(a1 * b1, r1); + + double2 a2 = double2(134.86723214707672, -438.272912467957); + double b2 = (-477.31047104173825); + double2 r2 = double2(-64373.542104216656, 209192.25029491508); + TestUtils.AreEqual(a2 * b2, r2); + + double2 a3 = double2(-46.729179165665585, 422.08249374017237); + double b3 = (-238.40500103608008); + double2 r3 = double2(11140.470007405675, -100626.57735743705); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2_operator_mul_scalar_wide() + { + double a0 = (-464.534700371574); + double2 b0 = double2(329.36093846399376, -198.68342671109525); + double2 r0 = double2(-152999.58486347177, 92295.346096036214); + TestUtils.AreEqual(a0 * b0, r0); + + double a1 = (184.07942518223047); + double2 b1 = double2(256.01618754864489, 266.22629297255833); + double2 r1 = double2(47127.312641300661, 49006.78297878462); + TestUtils.AreEqual(a1 * b1, r1); + + double a2 = (-97.894749448585685); + double2 b2 = double2(159.74810583877752, -351.82222263506719); + double2 r2 = double2(-15638.500795973274, 34441.548335304433); + TestUtils.AreEqual(a2 * b2, r2); + + double a3 = (491.80157660497423); + double2 b3 = double2(49.902031206480274, 424.46256871915546); + double2 r3 = double2(24541.897623137622, 208751.36050587788); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2_operator_div_wide_wide() + { + double2 a0 = double2(246.26574933075619, -269.85612953354428); + double2 b0 = double2(172.11981423763552, -77.141104972521362); + double2 r0 = double2(1.4307809383918566, 3.4982144685336105); + TestUtils.AreEqual(a0 / b0, r0); + + double2 a1 = double2(-451.61952588130697, -7.38850236283082); + double2 b1 = double2(-325.8353723612779, -450.60868117334724); + double2 r1 = double2(1.3860359070548143, 0.016396715535066435); + TestUtils.AreEqual(a1 / b1, r1); + + double2 a2 = double2(-308.20558681534862, -373.394808704683); + double2 b2 = double2(-261.26215398556656, -122.44949847201326); + double2 r2 = double2(1.1796794220427942, 3.0493780159501847); + TestUtils.AreEqual(a2 / b2, r2); + + double2 a3 = double2(360.41863482092447, 25.80972458133931); + double2 b3 = double2(-93.210781379235357, -442.00522705633438); + double2 r3 = double2(-3.8667054335113131, -0.05839235149599218); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2_operator_div_wide_scalar() + { + double2 a0 = double2(-244.51745116175965, 69.112274917360537); + double b0 = (-60.024377612408443); + double2 r0 = double2(4.0736357608014941, -1.1514034408425655); + TestUtils.AreEqual(a0 / b0, r0); + + double2 a1 = double2(-333.02311888943575, 403.24561257066466); + double b1 = (257.39682519500923); + double2 r1 = double2(-1.2938120687274619, 1.5666300944666172); + TestUtils.AreEqual(a1 / b1, r1); + + double2 a2 = double2(154.34436066185322, -261.88639200007844); + double b2 = (131.52659160062979); + double2 r2 = double2(1.1734840748440269, -1.9911288570092047); + TestUtils.AreEqual(a2 / b2, r2); + + double2 a3 = double2(-348.92380516087815, 210.55792174607416); + double b3 = (-275.53868187383688); + double2 r3 = double2(1.26633328862567, -0.76416828415577609); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2_operator_div_scalar_wide() + { + double a0 = (41.737658758525527); + double2 b0 = double2(-422.676129776368, 248.12963235011773); + double2 r0 = double2(-0.098746193168297289, 0.1682090863683405); + TestUtils.AreEqual(a0 / b0, r0); + + double a1 = (449.39137741988122); + double2 b1 = double2(245.85813796047967, -326.62061253498337); + double2 r1 = double2(1.8278482914896166, -1.3758818646871169); + TestUtils.AreEqual(a1 / b1, r1); + + double a2 = (163.71510489457989); + double2 b2 = double2(333.664472020075, 38.291076916405473); + double2 r2 = double2(0.4906578872584611, 4.2755419298337261); + TestUtils.AreEqual(a2 / b2, r2); + + double a3 = (-472.97976062864984); + double2 b3 = double2(192.23013958345643, -200.29686960964318); + double2 r3 = double2(-2.4604870061143891, 2.3613936730535827); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2_operator_mod_wide_wide() + { + double2 a0 = double2(-442.30985924336585, 368.50046246522129); + double2 b0 = double2(-43.245045443645211, -144.19587690392319); + double2 r0 = double2(-9.8594048069137443, 80.1087086573749); + TestUtils.AreEqual(a0 % b0, r0); + + double2 a1 = double2(-1.0938966279355213, -364.67383473211612); + double2 b1 = double2(-62.640481739603217, -336.82826510855381); + double2 r1 = double2(-1.0938966279355213, -27.845569623562312); + TestUtils.AreEqual(a1 % b1, r1); + + double2 a2 = double2(-197.34394487987458, -34.034902350062); + double2 b2 = double2(-154.6102545981343, -154.02935583611452); + double2 r2 = double2(-42.73369028174028, -34.034902350062); + TestUtils.AreEqual(a2 % b2, r2); + + double2 a3 = double2(-101.34858350704826, 208.31857142612273); + double2 b3 = double2(487.0462093237071, -469.82909105244516); + double2 r3 = double2(-101.34858350704826, 208.31857142612273); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2_operator_mod_wide_scalar() + { + double2 a0 = double2(-433.41699548876704, -5.5141427542614565); + double b0 = (-90.499235433758827); + double2 r0 = double2(-71.420053753731736, -5.5141427542614565); + TestUtils.AreEqual(a0 % b0, r0); + + double2 a1 = double2(393.39439958771425, -120.80601626299602); + double b1 = (299.41153277988155); + double2 r1 = double2(93.982866807832693, -120.80601626299602); + TestUtils.AreEqual(a1 % b1, r1); + + double2 a2 = double2(-502.939041133476, 186.09479698263794); + double b2 = (-450.80766245853511); + double2 r2 = double2(-52.131378674940891, 186.09479698263794); + TestUtils.AreEqual(a2 % b2, r2); + + double2 a3 = double2(-84.473635951277629, 433.45469041981482); + double b3 = (-318.78148356023314); + double2 r3 = double2(-84.473635951277629, 114.67320685958168); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2_operator_mod_scalar_wide() + { + double a0 = (-396.4224028049141); + double2 b0 = double2(-159.14024384279747, 230.17333399046834); + double2 r0 = double2(-78.141915119319151, -166.24906881444576); + TestUtils.AreEqual(a0 % b0, r0); + + double a1 = (14.779358632294134); + double2 b1 = double2(-303.15649738123477, 399.63502020371845); + double2 r1 = double2(14.779358632294134, 14.779358632294134); + TestUtils.AreEqual(a1 % b1, r1); + + double a2 = (206.69470534412881); + double2 b2 = double2(397.04482263934096, -393.89064735634747); + double2 r2 = double2(206.69470534412881, 206.69470534412881); + TestUtils.AreEqual(a2 % b2, r2); + + double a3 = (-372.06709426085797); + double2 b3 = double2(201.01229796233224, -95.5668547598491); + double2 r3 = double2(-171.05479629852573, -85.366529981310691); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2_operator_plus() + { + double2 a0 = double2(271.6708086802023, -79.080240524876956); + double2 r0 = double2(271.6708086802023, -79.080240524876956); + TestUtils.AreEqual(+a0, r0); + + double2 a1 = double2(-330.98506203805334, 315.44952860262686); + double2 r1 = double2(-330.98506203805334, 315.44952860262686); + TestUtils.AreEqual(+a1, r1); + + double2 a2 = double2(319.22218742930431, -350.30858270745193); + double2 r2 = double2(319.22218742930431, -350.30858270745193); + TestUtils.AreEqual(+a2, r2); + + double2 a3 = double2(-320.51845875406565, -107.00351267075331); + double2 r3 = double2(-320.51845875406565, -107.00351267075331); + TestUtils.AreEqual(+a3, r3); + } + + [TestCompiler] + public static void double2_operator_neg() + { + double2 a0 = double2(420.22718854445372, -196.25749811728366); + double2 r0 = double2(-420.22718854445372, 196.25749811728366); + TestUtils.AreEqual(-a0, r0); + + double2 a1 = double2(-335.42683068636188, -33.014395013923945); + double2 r1 = double2(335.42683068636188, 33.014395013923945); + TestUtils.AreEqual(-a1, r1); + + double2 a2 = double2(-498.57532071442125, -270.85946787095605); + double2 r2 = double2(498.57532071442125, 270.85946787095605); + TestUtils.AreEqual(-a2, r2); + + double2 a3 = double2(19.686896571743773, -180.60051473444349); + double2 r3 = double2(-19.686896571743773, 180.60051473444349); + TestUtils.AreEqual(-a3, r3); + } + + [TestCompiler] + public static void double2_operator_prefix_inc() + { + double2 a0 = double2(-99.79557113526181, 458.74185082816609); + double2 r0 = double2(-98.79557113526181, 459.74185082816609); + TestUtils.AreEqual(++a0, r0); + + double2 a1 = double2(96.179026886904126, -315.728967098393); + double2 r1 = double2(97.179026886904126, -314.728967098393); + TestUtils.AreEqual(++a1, r1); + + double2 a2 = double2(-299.23014583216525, -456.89028832730384); + double2 r2 = double2(-298.23014583216525, -455.89028832730384); + TestUtils.AreEqual(++a2, r2); + + double2 a3 = double2(-76.507656371457358, 64.0964734852763); + double2 r3 = double2(-75.507656371457358, 65.0964734852763); + TestUtils.AreEqual(++a3, r3); + } + + [TestCompiler] + public static void double2_operator_postfix_inc() + { + double2 a0 = double2(322.94356623429042, 472.05246542024076); + double2 r0 = double2(322.94356623429042, 472.05246542024076); + TestUtils.AreEqual(a0++, r0); + + double2 a1 = double2(203.48761925636211, -31.420532002775246); + double2 r1 = double2(203.48761925636211, -31.420532002775246); + TestUtils.AreEqual(a1++, r1); + + double2 a2 = double2(455.33662459595905, 55.736877228942149); + double2 r2 = double2(455.33662459595905, 55.736877228942149); + TestUtils.AreEqual(a2++, r2); + + double2 a3 = double2(153.75031645305, -427.40105100506969); + double2 r3 = double2(153.75031645305, -427.40105100506969); + TestUtils.AreEqual(a3++, r3); + } + + [TestCompiler] + public static void double2_operator_prefix_dec() + { + double2 a0 = double2(-416.20121712992022, -96.637880131899351); + double2 r0 = double2(-417.20121712992022, -97.637880131899351); + TestUtils.AreEqual(--a0, r0); + + double2 a1 = double2(-50.145671629414721, 439.47906156977592); + double2 r1 = double2(-51.145671629414721, 438.47906156977592); + TestUtils.AreEqual(--a1, r1); + + double2 a2 = double2(-304.40081920493435, 246.08898293510492); + double2 r2 = double2(-305.40081920493435, 245.08898293510492); + TestUtils.AreEqual(--a2, r2); + + double2 a3 = double2(171.96452935597142, 298.28480710568135); + double2 r3 = double2(170.96452935597142, 297.28480710568135); + TestUtils.AreEqual(--a3, r3); + } + + [TestCompiler] + public static void double2_operator_postfix_dec() + { + double2 a0 = double2(-376.59242719066907, 16.969734438215255); + double2 r0 = double2(-376.59242719066907, 16.969734438215255); + TestUtils.AreEqual(a0--, r0); + + double2 a1 = double2(-0.25066399585949739, 409.55752940175944); + double2 r1 = double2(-0.25066399585949739, 409.55752940175944); + TestUtils.AreEqual(a1--, r1); + + double2 a2 = double2(47.856652520530247, -262.062590959511); + double2 r2 = double2(47.856652520530247, -262.062590959511); + TestUtils.AreEqual(a2--, r2); + + double2 a3 = double2(-182.40572866350681, -129.23265582380475); + double2 r3 = double2(-182.40572866350681, -129.23265582380475); + TestUtils.AreEqual(a3--, r3); + } + + [TestCompiler] + public static void double2_shuffle_result_1() + { + double2 a = double2(0, 1); + double2 b = double2(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 double2_shuffle_result_2() + { + double2 a = double2(0, 1); + double2 b = double2(2, 3); + + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftX), double2(0, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftX), double2(1, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX), double2(2, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX), double2(3, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY), double2(0, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftY), double2(1, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY), double2(2, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY), double2(3, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightX), double2(0, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightX), double2(1, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX), double2(2, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), double2(3, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY), double2(0, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightY), double2(1, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY), double2(2, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY), double2(3, 3)); + } + + [TestCompiler] + public static void double2_shuffle_result_3() + { + double2 a = double2(0, 1); + double2 b = double2(2, 3); + + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightY), double3(2, 3, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightX), double3(2, 0, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightY), double3(3, 1, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftY, ShuffleComponent.LeftY), double3(1, 1, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY), double3(2, 1, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.RightY), double3(0, 3, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY), double3(2, 1, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.LeftX), double3(3, 3, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightY), double3(2, 2, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftX), double3(2, 2, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), double3(0, 1, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightY), double3(3, 2, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), double3(0, 1, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightX), double3(3, 2, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightY), double3(0, 1, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY), double3(3, 1, 1)); + } + + [TestCompiler] + public static void double2_shuffle_result_4() + { + double2 a = double2(0, 1); + double2 b = double2(2, 3); + + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightX), double4(0, 0, 1, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.LeftX, ShuffleComponent.RightY), double4(2, 1, 0, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightX), double4(3, 2, 3, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.RightY), double4(2, 0, 3, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightX), double4(0, 3, 0, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.LeftY), double4(3, 0, 3, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.LeftX), double4(2, 2, 3, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY), double4(2, 2, 0, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.RightX, ShuffleComponent.LeftY), double4(0, 1, 2, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightY), double4(2, 1, 3, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.LeftY), double4(3, 3, 3, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), double4(2, 2, 1, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX), double4(3, 0, 0, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.RightY), double4(2, 2, 2, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightY), double4(0, 3, 0, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX), double4(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/TestDouble2.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/TestDouble2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d496ffc29001e55602cf936491178cf87ef13ea8 --- /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/TestDouble2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: aad8a485c4a133942b50e482a663b6a3 +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/TestDouble2x2.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/TestDouble2x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..6caad9b633e92c93e9fc7a43a9b65b5222e18162 --- /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/TestDouble2x2.gen.cs @@ -0,0 +1,950 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestDouble2x2 + { + [TestCompiler] + public static void double2x2_zero() + { + TestUtils.AreEqual(double2x2.zero.c0.x, 0.0); + TestUtils.AreEqual(double2x2.zero.c0.y, 0.0); + TestUtils.AreEqual(double2x2.zero.c1.x, 0.0); + TestUtils.AreEqual(double2x2.zero.c1.y, 0.0); + } + + [TestCompiler] + public static void double2x2_identity() + { + TestUtils.AreEqual(double2x2.identity.c0.x, 1.0); + TestUtils.AreEqual(double2x2.identity.c0.y, 0.0); + TestUtils.AreEqual(double2x2.identity.c1.x, 0.0); + TestUtils.AreEqual(double2x2.identity.c1.y, 1.0); + } + + [TestCompiler] + public static void double2x2_operator_equal_wide_wide() + { + double2x2 a0 = double2x2(-135.18925172425304, -49.094127439471947, 169.12980778940482, 240.80529772527757); + double2x2 b0 = double2x2(-220.01464591734793, 66.980020792679852, 499.20158576369363, -371.113114291389); + bool2x2 r0 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double2x2 a1 = double2x2(314.73919382446411, 442.39301916695808, 177.92444881141398, 335.53340283759564); + double2x2 b1 = double2x2(208.44865212610398, 390.80369133074009, -72.443806920407269, 362.97643273089841); + bool2x2 r1 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double2x2 a2 = double2x2(168.1544516869609, 350.72955982327903, 367.17843668869625, 46.941470406456574); + double2x2 b2 = double2x2(194.6783255053117, 471.6448635867074, -404.04466719368691, -144.69675476136467); + bool2x2 r2 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double2x2 a3 = double2x2(188.76415094582558, -97.211392209497944, -293.3210057193977, -234.82292353120766); + double2x2 b3 = double2x2(-494.44664334433463, -252.97038209297244, 234.41711746641306, 398.72397465199413); + bool2x2 r3 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_equal_wide_scalar() + { + double2x2 a0 = double2x2(65.671194345537174, 404.41550440546848, -269.7301577393572, 83.630607882342588); + double b0 = (-155.8157547245807); + bool2x2 r0 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double2x2 a1 = double2x2(152.99450476141385, 314.67125597348024, 386.36515325417986, 290.04894007837811); + double b1 = (-155.86829836474186); + bool2x2 r1 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double2x2 a2 = double2x2(-132.63519460178691, -69.683271678948415, -191.19075521789063, 186.84520086406042); + double b2 = (-65.667489797653388); + bool2x2 r2 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double2x2 a3 = double2x2(-232.89569221851218, -49.701092981594172, -300.88189925853248, 333.39685193328046); + double b3 = (-319.14406481345372); + bool2x2 r3 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_equal_scalar_wide() + { + double a0 = (36.383921878591195); + double2x2 b0 = double2x2(-400.48919958644046, -71.286823544319191, 156.97811491646712, -225.23872791288363); + bool2x2 r0 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double a1 = (499.14180993435059); + double2x2 b1 = double2x2(-211.97992358542047, 428.31192394174263, -489.50133322621758, -5.6915457275190988); + bool2x2 r1 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double a2 = (-30.865948453017495); + double2x2 b2 = double2x2(-362.98307221149241, 184.50319322594589, -160.47062142215231, 316.66882315122928); + bool2x2 r2 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double a3 = (390.36923879681581); + double2x2 b3 = double2x2(505.10510301268891, -294.64870967280524, 443.19909283295226, 96.559236333034619); + bool2x2 r3 = bool2x2(false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_not_equal_wide_wide() + { + double2x2 a0 = double2x2(279.99414576217259, -43.342018386042696, -465.72473523846116, 317.46655645848557); + double2x2 b0 = double2x2(-460.912120318465, -476.00904844515446, 468.13642070635058, -341.01254312182431); + bool2x2 r0 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double2x2 a1 = double2x2(85.714987079480238, 360.89050572034466, 366.08152668833804, 154.5428384070018); + double2x2 b1 = double2x2(-62.658060341448561, -458.80166718866752, -457.73023316717251, -59.523265627922171); + bool2x2 r1 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double2x2 a2 = double2x2(332.426219856565, 397.11323160543725, -431.3749584776233, 489.01079319837072); + double2x2 b2 = double2x2(3.024243117787023, 155.81276352508587, -19.839918384253963, -6.0169332055453992); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double2x2 a3 = double2x2(398.43358320669904, -489.81794594685454, 171.4049242340983, -67.829682620162941); + double2x2 b3 = double2x2(-406.20792145571107, -102.42070083619126, -40.362921018322425, 452.67542645552919); + bool2x2 r3 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_not_equal_wide_scalar() + { + double2x2 a0 = double2x2(-155.44111282911206, -19.426602134214079, 174.63305409934048, 507.9207296352464); + double b0 = (-393.41354173860213); + bool2x2 r0 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double2x2 a1 = double2x2(59.177048472304364, -58.923273352404692, -398.17684835855704, 492.20105361016522); + double b1 = (171.15146430356026); + bool2x2 r1 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double2x2 a2 = double2x2(-165.24150879925185, -380.24326222960059, 501.8990516615562, -134.34545642433011); + double b2 = (270.34102333259818); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double2x2 a3 = double2x2(458.40042302496749, 161.45995123752391, 261.51423442620512, -145.61239559278471); + double b3 = (46.771004937016869); + bool2x2 r3 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_not_equal_scalar_wide() + { + double a0 = (478.35313938481409); + double2x2 b0 = double2x2(459.55319592894671, 436.45324369727314, -488.71416806090349, 392.76794475725296); + bool2x2 r0 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double a1 = (-266.73665369056937); + double2x2 b1 = double2x2(338.55788270503183, -338.10012475498957, -152.3145445102428, -452.82067868338); + bool2x2 r1 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double a2 = (209.43931422449612); + double2x2 b2 = double2x2(50.107968592135194, 372.4343656843688, -488.0213141329686, 489.74075697816011); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double a3 = (270.40006149485714); + double2x2 b3 = double2x2(-472.8467831429312, -286.85046090132113, -384.69186681541237, 443.42352959300558); + bool2x2 r3 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_less_wide_wide() + { + double2x2 a0 = double2x2(51.710243010758518, -313.85556450200062, 283.04767359562572, 235.02188621974642); + double2x2 b0 = double2x2(-261.83523881707117, -19.810742149041403, -149.25882084167506, 205.99822316225539); + bool2x2 r0 = bool2x2(false, true, false, false); + TestUtils.AreEqual(a0 < b0, r0); + + double2x2 a1 = double2x2(44.0783565249659, -207.25566659088042, 3.3829410091894943, -144.30134326978651); + double2x2 b1 = double2x2(-306.02438535635565, 102.12168006884008, 231.90633760760829, 179.49885305180158); + bool2x2 r1 = bool2x2(false, true, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double2x2 a2 = double2x2(-69.369597705718888, -135.66796762108243, -194.78736576567746, -33.473868147225062); + double2x2 b2 = double2x2(473.22488496882136, 15.891647107848712, 270.04990614114786, 490.91400240869916); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double2x2 a3 = double2x2(-19.675088653189619, 423.23796697297973, -71.698315415390937, -501.88598870760109); + double2x2 b3 = double2x2(-185.73412164753961, 76.433086669274189, 97.75231246731812, 419.30080600236579); + bool2x2 r3 = bool2x2(false, false, true, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_less_wide_scalar() + { + double2x2 a0 = double2x2(-221.86977325280651, -121.54646807608498, -97.52392511140738, 479.88107775146193); + double b0 = (199.06751808853244); + bool2x2 r0 = bool2x2(true, true, true, false); + TestUtils.AreEqual(a0 < b0, r0); + + double2x2 a1 = double2x2(67.118990214131259, 282.96659601990439, 258.27909362422258, -111.41316061439608); + double b1 = (137.32880574899207); + bool2x2 r1 = bool2x2(true, false, false, true); + TestUtils.AreEqual(a1 < b1, r1); + + double2x2 a2 = double2x2(-288.08113278452356, -361.64292042406413, -68.088202269788951, 12.788020378345664); + double b2 = (82.665427008022334); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double2x2 a3 = double2x2(-66.703050406045747, 25.727694284975428, 101.37087182950734, -330.442660724019); + double b3 = (-78.762971199472872); + bool2x2 r3 = bool2x2(false, false, false, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_less_scalar_wide() + { + double a0 = (-250.4849370692321); + double2x2 b0 = double2x2(-377.19654887597846, -505.14754104295167, 375.92672198634909, 110.17393474940855); + bool2x2 r0 = bool2x2(false, false, true, true); + TestUtils.AreEqual(a0 < b0, r0); + + double a1 = (-118.09757452742082); + double2x2 b1 = double2x2(-40.45089079833167, -299.74430932651478, 31.437125935888389, -458.904539560389); + bool2x2 r1 = bool2x2(true, false, true, false); + TestUtils.AreEqual(a1 < b1, r1); + + double a2 = (13.684679276163024); + double2x2 b2 = double2x2(-458.50690839183841, 248.27646624682302, 389.23142999654237, 488.74553679337055); + bool2x2 r2 = bool2x2(false, true, true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double a3 = (-221.63786731550368); + double2x2 b3 = double2x2(-424.26720329013989, 249.05904948388184, -22.136127720650336, -442.24773928255206); + bool2x2 r3 = bool2x2(false, true, true, false); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_greater_wide_wide() + { + double2x2 a0 = double2x2(-229.29066501804192, 505.536608216137, -73.80706862071861, 100.29203777215071); + double2x2 b0 = double2x2(-445.84502407808088, -420.03529210576568, 299.02440108872224, -13.880978829171966); + bool2x2 r0 = bool2x2(true, true, false, true); + TestUtils.AreEqual(a0 > b0, r0); + + double2x2 a1 = double2x2(-419.21478124112582, -159.55974753180504, -396.7703608929973, 127.03739482119556); + double2x2 b1 = double2x2(151.56173593903043, -163.5094302461992, -391.09603733154762, 479.2837710228207); + bool2x2 r1 = bool2x2(false, true, false, false); + TestUtils.AreEqual(a1 > b1, r1); + + double2x2 a2 = double2x2(489.13989733585151, 51.91890885863404, 155.38475544535777, -135.63165027258526); + double2x2 b2 = double2x2(-77.674873149802409, -46.5841996886694, -415.37701888353422, 71.466978344818131); + bool2x2 r2 = bool2x2(true, true, true, false); + TestUtils.AreEqual(a2 > b2, r2); + + double2x2 a3 = double2x2(-425.97813554572787, -228.430505143679, 383.03834909155887, 136.53358298937496); + double2x2 b3 = double2x2(-206.06102643071722, 360.83628218287424, 236.96878658838978, 14.550342328171382); + bool2x2 r3 = bool2x2(false, false, true, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_greater_wide_scalar() + { + double2x2 a0 = double2x2(11.156317000815761, -411.02322382993214, 385.88556188432756, -485.10304831206008); + double b0 = (-302.81693877969724); + bool2x2 r0 = bool2x2(true, false, true, false); + TestUtils.AreEqual(a0 > b0, r0); + + double2x2 a1 = double2x2(-491.18003033622171, 173.57509740329124, 69.269281181166548, 501.30683183172107); + double b1 = (405.17534632476759); + bool2x2 r1 = bool2x2(false, false, false, true); + TestUtils.AreEqual(a1 > b1, r1); + + double2x2 a2 = double2x2(-367.027771405423, -489.09058998948456, -172.51816066192379, -18.149639853346002); + double b2 = (-86.124509613087639); + bool2x2 r2 = bool2x2(false, false, false, true); + TestUtils.AreEqual(a2 > b2, r2); + + double2x2 a3 = double2x2(-236.41493498367021, -27.239137900638923, 471.77934072528933, 240.16453253485474); + double b3 = (-238.8945134798505); + bool2x2 r3 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_greater_scalar_wide() + { + double a0 = (453.54610201974685); + double2x2 b0 = double2x2(-226.20441423459187, -423.46500487973213, 409.40550227156166, 453.87706277048073); + bool2x2 r0 = bool2x2(true, true, true, false); + TestUtils.AreEqual(a0 > b0, r0); + + double a1 = (87.475727837288673); + double2x2 b1 = double2x2(113.79560308987072, 176.40926154721956, -140.44002944810319, -182.48286804113673); + bool2x2 r1 = bool2x2(false, false, true, true); + TestUtils.AreEqual(a1 > b1, r1); + + double a2 = (-158.29329188088576); + double2x2 b2 = double2x2(-162.68531830733889, -193.328676075362, 230.18129955519987, -102.58784227379965); + bool2x2 r2 = bool2x2(true, true, false, false); + TestUtils.AreEqual(a2 > b2, r2); + + double a3 = (392.5205878655056); + double2x2 b3 = double2x2(-177.47865947404813, -10.295010809924008, -24.048938524000789, 172.44867499752377); + bool2x2 r3 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_less_equal_wide_wide() + { + double2x2 a0 = double2x2(240.09053169940159, 462.2131528622532, 293.08251561461134, -427.87067361728782); + double2x2 b0 = double2x2(-81.203838624620744, 493.63743876555816, -411.47211451617636, 99.164449499530974); + bool2x2 r0 = bool2x2(false, true, false, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double2x2 a1 = double2x2(-405.5227226715175, 204.59190211286386, 294.670105832941, -327.56444445604666); + double2x2 b1 = double2x2(-295.66769875943089, -480.46254824123463, 74.414040361723892, 260.916124226952); + bool2x2 r1 = bool2x2(true, false, false, true); + TestUtils.AreEqual(a1 <= b1, r1); + + double2x2 a2 = double2x2(-456.12326667091031, 282.3012408140587, 421.8811549720732, -311.71284809322697); + double2x2 b2 = double2x2(306.17329730939741, 139.56480438055689, -505.75247955031341, -489.62680958659706); + bool2x2 r2 = bool2x2(true, false, false, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double2x2 a3 = double2x2(84.5674827492644, 447.24461647832982, -154.49435217422172, -424.36474986763892); + double2x2 b3 = double2x2(-280.03260267899958, 303.15991058161478, 511.19015788994272, -104.65973358259527); + bool2x2 r3 = bool2x2(false, false, true, true); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_less_equal_wide_scalar() + { + double2x2 a0 = double2x2(309.1924356469849, 69.673792633076118, -101.72418622939114, -315.97240629604664); + double b0 = (292.92427148154206); + bool2x2 r0 = bool2x2(false, true, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double2x2 a1 = double2x2(-346.01106731314724, -410.87006945669191, -483.90265320423185, 183.82114538169515); + double b1 = (424.15386577330241); + bool2x2 r1 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a1 <= b1, r1); + + double2x2 a2 = double2x2(320.44249287268258, -386.801748694294, -182.9388249772316, 349.25012962392077); + double b2 = (-257.87003791419329); + bool2x2 r2 = bool2x2(false, true, false, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double2x2 a3 = double2x2(485.31159304329731, 259.15151822713744, 450.13007828692446, -128.5255282523695); + double b3 = (373.56911652794531); + bool2x2 r3 = bool2x2(false, true, false, true); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_less_equal_scalar_wide() + { + double a0 = (-511.15238141974078); + double2x2 b0 = double2x2(51.159012579898786, 340.44369022010062, 312.81429519914752, 354.19252626699983); + bool2x2 r0 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double a1 = (136.39671165142056); + double2x2 b1 = double2x2(-94.767871185563422, 288.544332877055, 304.04282369466625, -148.61806089646092); + bool2x2 r1 = bool2x2(false, true, true, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double a2 = (-506.30010127755816); + double2x2 b2 = double2x2(27.581254256694251, 48.471146844546865, 104.88351326104419, -488.6858386884843); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double a3 = (-480.43516968210935); + double2x2 b3 = double2x2(421.9366516647566, 239.72105299668431, -101.01844673092404, -283.95147551407638); + bool2x2 r3 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_greater_equal_wide_wide() + { + double2x2 a0 = double2x2(-386.59181302906563, -157.12078221008215, 391.01526445477054, -511.88687133783793); + double2x2 b0 = double2x2(153.44301350109424, 49.892483019219981, 78.025787628267835, 138.81373292711271); + bool2x2 r0 = bool2x2(false, false, true, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double2x2 a1 = double2x2(-5.4220387960886569, 287.64527501149348, -122.53520184500849, 7.4814426933794493); + double2x2 b1 = double2x2(-225.51057802211056, -339.35611335344436, -373.302078182484, 364.9358934671319); + bool2x2 r1 = bool2x2(true, true, true, false); + TestUtils.AreEqual(a1 >= b1, r1); + + double2x2 a2 = double2x2(152.94642765491574, 48.986223482054811, 57.338148859021317, 300.46493138953338); + double2x2 b2 = double2x2(-322.71539870030961, 125.47818165900105, -25.776589167200314, 297.51890792395864); + bool2x2 r2 = bool2x2(true, false, true, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double2x2 a3 = double2x2(349.25705139211243, 85.749700824613569, -230.95330654408468, 418.7112159294594); + double2x2 b3 = double2x2(73.222349439385539, 462.78374288174496, 393.19134515951919, -95.001432224643168); + bool2x2 r3 = bool2x2(true, false, false, true); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_greater_equal_wide_scalar() + { + double2x2 a0 = double2x2(495.457423679278, -14.345115906719627, -463.47478053694346, 217.51749215718246); + double b0 = (189.20512804258851); + bool2x2 r0 = bool2x2(true, false, false, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double2x2 a1 = double2x2(-246.86571776441565, 53.815095211293169, -123.33294373533357, -221.50546441856096); + double b1 = (-377.65869706573835); + bool2x2 r1 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double2x2 a2 = double2x2(252.99433410027734, -395.36331028275345, 164.77259667439978, -287.00733889593153); + double b2 = (-116.44038277326172); + bool2x2 r2 = bool2x2(true, false, true, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double2x2 a3 = double2x2(355.83704559683667, 273.01225555735277, -418.14240308205706, 249.38409697701411); + double b3 = (184.19556316369938); + bool2x2 r3 = bool2x2(true, true, false, true); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_greater_equal_scalar_wide() + { + double a0 = (215.43534169692327); + double2x2 b0 = double2x2(204.80295310020585, -101.10404853760451, -122.05503827056617, -70.456147941973143); + bool2x2 r0 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double a1 = (-239.62025677395064); + double2x2 b1 = double2x2(-185.99272426683115, -455.61258027312, 276.66581476697036, 79.39918831707871); + bool2x2 r1 = bool2x2(false, true, false, false); + TestUtils.AreEqual(a1 >= b1, r1); + + double a2 = (416.42054791768112); + double2x2 b2 = double2x2(379.27350801009379, -439.51472612820322, 67.141009600433108, -74.560638224035813); + bool2x2 r2 = bool2x2(true, true, true, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double a3 = (-367.25635474140586); + double2x2 b3 = double2x2(494.950765601802, -61.235545425319856, -429.17024846988278, -213.82468924942646); + bool2x2 r3 = bool2x2(false, false, true, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_add_wide_wide() + { + double2x2 a0 = double2x2(465.14837644302679, 278.91072548502621, -277.52992237616792, -65.197214395365336); + double2x2 b0 = double2x2(483.99436186440028, -204.07667193379098, -365.67356007437854, -509.92086076639634); + double2x2 r0 = double2x2(949.14273830742707, 74.834053551235229, -643.20348245054652, -575.11807516176168); + TestUtils.AreEqual(a0 + b0, r0); + + double2x2 a1 = double2x2(-473.32437561141529, -4.6955420992782138, -470.53676698661258, -109.95011453980118); + double2x2 b1 = double2x2(-270.69751108377125, 486.76397846954126, 267.49177587567442, 251.6425212601398); + double2x2 r1 = double2x2(-744.02188669518659, 482.06843637026304, -203.04499111093816, 141.69240672033862); + TestUtils.AreEqual(a1 + b1, r1); + + double2x2 a2 = double2x2(-178.70145782209067, -420.03378339299644, 290.71109236903078, -446.5296368294068); + double2x2 b2 = double2x2(244.4951094335388, -78.675763882079991, 352.20551340291536, 82.779185095233515); + double2x2 r2 = double2x2(65.793651611448126, -498.70954727507643, 642.91660577194614, -363.75045173417328); + TestUtils.AreEqual(a2 + b2, r2); + + double2x2 a3 = double2x2(491.066454400805, -261.11730039358014, -298.40688409395835, 502.42861890347149); + double2x2 b3 = double2x2(462.54732606492348, -405.492017696375, -428.4983238785054, -41.872599859662614); + double2x2 r3 = double2x2(953.6137804657285, -666.6093180899552, -726.90520797246381, 460.55601904380887); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_add_wide_scalar() + { + double2x2 a0 = double2x2(459.89829728561369, -447.66336104258119, -94.438627525436971, 126.42986279652916); + double b0 = (500.99725913489112); + double2x2 r0 = double2x2(960.89555642050482, 53.333898092309937, 406.55863160945415, 627.42712193142029); + TestUtils.AreEqual(a0 + b0, r0); + + double2x2 a1 = double2x2(-36.254356162741033, -2.7912590516690443, -478.41478489265535, 443.11525246273504); + double b1 = (-349.64130060264904); + double2x2 r1 = double2x2(-385.89565676539007, -352.43255965431808, -828.05608549530439, 93.473951860086); + TestUtils.AreEqual(a1 + b1, r1); + + double2x2 a2 = double2x2(268.092225914864, -471.25607584009697, -2.6649749291431704, 78.985822952811532); + double b2 = (41.32102133767728); + double2x2 r2 = double2x2(309.41324725254128, -429.93505450241969, 38.65604640853411, 120.30684429048881); + TestUtils.AreEqual(a2 + b2, r2); + + double2x2 a3 = double2x2(202.14799151297098, 10.345855002452595, -151.24445898423181, 355.23276703210206); + double b3 = (311.7254551908585); + double2x2 r3 = double2x2(513.87344670382947, 322.07131019331109, 160.48099620662668, 666.95822222296056); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_add_scalar_wide() + { + double a0 = (-325.51276484388518); + double2x2 b0 = double2x2(-264.08813178915909, -106.00925998855814, -355.44729320865463, -447.33029362528134); + double2x2 r0 = double2x2(-589.60089663304427, -431.52202483244332, -680.96005805253981, -772.84305846916652); + TestUtils.AreEqual(a0 + b0, r0); + + double a1 = (-158.70021040677102); + double2x2 b1 = double2x2(-199.48369154682553, 180.31809123806568, 337.57936898692481, -37.05501486596421); + double2x2 r1 = double2x2(-358.18390195359655, 21.617880831294656, 178.87915858015378, -195.75522527273523); + TestUtils.AreEqual(a1 + b1, r1); + + double a2 = (230.80498014707348); + double2x2 b2 = double2x2(-140.17433339924287, 18.02419591789328, -138.61435825126915, 26.904163611542458); + double2x2 r2 = double2x2(90.63064674783061, 248.82917606496676, 92.190621895804327, 257.70914375861594); + TestUtils.AreEqual(a2 + b2, r2); + + double a3 = (-374.53758233345); + double2x2 b3 = double2x2(154.4676006559597, 268.3838204203098, -190.96302255939833, 188.61725362977813); + double2x2 r3 = double2x2(-220.06998167749032, -106.15376191314022, -565.50060489284829, -185.92032870367188); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_sub_wide_wide() + { + double2x2 a0 = double2x2(133.37101680290471, -131.8321183341705, -197.29314407952739, -485.286571013409); + double2x2 b0 = double2x2(123.46028739002543, 359.56010048443454, -48.24847819667707, 478.97904680621764); + double2x2 r0 = double2x2(9.9107294128792773, -491.39221881860504, -149.04466588285032, -964.26561781962664); + TestUtils.AreEqual(a0 - b0, r0); + + double2x2 a1 = double2x2(-337.55033103448818, 471.66710470228782, 146.5066197600712, -130.58504372955537); + double2x2 b1 = double2x2(207.15832886805686, 142.36730462981723, -125.60551005490379, -65.299004823574307); + double2x2 r1 = double2x2(-544.708659902545, 329.29980007247059, 272.112129814975, -65.286038905981059); + TestUtils.AreEqual(a1 - b1, r1); + + double2x2 a2 = double2x2(110.77707367333448, -235.54160486699158, 78.879356659427, -347.68616811730254); + double2x2 b2 = double2x2(-477.876434787119, 164.50000031501986, 428.00958915614035, 72.6278169493321); + double2x2 r2 = double2x2(588.65350846045351, -400.04160518201144, -349.13023249671335, -420.31398506663464); + TestUtils.AreEqual(a2 - b2, r2); + + double2x2 a3 = double2x2(-470.82054565419469, -11.459293609233271, -167.94791730118351, 330.67676917215658); + double2x2 b3 = double2x2(-446.880505531505, 432.09146114443035, -225.55465637219822, -112.45196705332586); + double2x2 r3 = double2x2(-23.940040122689709, -443.55075475366363, 57.606739071014715, 443.12873622548244); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_sub_wide_scalar() + { + double2x2 a0 = double2x2(48.936717294592768, 410.45158953706346, -364.44171612544062, 163.98060353285666); + double b0 = (-291.59041442144212); + double2x2 r0 = double2x2(340.52713171603489, 702.04200395850557, -72.8513017039985, 455.57101795429878); + TestUtils.AreEqual(a0 - b0, r0); + + double2x2 a1 = double2x2(-460.06732318367222, 204.35834441164434, 180.26971420099483, -377.92569344952972); + double b1 = (110.91942339340198); + double2x2 r1 = double2x2(-570.9867465770742, 93.438921018242354, 69.350290807592842, -488.8451168429317); + TestUtils.AreEqual(a1 - b1, r1); + + double2x2 a2 = double2x2(-470.26204297983185, 461.50756499800252, -246.28726660753006, 21.605312595891405); + double b2 = (400.53491968686455); + double2x2 r2 = double2x2(-870.79696266669634, 60.972645311137967, -646.82218629439467, -378.92960709097315); + TestUtils.AreEqual(a2 - b2, r2); + + double2x2 a3 = double2x2(246.35072171238755, -122.71842413894757, -122.93872099879138, 360.15095417581074); + double b3 = (-121.42736178330489); + double2x2 r3 = double2x2(367.77808349569244, -1.29106235564268, -1.5113592154864932, 481.57831595911563); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_sub_scalar_wide() + { + double a0 = (294.58645905861); + double2x2 b0 = double2x2(452.35251757705237, 256.98980891750648, -275.159888634067, -89.027518075437968); + double2x2 r0 = double2x2(-157.76605851844238, 37.59665014110351, 569.746347692677, 383.61397713404796); + TestUtils.AreEqual(a0 - b0, r0); + + double a1 = (488.22838829840919); + double2x2 b1 = double2x2(-333.21728030462623, -64.232989102710519, -66.041730196234653, 341.20492831859963); + double2x2 r1 = double2x2(821.44566860303541, 552.46137740111976, 554.27011849464384, 147.02345997980956); + TestUtils.AreEqual(a1 - b1, r1); + + double a2 = (-385.775056303374); + double2x2 b2 = double2x2(75.394746577085357, 354.94371645289641, 169.13141520746581, 88.216608326982964); + double2x2 r2 = double2x2(-461.16980288045937, -740.71877275627048, -554.90647151083976, -473.991664630357); + TestUtils.AreEqual(a2 - b2, r2); + + double a3 = (1.7350065716240124); + double2x2 b3 = double2x2(122.53803997977548, -264.94502771317264, -50.837180399725753, -347.65032283759228); + double2x2 r3 = double2x2(-120.80303340815146, 266.68003428479665, 52.572186971349765, 349.3853294092163); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_mul_wide_wide() + { + double2x2 a0 = double2x2(-394.78053898121254, -412.37219519744264, -25.874570143350638, -241.04595886964626); + double2x2 b0 = double2x2(-149.76397831261346, -345.04538671348496, -284.33404721148963, 267.97923648915219); + double2x2 r0 = double2x2(59123.904078224172, 142287.1235617903, 7357.0212487164608, -64595.312016683383); + TestUtils.AreEqual(a0 * b0, r0); + + double2x2 a1 = double2x2(-93.675987525692221, 244.15999257013198, 494.68846606402121, 53.537962700025105); + double2x2 b1 = double2x2(-326.64849558782225, -150.68967754705329, 207.73243794577775, 366.19289248352538); + double2x2 r1 = double2x2(30599.120397970968, -36792.390550284115, 102762.84107913627, 19605.221418797286); + TestUtils.AreEqual(a1 * b1, r1); + + double2x2 a2 = double2x2(-239.49641167349017, 236.67584644848284, -211.85620818466703, -216.65482030466887); + double2x2 b2 = double2x2(358.88076202891807, 214.85359368792433, 253.42280900358355, -307.71382751488773); + double2x2 r2 = double2x2(-85950.654724573629, 50850.6561485879, -53689.195383006307, 66667.684005499876); + TestUtils.AreEqual(a2 * b2, r2); + + double2x2 a3 = double2x2(467.95832870339893, -178.02191146557311, -386.3942503344241, -422.43540521265726); + double2x2 b3 = double2x2(184.4711149597872, 426.43644185850235, -144.28142625851621, 459.47961518703016); + double2x2 r3 = double2x2(86324.794650634591, -75915.030498228327, 55749.513536340863, -194100.45742848891); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_mul_wide_scalar() + { + double2x2 a0 = double2x2(328.20302191758674, -290.10672272839895, 236.99572454998065, 120.48136692889102); + double b0 = (192.21119055161773); + double2x2 r0 = double2x2(63084.293585418032, -55761.758562653624, 45553.230371395039, 23157.866976688449); + TestUtils.AreEqual(a0 * b0, r0); + + double2x2 a1 = double2x2(357.90315811610924, -477.31047104173825, -438.272912467957, -46.729179165665585); + double b1 = (134.86723214707672); + double2x2 r1 = double2x2(48269.408311817213, -64373.542104216656, -59108.654629591387, -6302.235054578161); + TestUtils.AreEqual(a1 * b1, r1); + + double2x2 a2 = double2x2(-238.40500103608008, -48.83483722099794, 355.30832998608628, 119.35660391643489); + double b2 = (422.08249374017237); + double2x2 r2 = double2x2(-100626.57735743705, -20612.3298756342, 149969.42596718337, 50378.333025406864); + TestUtils.AreEqual(a2 * b2, r2); + + double2x2 a3 = double2x2(-196.995807977857, -325.55215683837991, 53.937323833786536, -87.4509838034636); + double b3 = (98.2360046367329); + double2x2 r3 = double2x2(-19352.081105929705, -31980.943188673486, 5298.5871942288177, -8590.8352504039049); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_mul_scalar_wide() + { + double a0 = (-464.534700371574); + double2x2 b0 = double2x2(329.36093846399376, -198.68342671109525, 184.07942518223047, 256.01618754864489); + double2x2 r0 = double2x2(-152999.58486347177, 92295.346096036214, -85511.280621599, -118928.40297318244); + TestUtils.AreEqual(a0 * b0, r0); + + double a1 = (266.22629297255833); + double2x2 b1 = double2x2(-97.894749448585685, 159.74810583877752, -351.82222263506719, 491.80157660497423); + double2x2 r1 = double2x2(-26062.156247174364, 42529.146026845636, -93664.326117500037, 130930.51061760196); + TestUtils.AreEqual(a1 * b1, r1); + + double a2 = (49.902031206480274); + double2x2 b2 = double2x2(424.46256871915546, 160.11807616060514, -395.99208492599058, 125.20168858636248); + double2x2 r2 = double2x2(21181.544350206073, 7990.2172332881028, -19760.809379495968, 6247.8185709406853); + TestUtils.AreEqual(a2 * b2, r2); + + double a3 = (-265.01581991138676); + double2x2 b3 = double2x2(314.65609779705107, -292.71202029507236, -37.729878681586058, 165.3622206027444); + double2x2 r3 = double2x2(-83388.843747802981, 77573.316056417083, 9999.0147339576815, -43823.604475403918); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_div_wide_wide() + { + double2x2 a0 = double2x2(246.26574933075619, -269.85612953354428, -451.61952588130697, -7.38850236283082); + double2x2 b0 = double2x2(172.11981423763552, -77.141104972521362, -325.8353723612779, -450.60868117334724); + double2x2 r0 = double2x2(1.4307809383918566, 3.4982144685336105, 1.3860359070548143, 0.016396715535066435); + TestUtils.AreEqual(a0 / b0, r0); + + double2x2 a1 = double2x2(-308.20558681534862, -373.394808704683, 360.41863482092447, 25.80972458133931); + double2x2 b1 = double2x2(-261.26215398556656, -122.44949847201326, -93.210781379235357, -442.00522705633438); + double2x2 r1 = double2x2(1.1796794220427942, 3.0493780159501847, -3.8667054335113131, -0.05839235149599218); + TestUtils.AreEqual(a1 / b1, r1); + + double2x2 a2 = double2x2(-274.050461181463, 127.53858977534742, -447.6717600522897, -137.4586017771897); + double2x2 b2 = double2x2(484.36271380091216, -390.78178686219348, 402.02531714086672, 316.65072193585831); + double2x2 r2 = double2x2(-0.56579594872388561, -0.32636779415802974, -1.1135412148569459, -0.43410165287743668); + TestUtils.AreEqual(a2 / b2, r2); + + double2x2 a3 = double2x2(-136.13317424437645, 12.43763423545181, 228.51298319013461, 356.9723681681661); + double2x2 b3 = double2x2(397.15440744774151, -303.26218643005109, -118.59124451437555, -81.650312223308845); + double2x2 r3 = double2x2(-0.3427714050039572, -0.041012809351094658, -1.9268959030313104, -4.37196574572633); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_div_wide_scalar() + { + double2x2 a0 = double2x2(-244.51745116175965, 69.112274917360537, -333.02311888943575, 257.39682519500923); + double b0 = (-60.024377612408443); + double2x2 r0 = double2x2(4.0736357608014941, -1.1514034408425655, 5.5481311449798705, -4.2882048166676752); + TestUtils.AreEqual(a0 / b0, r0); + + double2x2 a1 = double2x2(403.24561257066466, 131.52659160062979, -261.88639200007844, -348.92380516087815); + double b1 = (154.34436066185322); + double2x2 r1 = double2x2(2.6126358672353378, 0.85216324740743876, -1.6967668327956258, -2.2606838608462096); + TestUtils.AreEqual(a1 / b1, r1); + + double2x2 a2 = double2x2(-275.53868187383688, 287.64239968342815, 504.37224626185946, 491.78708600056689); + double b2 = (210.55792174607416); + double2x2 r2 = double2x2(-1.308612279171939, 1.3660963087882074, 2.39540855114497, 2.3356380131527215); + TestUtils.AreEqual(a2 / b2, r2); + + double2x2 a3 = double2x2(-26.63160015392657, 272.89512098622276, 178.09617313095191, -460.87559030059521); + double b3 = (-253.23667275776933); + double2x2 r3 = double2x2(0.10516486361910435, -1.0776287573769281, -0.70327954948810989, 1.8199401582781043); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_div_scalar_wide() + { + double a0 = (41.737658758525527); + double2x2 b0 = double2x2(-422.676129776368, 248.12963235011773, 449.39137741988122, 245.85813796047967); + double2x2 r0 = double2x2(-0.098746193168297289, 0.1682090863683405, 0.092875967042706856, 0.16976317767945767); + TestUtils.AreEqual(a0 / b0, r0); + + double a1 = (-326.62061253498337); + double2x2 b1 = double2x2(163.71510489457989, 333.664472020075, 38.291076916405473, -472.97976062864984); + double2x2 r1 = double2x2(-1.9950548408181534, -0.97888939316060053, -8.5299406242357652, 0.69055938482624146); + TestUtils.AreEqual(a1 / b1, r1); + + double a2 = (192.23013958345643); + double2x2 b2 = double2x2(-200.29686960964318, -490.18150376257557, -211.10257468517057, -322.85234108700058); + double2x2 r2 = double2x2(-0.95972613030893628, -0.3921611446125986, -0.91060063985548412, -0.59541194261204144); + TestUtils.AreEqual(a2 / b2, r2); + + double a3 = (-137.98529035317961); + double2x2 b3 = double2x2(84.32973555677097, 355.06345550858578, 276.42724455354141, -382.9880213136729); + double2x2 r3 = double2x2(-1.6362590187453818, -0.38862149346102726, -0.49917398907636662, 0.36028617782843814); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_mod_wide_wide() + { + double2x2 a0 = double2x2(-442.30985924336585, 368.50046246522129, -1.0938966279355213, -364.67383473211612); + double2x2 b0 = double2x2(-43.245045443645211, -144.19587690392319, -62.640481739603217, -336.82826510855381); + double2x2 r0 = double2x2(-9.8594048069137443, 80.1087086573749, -1.0938966279355213, -27.845569623562312); + TestUtils.AreEqual(a0 % b0, r0); + + double2x2 a1 = double2x2(-197.34394487987458, -34.034902350062, -101.34858350704826, 208.31857142612273); + double2x2 b1 = double2x2(-154.6102545981343, -154.02935583611452, 487.0462093237071, -469.82909105244516); + double2x2 r1 = double2x2(-42.73369028174028, -34.034902350062, -101.34858350704826, 208.31857142612273); + TestUtils.AreEqual(a1 % b1, r1); + + double2x2 a2 = double2x2(-140.77031404374645, 183.446989383291, -463.36838100076113, 83.839106360375467); + double2x2 b2 = double2x2(-145.20377237405802, -203.38401780062543, -22.520082245823062, 224.6900237652892); + double2x2 r2 = double2x2(-140.77031404374645, 183.446989383291, -12.966736084299896, 83.839106360375467); + TestUtils.AreEqual(a2 % b2, r2); + + double2x2 a3 = double2x2(-64.714058190916717, 295.06681050689281, 212.257051805154, 349.62829916068745); + double2x2 b3 = double2x2(-435.62674614210925, 12.095571285158144, 40.378765363422531, 345.78484813579587); + double2x2 r3 = double2x2(-64.714058190916717, 4.773099663097355, 10.363224988041338, 3.8434510248915785); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_mod_wide_scalar() + { + double2x2 a0 = double2x2(-433.41699548876704, -5.5141427542614565, 393.39439958771425, 299.41153277988155); + double b0 = (-90.499235433758827); + double2x2 r0 = double2x2(-71.420053753731736, -5.5141427542614565, 31.39745785267894, 27.913826478605074); + TestUtils.AreEqual(a0 % b0, r0); + + double2x2 a1 = double2x2(-120.80601626299602, -450.80766245853511, 186.09479698263794, -84.473635951277629); + double b1 = (-502.939041133476); + double2x2 r1 = double2x2(-120.80601626299602, -450.80766245853511, 186.09479698263794, -84.473635951277629); + TestUtils.AreEqual(a1 % b1, r1); + + double2x2 a2 = double2x2(-318.78148356023314, -54.6001856581309, -172.33886607565864, -429.71466728193434); + double b2 = (433.45469041981482); + double2x2 r2 = double2x2(-318.78148356023314, -54.6001856581309, -172.33886607565864, -429.71466728193434); + TestUtils.AreEqual(a2 % b2, r2); + + double2x2 a3 = double2x2(222.36186109406958, 254.51082885196, -433.09369703433185, -203.08261284748215); + double b3 = (5.796394112425105); + double2x2 r3 = double2x2(2.09888482191559, 5.2658820176804966, -4.16053271487408, -0.20881891260347629); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_mod_scalar_wide() + { + double a0 = (-396.4224028049141); + double2x2 b0 = double2x2(-159.14024384279747, 230.17333399046834, 14.779358632294134, -303.15649738123477); + double2x2 r0 = double2x2(-78.141915119319151, -166.24906881444576, -12.159078365266623, -93.265905423679328); + TestUtils.AreEqual(a0 % b0, r0); + + double a1 = (399.63502020371845); + double2x2 b1 = double2x2(206.69470534412881, 397.04482263934096, -393.89064735634747, -372.06709426085797); + double2x2 r1 = double2x2(192.94031485958965, 2.5901975643774904, 5.7443728473709825, 27.567925942860484); + TestUtils.AreEqual(a1 % b1, r1); + + double a2 = (201.01229796233224); + double2x2 b2 = double2x2(-95.5668547598491, -258.95146882671463, 106.98357563232241, 469.3235559264773); + double2x2 r2 = double2x2(9.8785884426340544, 201.01229796233224, 94.028722330009828, 201.01229796233224); + TestUtils.AreEqual(a2 % b2, r2); + + double a3 = (-34.808985011097491); + double2x2 b3 = double2x2(184.83653434777466, 374.79425376224992, -131.87271911086174, -120.09286003936683); + double2x2 r3 = double2x2(-34.808985011097491, -34.808985011097491, -34.808985011097491, -34.808985011097491); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2x2_operator_plus() + { + double2x2 a0 = double2x2(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045); + double2x2 r0 = double2x2(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045); + TestUtils.AreEqual(+a0, r0); + + double2x2 a1 = double2x2(315.44952860262686, 190.32466015141677, -350.30858270745193, -320.51845875406565); + double2x2 r1 = double2x2(315.44952860262686, 190.32466015141677, -350.30858270745193, -320.51845875406565); + TestUtils.AreEqual(+a1, r1); + + double2x2 a2 = double2x2(102.0544069288552, -428.77622075973835, 377.23016208095021, 234.77393042052813); + double2x2 r2 = double2x2(102.0544069288552, -428.77622075973835, 377.23016208095021, 234.77393042052813); + TestUtils.AreEqual(+a2, r2); + + double2x2 a3 = double2x2(34.283600107898792, 465.35593555185756, 309.59316530339106, -316.93713655925222); + double2x2 r3 = double2x2(34.283600107898792, 465.35593555185756, 309.59316530339106, -316.93713655925222); + TestUtils.AreEqual(+a3, r3); + } + + [TestCompiler] + public static void double2x2_operator_neg() + { + double2x2 a0 = double2x2(420.22718854445372, -196.25749811728366, -335.42683068636188, 509.04366969924592); + double2x2 r0 = double2x2(-420.22718854445372, 196.25749811728366, 335.42683068636188, -509.04366969924592); + TestUtils.AreEqual(-a0, r0); + + double2x2 a1 = double2x2(-33.014395013923945, -495.8379526063045, -270.85946787095605, 19.686896571743773); + double2x2 r1 = double2x2(33.014395013923945, 495.8379526063045, 270.85946787095605, -19.686896571743773); + TestUtils.AreEqual(-a1, r1); + + double2x2 a2 = double2x2(268.23670662019254, 223.38126312167446, -410.39206070936848, -395.68154186554324); + double2x2 r2 = double2x2(-268.23670662019254, -223.38126312167446, 410.39206070936848, 395.68154186554324); + TestUtils.AreEqual(-a2, r2); + + double2x2 a3 = double2x2(-349.14948885010062, -238.21960913307015, 292.54351224216794, 469.29257867731735); + double2x2 r3 = double2x2(349.14948885010062, 238.21960913307015, -292.54351224216794, -469.29257867731735); + TestUtils.AreEqual(-a3, r3); + } + + [TestCompiler] + public static void double2x2_operator_prefix_inc() + { + double2x2 a0 = double2x2(-99.79557113526181, 458.74185082816609, 96.179026886904126, -48.552469514567633); + double2x2 r0 = double2x2(-98.79557113526181, 459.74185082816609, 97.179026886904126, -47.552469514567633); + TestUtils.AreEqual(++a0, r0); + + double2x2 a1 = double2x2(-315.728967098393, -323.61485853959567, -456.89028832730384, -76.507656371457358); + double2x2 r1 = double2x2(-314.728967098393, -322.61485853959567, -455.89028832730384, -75.507656371457358); + TestUtils.AreEqual(++a1, r1); + + double2x2 a2 = double2x2(-305.58477344437722, 148.67930967578627, 363.2849182390072, -115.5592263283018); + double2x2 r2 = double2x2(-304.58477344437722, 149.67930967578627, 364.2849182390072, -114.5592263283018); + TestUtils.AreEqual(++a2, r2); + + double2x2 a3 = double2x2(-326.87781992874937, 339.8765849265626, -38.410431164507941, -153.3736775635619); + double2x2 r3 = double2x2(-325.87781992874937, 340.8765849265626, -37.410431164507941, -152.3736775635619); + TestUtils.AreEqual(++a3, r3); + } + + [TestCompiler] + public static void double2x2_operator_postfix_inc() + { + double2x2 a0 = double2x2(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888); + double2x2 r0 = double2x2(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888); + TestUtils.AreEqual(a0++, r0); + + double2x2 a1 = double2x2(-31.420532002775246, 271.45466840986842, 55.736877228942149, 153.75031645305); + double2x2 r1 = double2x2(-31.420532002775246, 271.45466840986842, 55.736877228942149, 153.75031645305); + TestUtils.AreEqual(a1++, r1); + + double2x2 a2 = double2x2(-174.17301925186672, 215.11022744658874, 159.86103184514729, -333.05045262586816); + double2x2 r2 = double2x2(-174.17301925186672, 215.11022744658874, 159.86103184514729, -333.05045262586816); + TestUtils.AreEqual(a2++, r2); + + double2x2 a3 = double2x2(241.46487509527469, -170.10464366250886, -270.65246380057766, -162.86024792625579); + double2x2 r3 = double2x2(241.46487509527469, -170.10464366250886, -270.65246380057766, -162.86024792625579); + TestUtils.AreEqual(a3++, r3); + } + + [TestCompiler] + public static void double2x2_operator_prefix_dec() + { + double2x2 a0 = double2x2(-416.20121712992022, -96.637880131899351, -50.145671629414721, -207.31644759295341); + double2x2 r0 = double2x2(-417.20121712992022, -97.637880131899351, -51.145671629414721, -208.31644759295341); + TestUtils.AreEqual(--a0, r0); + + double2x2 a1 = double2x2(439.47906156977592, 337.96895734312432, 246.08898293510492, 171.96452935597142); + double2x2 r1 = double2x2(438.47906156977592, 336.96895734312432, 245.08898293510492, 170.96452935597142); + TestUtils.AreEqual(--a1, r1); + + double2x2 a2 = double2x2(-227.44280134301761, 326.50782338087811, 400.720900006928, -478.03137253133178); + double2x2 r2 = double2x2(-228.44280134301761, 325.50782338087811, 399.720900006928, -479.03137253133178); + TestUtils.AreEqual(--a2, r2); + + double2x2 a3 = double2x2(-326.45297852459038, 112.79684668071422, -341.97629300783217, -503.27416181158003); + double2x2 r3 = double2x2(-327.45297852459038, 111.79684668071422, -342.97629300783217, -504.27416181158003); + TestUtils.AreEqual(--a3, r3); + } + + [TestCompiler] + public static void double2x2_operator_postfix_dec() + { + double2x2 a0 = double2x2(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555); + double2x2 r0 = double2x2(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555); + TestUtils.AreEqual(a0--, r0); + + double2x2 a1 = double2x2(409.55752940175944, -281.11170376516492, -262.062590959511, -182.40572866350681); + double2x2 r1 = double2x2(409.55752940175944, -281.11170376516492, -262.062590959511, -182.40572866350681); + TestUtils.AreEqual(a1--, r1); + + double2x2 a2 = double2x2(450.12809559801974, -332.15495768755443, -261.00890052551819, 205.46112570793423); + double2x2 r2 = double2x2(450.12809559801974, -332.15495768755443, -261.00890052551819, 205.46112570793423); + TestUtils.AreEqual(a2--, r2); + + double2x2 a3 = double2x2(-230.22777878038016, 378.64123433578811, 487.34482287212495, -192.17785772689518); + double2x2 r3 = double2x2(-230.22777878038016, 378.64123433578811, 487.34482287212495, -192.17785772689518); + 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/TestDouble2x2.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/TestDouble2x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..0aee2fe45b730fb85a6a964fcb5e1f457c44ef28 --- /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/TestDouble2x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: eb8a44886606504469cf3329b4993591 +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/TestDouble2x3.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/TestDouble2x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..997a37642e5bf019dce1f20f12de6bfcc30882f6 --- /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/TestDouble2x3.gen.cs @@ -0,0 +1,943 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestDouble2x3 + { + [TestCompiler] + public static void double2x3_zero() + { + TestUtils.AreEqual(double2x3.zero.c0.x, 0.0); + TestUtils.AreEqual(double2x3.zero.c0.y, 0.0); + TestUtils.AreEqual(double2x3.zero.c1.x, 0.0); + TestUtils.AreEqual(double2x3.zero.c1.y, 0.0); + TestUtils.AreEqual(double2x3.zero.c2.x, 0.0); + TestUtils.AreEqual(double2x3.zero.c2.y, 0.0); + } + + [TestCompiler] + public static void double2x3_operator_equal_wide_wide() + { + double2x3 a0 = double2x3(-135.18925172425304, -49.094127439471947, 169.12980778940482, 240.80529772527757, 314.73919382446411, 442.39301916695808); + double2x3 b0 = double2x3(-220.01464591734793, 66.980020792679852, 499.20158576369363, -371.113114291389, 208.44865212610398, 390.80369133074009); + bool2x3 r0 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double2x3 a1 = double2x3(177.92444881141398, 335.53340283759564, 168.1544516869609, 350.72955982327903, 367.17843668869625, 46.941470406456574); + double2x3 b1 = double2x3(-72.443806920407269, 362.97643273089841, 194.6783255053117, 471.6448635867074, -404.04466719368691, -144.69675476136467); + bool2x3 r1 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double2x3 a2 = double2x3(188.76415094582558, -97.211392209497944, -293.3210057193977, -234.82292353120766, 417.03371329653714, 26.386443388828297); + double2x3 b2 = double2x3(-494.44664334433463, -252.97038209297244, 234.41711746641306, 398.72397465199413, 260.42872083393331, 370.14420502732708); + bool2x3 r2 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double2x3 a3 = double2x3(269.24572265764959, 29.474191440955792, 479.48521469509467, -237.23094355186026, -221.98371349181224, -506.67253255596034); + double2x3 b3 = double2x3(89.579862397899774, -434.81684347373289, -109.84533815730612, 336.9730161805511, -409.15498156526826, 500.38755273278218); + bool2x3 r3 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_equal_wide_scalar() + { + double2x3 a0 = double2x3(65.671194345537174, 404.41550440546848, -269.7301577393572, 83.630607882342588, 152.99450476141385, -155.86829836474186); + double b0 = (-155.8157547245807); + bool2x3 r0 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double2x3 a1 = double2x3(314.67125597348024, 290.04894007837811, -132.63519460178691, -65.667489797653388, -69.683271678948415, -191.19075521789063); + double b1 = (386.36515325417986); + bool2x3 r1 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double2x3 a2 = double2x3(186.84520086406042, -319.14406481345372, -49.701092981594172, -300.88189925853248, 333.39685193328046, 386.377503336583); + double b2 = (-232.89569221851218); + bool2x3 r2 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double2x3 a3 = double2x3(-296.70189084517858, 141.54237968360189, -227.32334314441465, 83.872881689981, -410.91687483848858, 110.50128345866744); + double b3 = (-309.11719741910565); + bool2x3 r3 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_equal_scalar_wide() + { + double a0 = (36.383921878591195); + double2x3 b0 = double2x3(-400.48919958644046, -71.286823544319191, 156.97811491646712, -225.23872791288363, 499.14180993435059, -211.97992358542047); + bool2x3 r0 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double a1 = (428.31192394174263); + double2x3 b1 = double2x3(-489.50133322621758, -5.6915457275190988, -30.865948453017495, -362.98307221149241, 184.50319322594589, -160.47062142215231); + bool2x3 r1 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double a2 = (316.66882315122928); + double2x3 b2 = double2x3(390.36923879681581, 505.10510301268891, -294.64870967280524, 443.19909283295226, 96.559236333034619, -257.01294601010761); + bool2x3 r2 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double a3 = (-245.05497538533757); + double2x3 b3 = double2x3(326.46485176983515, -23.959890138339176, -168.6948808025079, 386.24859279498855, -227.09065185631192, -336.61242524562982); + bool2x3 r3 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_not_equal_wide_wide() + { + double2x3 a0 = double2x3(279.99414576217259, -43.342018386042696, -465.72473523846116, 317.46655645848557, 85.714987079480238, 360.89050572034466); + double2x3 b0 = double2x3(-460.912120318465, -476.00904844515446, 468.13642070635058, -341.01254312182431, -62.658060341448561, -458.80166718866752); + bool2x3 r0 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double2x3 a1 = double2x3(366.08152668833804, 154.5428384070018, 332.426219856565, 397.11323160543725, -431.3749584776233, 489.01079319837072); + double2x3 b1 = double2x3(-457.73023316717251, -59.523265627922171, 3.024243117787023, 155.81276352508587, -19.839918384253963, -6.0169332055453992); + bool2x3 r1 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double2x3 a2 = double2x3(398.43358320669904, -489.81794594685454, 171.4049242340983, -67.829682620162941, -192.27871498478515, 227.84082494854965); + double2x3 b2 = double2x3(-406.20792145571107, -102.42070083619126, -40.362921018322425, 452.67542645552919, 93.257571979080126, -258.37806689849964); + bool2x3 r2 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double2x3 a3 = double2x3(62.138187675801191, 262.18648755838467, -404.05309052209049, 34.449567572423007, -204.79578719138902, -285.41180314003111); + double2x3 b3 = double2x3(-184.04980405794913, -379.23531192319251, -370.68729537105526, -255.94724023339677, 29.055771602809273, 322.40763226263584); + bool2x3 r3 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_not_equal_wide_scalar() + { + double2x3 a0 = double2x3(-155.44111282911206, -19.426602134214079, 174.63305409934048, 507.9207296352464, 59.177048472304364, 171.15146430356026); + double b0 = (-393.41354173860213); + bool2x3 r0 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double2x3 a1 = double2x3(-58.923273352404692, 492.20105361016522, -165.24150879925185, 270.34102333259818, -380.24326222960059, 501.8990516615562); + double b1 = (-398.17684835855704); + bool2x3 r1 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double2x3 a2 = double2x3(-134.34545642433011, 46.771004937016869, 161.45995123752391, 261.51423442620512, -145.61239559278471, -0.44992661497087738); + double b2 = (458.40042302496749); + bool2x3 r2 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double2x3 a3 = double2x3(350.46143047439932, 242.66402232025939, 382.67707675633812, -468.96794221781562, -497.45947789468778, -80.932258882062627); + double b3 = (202.22103724359579); + bool2x3 r3 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_not_equal_scalar_wide() + { + double a0 = (478.35313938481409); + double2x3 b0 = double2x3(459.55319592894671, 436.45324369727314, -488.71416806090349, 392.76794475725296, -266.73665369056937, 338.55788270503183); + bool2x3 r0 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double a1 = (-338.10012475498957); + double2x3 b1 = double2x3(-152.3145445102428, -452.82067868338, 209.43931422449612, 50.107968592135194, 372.4343656843688, -488.0213141329686); + bool2x3 r1 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double a2 = (489.74075697816011); + double2x3 b2 = double2x3(270.40006149485714, -472.8467831429312, -286.85046090132113, -384.69186681541237, 443.42352959300558, 358.74720900074919); + bool2x3 r2 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double a3 = (-15.414077527548216); + double2x3 b3 = double2x3(-342.17916194637269, 468.96750400446706, -130.56808501601597, 401.7858013593526, -268.35225761511936, -239.231014124691); + bool2x3 r3 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_less_wide_wide() + { + double2x3 a0 = double2x3(51.710243010758518, -313.85556450200062, 283.04767359562572, 235.02188621974642, 44.0783565249659, -207.25566659088042); + double2x3 b0 = double2x3(-261.83523881707117, -19.810742149041403, -149.25882084167506, 205.99822316225539, -306.02438535635565, 102.12168006884008); + bool2x3 r0 = bool2x3(false, true, false, false, false, true); + TestUtils.AreEqual(a0 < b0, r0); + + double2x3 a1 = double2x3(3.3829410091894943, -144.30134326978651, -69.369597705718888, -135.66796762108243, -194.78736576567746, -33.473868147225062); + double2x3 b1 = double2x3(231.90633760760829, 179.49885305180158, 473.22488496882136, 15.891647107848712, 270.04990614114786, 490.91400240869916); + bool2x3 r1 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double2x3 a2 = double2x3(-19.675088653189619, 423.23796697297973, -71.698315415390937, -501.88598870760109, 7.6438391244242894, 302.26289214857991); + double2x3 b2 = double2x3(-185.73412164753961, 76.433086669274189, 97.75231246731812, 419.30080600236579, 73.953208242521214, 481.03232382285978); + bool2x3 r2 = bool2x3(false, false, true, true, true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double2x3 a3 = double2x3(-140.55051786291904, -436.586703265359, -351.441728040316, 364.97084896870467, 301.894133946809, 407.55097336673691); + double2x3 b3 = double2x3(7.00747371046225, -7.3240954910051528, -413.07575793428146, -154.1188920261892, 449.20288989003882, 502.01430797111914); + bool2x3 r3 = bool2x3(true, true, false, false, true, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_less_wide_scalar() + { + double2x3 a0 = double2x3(-221.86977325280651, -121.54646807608498, -97.52392511140738, 479.88107775146193, 67.118990214131259, 137.32880574899207); + double b0 = (199.06751808853244); + bool2x3 r0 = bool2x3(true, true, true, false, true, true); + TestUtils.AreEqual(a0 < b0, r0); + + double2x3 a1 = double2x3(282.96659601990439, -111.41316061439608, -288.08113278452356, 82.665427008022334, -361.64292042406413, -68.088202269788951); + double b1 = (258.27909362422258); + bool2x3 r1 = bool2x3(false, true, true, true, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double2x3 a2 = double2x3(12.788020378345664, -78.762971199472872, 25.727694284975428, 101.37087182950734, -330.442660724019, -48.920521520506838); + double b2 = (-66.703050406045747); + bool2x3 r2 = bool2x3(false, true, false, false, true, false); + TestUtils.AreEqual(a2 < b2, r2); + + double2x3 a3 = double2x3(359.60440914686978, 241.27682101040932, -183.43778165776178, 423.02713580756779, -334.62272349680904, -98.315578744893685); + double b3 = (-8.15008759878117); + bool2x3 r3 = bool2x3(false, false, true, false, true, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_less_scalar_wide() + { + double a0 = (-250.4849370692321); + double2x3 b0 = double2x3(-377.19654887597846, -505.14754104295167, 375.92672198634909, 110.17393474940855, -118.09757452742082, -40.45089079833167); + bool2x3 r0 = bool2x3(false, false, true, true, true, true); + TestUtils.AreEqual(a0 < b0, r0); + + double a1 = (-299.74430932651478); + double2x3 b1 = double2x3(31.437125935888389, -458.904539560389, 13.684679276163024, -458.50690839183841, 248.27646624682302, 389.23142999654237); + bool2x3 r1 = bool2x3(true, false, true, false, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double a2 = (488.74553679337055); + double2x3 b2 = double2x3(-221.63786731550368, -424.26720329013989, 249.05904948388184, -22.136127720650336, -442.24773928255206, -340.85755721705851); + bool2x3 r2 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a2 < b2, r2); + + double a3 = (-95.1117256130612); + double2x3 b3 = double2x3(15.409410245441563, 87.292497437117845, 495.06764220402931, 316.01850309782594, -125.56811505442863, 122.16476803746298); + bool2x3 r3 = bool2x3(true, true, true, true, false, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_greater_wide_wide() + { + double2x3 a0 = double2x3(-229.29066501804192, 505.536608216137, -73.80706862071861, 100.29203777215071, -419.21478124112582, -159.55974753180504); + double2x3 b0 = double2x3(-445.84502407808088, -420.03529210576568, 299.02440108872224, -13.880978829171966, 151.56173593903043, -163.5094302461992); + bool2x3 r0 = bool2x3(true, true, false, true, false, true); + TestUtils.AreEqual(a0 > b0, r0); + + double2x3 a1 = double2x3(-396.7703608929973, 127.03739482119556, 489.13989733585151, 51.91890885863404, 155.38475544535777, -135.63165027258526); + double2x3 b1 = double2x3(-391.09603733154762, 479.2837710228207, -77.674873149802409, -46.5841996886694, -415.37701888353422, 71.466978344818131); + bool2x3 r1 = bool2x3(false, false, true, true, true, false); + TestUtils.AreEqual(a1 > b1, r1); + + double2x3 a2 = double2x3(-425.97813554572787, -228.430505143679, 383.03834909155887, 136.53358298937496, 8.602427725029429, -251.3243674018068); + double2x3 b2 = double2x3(-206.06102643071722, 360.83628218287424, 236.96878658838978, 14.550342328171382, 364.735178402036, -159.0612996365229); + bool2x3 r2 = bool2x3(false, false, true, true, false, false); + TestUtils.AreEqual(a2 > b2, r2); + + double2x3 a3 = double2x3(-345.954920691417, -170.565928777012, -293.25441588706076, 139.1249764613458, 214.3030732675935, 238.76991211565678); + double2x3 b3 = double2x3(226.63117490831348, 182.79602512288659, 341.83937398616195, -79.130463875425278, -247.29681956362765, 164.58913882290437); + bool2x3 r3 = bool2x3(false, false, false, true, true, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_greater_wide_scalar() + { + double2x3 a0 = double2x3(11.156317000815761, -411.02322382993214, 385.88556188432756, -485.10304831206008, -491.18003033622171, 405.17534632476759); + double b0 = (-302.81693877969724); + bool2x3 r0 = bool2x3(true, false, true, false, false, true); + TestUtils.AreEqual(a0 > b0, r0); + + double2x3 a1 = double2x3(173.57509740329124, 501.30683183172107, -367.027771405423, -86.124509613087639, -489.09058998948456, -172.51816066192379); + double b1 = (69.269281181166548); + bool2x3 r1 = bool2x3(true, true, false, false, false, false); + TestUtils.AreEqual(a1 > b1, r1); + + double2x3 a2 = double2x3(-18.149639853346002, -238.8945134798505, -27.239137900638923, 471.77934072528933, 240.16453253485474, -481.47807930478734); + double b2 = (-236.41493498367021); + bool2x3 r2 = bool2x3(true, false, true, true, true, false); + TestUtils.AreEqual(a2 > b2, r2); + + double2x3 a3 = double2x3(185.59438547193747, -510.22814702905163, -183.28619607877278, -386.12766260007754, -13.638212448748845, -7.3478887115362568); + double b3 = (33.294723764664809); + bool2x3 r3 = bool2x3(true, false, false, false, false, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_greater_scalar_wide() + { + double a0 = (453.54610201974685); + double2x3 b0 = double2x3(-226.20441423459187, -423.46500487973213, 409.40550227156166, 453.87706277048073, 87.475727837288673, 113.79560308987072); + bool2x3 r0 = bool2x3(true, true, true, false, true, true); + TestUtils.AreEqual(a0 > b0, r0); + + double a1 = (176.40926154721956); + double2x3 b1 = double2x3(-140.44002944810319, -182.48286804113673, -158.29329188088576, -162.68531830733889, -193.328676075362, 230.18129955519987); + bool2x3 r1 = bool2x3(true, true, true, true, true, false); + TestUtils.AreEqual(a1 > b1, r1); + + double a2 = (-102.58784227379965); + double2x3 b2 = double2x3(392.5205878655056, -177.47865947404813, -10.295010809924008, -24.048938524000789, 172.44867499752377, 374.04800503982608); + bool2x3 r2 = bool2x3(false, true, false, false, false, false); + TestUtils.AreEqual(a2 > b2, r2); + + double a3 = (-368.99763958947619); + double2x3 b3 = double2x3(-210.19528804076617, 149.47022325800276, -281.34327019441093, -100.46916608720511, 304.86444320569956, -361.52483360912879); + bool2x3 r3 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_less_equal_wide_wide() + { + double2x3 a0 = double2x3(240.09053169940159, 462.2131528622532, 293.08251561461134, -427.87067361728782, -405.5227226715175, 204.59190211286386); + double2x3 b0 = double2x3(-81.203838624620744, 493.63743876555816, -411.47211451617636, 99.164449499530974, -295.66769875943089, -480.46254824123463); + bool2x3 r0 = bool2x3(false, true, false, true, true, false); + TestUtils.AreEqual(a0 <= b0, r0); + + double2x3 a1 = double2x3(294.670105832941, -327.56444445604666, -456.12326667091031, 282.3012408140587, 421.8811549720732, -311.71284809322697); + double2x3 b1 = double2x3(74.414040361723892, 260.916124226952, 306.17329730939741, 139.56480438055689, -505.75247955031341, -489.62680958659706); + bool2x3 r1 = bool2x3(false, true, true, false, false, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double2x3 a2 = double2x3(84.5674827492644, 447.24461647832982, -154.49435217422172, -424.36474986763892, 36.684489505684269, 267.07029283562224); + double2x3 b2 = double2x3(-280.03260267899958, 303.15991058161478, 511.19015788994272, -104.65973358259527, 95.1465771641333, -125.6363432992419); + bool2x3 r2 = bool2x3(false, false, true, true, true, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double2x3 a3 = double2x3(307.89391937288167, -351.76015369582927, -157.36036570247279, 152.70902712303632, 372.26716750313858, 202.36828837281485); + double2x3 b3 = double2x3(376.239777024947, -415.7747320680761, -47.481050275024529, 117.72210293529656, 469.37837264937275, -263.04235780567041); + bool2x3 r3 = bool2x3(true, false, true, false, true, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_less_equal_wide_scalar() + { + double2x3 a0 = double2x3(309.1924356469849, 69.673792633076118, -101.72418622939114, -315.97240629604664, -346.01106731314724, 424.15386577330241); + double b0 = (292.92427148154206); + bool2x3 r0 = bool2x3(false, true, true, true, true, false); + TestUtils.AreEqual(a0 <= b0, r0); + + double2x3 a1 = double2x3(-410.87006945669191, 183.82114538169515, 320.44249287268258, -257.87003791419329, -386.801748694294, -182.9388249772316); + double b1 = (-483.90265320423185); + bool2x3 r1 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double2x3 a2 = double2x3(349.25012962392077, 373.56911652794531, 259.15151822713744, 450.13007828692446, -128.5255282523695, -43.874866744445114); + double b2 = (485.31159304329731); + bool2x3 r2 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double2x3 a3 = double2x3(457.38574549992836, 479.45184038553941, -499.51644372358754, -398.13294643821797, 402.48485893871862, 87.9161055497434); + double b3 = (-77.638293064030961); + bool2x3 r3 = bool2x3(false, false, true, true, false, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_less_equal_scalar_wide() + { + double a0 = (-511.15238141974078); + double2x3 b0 = double2x3(51.159012579898786, 340.44369022010062, 312.81429519914752, 354.19252626699983, 136.39671165142056, -94.767871185563422); + bool2x3 r0 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double a1 = (288.544332877055); + double2x3 b1 = double2x3(304.04282369466625, -148.61806089646092, -506.30010127755816, 27.581254256694251, 48.471146844546865, 104.88351326104419); + bool2x3 r1 = bool2x3(true, false, false, false, false, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double a2 = (-488.6858386884843); + double2x3 b2 = double2x3(-480.43516968210935, 421.9366516647566, 239.72105299668431, -101.01844673092404, -283.95147551407638, -55.2435333986038); + bool2x3 r2 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double a3 = (-455.80483147865385); + double2x3 b3 = double2x3(131.10721618081777, -461.69878099006542, -388.48285001725094, -258.93605125087129, -225.2235287284588, -116.01998215355911); + bool2x3 r3 = bool2x3(true, false, true, true, true, true); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_greater_equal_wide_wide() + { + double2x3 a0 = double2x3(-386.59181302906563, -157.12078221008215, 391.01526445477054, -511.88687133783793, -5.4220387960886569, 287.64527501149348); + double2x3 b0 = double2x3(153.44301350109424, 49.892483019219981, 78.025787628267835, 138.81373292711271, -225.51057802211056, -339.35611335344436); + bool2x3 r0 = bool2x3(false, false, true, false, true, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double2x3 a1 = double2x3(-122.53520184500849, 7.4814426933794493, 152.94642765491574, 48.986223482054811, 57.338148859021317, 300.46493138953338); + double2x3 b1 = double2x3(-373.302078182484, 364.9358934671319, -322.71539870030961, 125.47818165900105, -25.776589167200314, 297.51890792395864); + bool2x3 r1 = bool2x3(true, false, true, false, true, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double2x3 a2 = double2x3(349.25705139211243, 85.749700824613569, -230.95330654408468, 418.7112159294594, -131.03991824530061, -126.51221257378916); + double2x3 b2 = double2x3(73.222349439385539, 462.78374288174496, 393.19134515951919, -95.001432224643168, 381.35702556248611, 93.031928344178937); + bool2x3 r2 = bool2x3(true, false, false, true, false, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double2x3 a3 = double2x3(-156.81847841889527, 422.37748761772059, -413.08933348818186, 219.44273553576443, 35.591133372667741, 447.18153521380464); + double2x3 b3 = double2x3(254.25326287665087, 90.672789377473691, 348.93816892660141, 161.33763106229605, 79.435611046587837, 420.24346824187944); + bool2x3 r3 = bool2x3(false, true, false, true, false, true); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_greater_equal_wide_scalar() + { + double2x3 a0 = double2x3(495.457423679278, -14.345115906719627, -463.47478053694346, 217.51749215718246, -246.86571776441565, -377.65869706573835); + double b0 = (189.20512804258851); + bool2x3 r0 = bool2x3(true, false, false, true, false, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double2x3 a1 = double2x3(53.815095211293169, -221.50546441856096, 252.99433410027734, -116.44038277326172, -395.36331028275345, 164.77259667439978); + double b1 = (-123.33294373533357); + bool2x3 r1 = bool2x3(true, false, true, true, false, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double2x3 a2 = double2x3(-287.00733889593153, 184.19556316369938, 273.01225555735277, -418.14240308205706, 249.38409697701411, 396.39213938098032); + double b2 = (355.83704559683667); + bool2x3 r2 = bool2x3(false, false, false, false, false, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double2x3 a3 = double2x3(332.66542044871744, -335.121477998384, -302.08690442800844, 254.44223344253476, 179.00504287472234, 71.176674637560154); + double b3 = (243.76141392614761); + bool2x3 r3 = bool2x3(true, false, false, true, false, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_greater_equal_scalar_wide() + { + double a0 = (215.43534169692327); + double2x3 b0 = double2x3(204.80295310020585, -101.10404853760451, -122.05503827056617, -70.456147941973143, -239.62025677395064, -185.99272426683115); + bool2x3 r0 = bool2x3(true, true, true, true, true, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double a1 = (-455.61258027312); + double2x3 b1 = double2x3(276.66581476697036, 79.39918831707871, 416.42054791768112, 379.27350801009379, -439.51472612820322, 67.141009600433108); + bool2x3 r1 = bool2x3(false, false, false, false, false, false); + TestUtils.AreEqual(a1 >= b1, r1); + + double a2 = (-74.560638224035813); + double2x3 b2 = double2x3(-367.25635474140586, 494.950765601802, -61.235545425319856, -429.17024846988278, -213.82468924942646, -264.31016242891093); + bool2x3 r2 = bool2x3(true, false, false, true, true, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double a3 = (243.11378275748052); + double2x3 b3 = double2x3(-22.383876095704693, 304.86197175870745, -323.68615332417477, 67.938025267765852, 125.30356818312009, -400.47050280145857); + bool2x3 r3 = bool2x3(true, false, true, true, true, true); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_add_wide_wide() + { + double2x3 a0 = double2x3(465.14837644302679, 278.91072548502621, -277.52992237616792, -65.197214395365336, -473.32437561141529, -4.6955420992782138); + double2x3 b0 = double2x3(483.99436186440028, -204.07667193379098, -365.67356007437854, -509.92086076639634, -270.69751108377125, 486.76397846954126); + double2x3 r0 = double2x3(949.14273830742707, 74.834053551235229, -643.20348245054652, -575.11807516176168, -744.02188669518659, 482.06843637026304); + TestUtils.AreEqual(a0 + b0, r0); + + double2x3 a1 = double2x3(-470.53676698661258, -109.95011453980118, -178.70145782209067, -420.03378339299644, 290.71109236903078, -446.5296368294068); + double2x3 b1 = double2x3(267.49177587567442, 251.6425212601398, 244.4951094335388, -78.675763882079991, 352.20551340291536, 82.779185095233515); + double2x3 r1 = double2x3(-203.04499111093816, 141.69240672033862, 65.793651611448126, -498.70954727507643, 642.91660577194614, -363.75045173417328); + TestUtils.AreEqual(a1 + b1, r1); + + double2x3 a2 = double2x3(491.066454400805, -261.11730039358014, -298.40688409395835, 502.42861890347149, 284.59432925125316, 401.12844366632794); + double2x3 b2 = double2x3(462.54732606492348, -405.492017696375, -428.4983238785054, -41.872599859662614, -269.9274958436971, 75.204465662690041); + double2x3 r2 = double2x3(953.6137804657285, -666.6093180899552, -726.90520797246381, 460.55601904380887, 14.666833407556055, 476.332909329018); + TestUtils.AreEqual(a2 + b2, r2); + + double2x3 a3 = double2x3(-36.263498084742366, -102.94915657069026, 503.19817161150195, -384.42911857386542, -45.22821452339565, -198.67394337368847); + double2x3 b3 = double2x3(-141.91339380196922, -222.1867559990784, 41.305726308983594, 148.33947117083676, -177.23311217931712, -176.51887830370987); + double2x3 r3 = double2x3(-178.17689188671159, -325.13591256976866, 544.50389792048554, -236.08964740302866, -222.46132670271277, -375.19282167739834); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_add_wide_scalar() + { + double2x3 a0 = double2x3(459.89829728561369, -447.66336104258119, -94.438627525436971, 126.42986279652916, -36.254356162741033, -349.64130060264904); + double b0 = (500.99725913489112); + double2x3 r0 = double2x3(960.89555642050482, 53.333898092309937, 406.55863160945415, 627.42712193142029, 464.74290297215009, 151.35595853224208); + TestUtils.AreEqual(a0 + b0, r0); + + double2x3 a1 = double2x3(-2.7912590516690443, 443.11525246273504, 268.092225914864, 41.32102133767728, -471.25607584009697, -2.6649749291431704); + double b1 = (-478.41478489265535); + double2x3 r1 = double2x3(-481.20604394432439, -35.299532429920305, -210.32255897779135, -437.09376355497807, -949.67086073275232, -481.07975982179852); + TestUtils.AreEqual(a1 + b1, r1); + + double2x3 a2 = double2x3(78.985822952811532, 311.7254551908585, 10.345855002452595, -151.24445898423181, 355.23276703210206, -197.80076584490052); + double b2 = (202.14799151297098); + double2x3 r2 = double2x3(281.13381446578251, 513.87344670382947, 212.49384651542357, 50.903532528739163, 557.380758545073, 4.34722566807045); + TestUtils.AreEqual(a2 + b2, r2); + + double2x3 a3 = double2x3(255.95526587961024, -181.6265695940827, -2.4549267303454485, 300.90065469448484, -236.49194895312746, -160.5840962680914); + double b3 = (244.14709793969394); + double2x3 r3 = double2x3(500.10236381930417, 62.52052834561124, 241.69217120934849, 545.04775263417878, 7.6551489865664735, 83.563001671602535); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_add_scalar_wide() + { + double a0 = (-325.51276484388518); + double2x3 b0 = double2x3(-264.08813178915909, -106.00925998855814, -355.44729320865463, -447.33029362528134, -158.70021040677102, -199.48369154682553); + double2x3 r0 = double2x3(-589.60089663304427, -431.52202483244332, -680.96005805253981, -772.84305846916652, -484.2129752506562, -524.9964563907107); + TestUtils.AreEqual(a0 + b0, r0); + + double a1 = (180.31809123806568); + double2x3 b1 = double2x3(337.57936898692481, -37.05501486596421, 230.80498014707348, -140.17433339924287, 18.02419591789328, -138.61435825126915); + double2x3 r1 = double2x3(517.89746022499048, 143.26307637210147, 411.12307138513916, 40.143757838822808, 198.34228715595896, 41.703732986796524); + TestUtils.AreEqual(a1 + b1, r1); + + double a2 = (26.904163611542458); + double2x3 b2 = double2x3(-374.53758233345, 154.4676006559597, 268.3838204203098, -190.96302255939833, 188.61725362977813, -504.91612386373623); + double2x3 r2 = double2x3(-347.63341872190756, 181.37176426750216, 295.28798403185226, -164.05885894785587, 215.52141724132059, -478.01196025219377); + TestUtils.AreEqual(a2 + b2, r2); + + double a3 = (20.454013595568995); + double2x3 b3 = double2x3(197.94534525552081, 251.41194474483461, -421.09037538109828, 111.44540052835146, -73.268883024001923, 480.88455770950975); + double2x3 r3 = double2x3(218.3993588510898, 271.86595834040361, -400.63636178552929, 131.89941412392045, -52.814869428432928, 501.33857130507874); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_sub_wide_wide() + { + double2x3 a0 = double2x3(133.37101680290471, -131.8321183341705, -197.29314407952739, -485.286571013409, -337.55033103448818, 471.66710470228782); + double2x3 b0 = double2x3(123.46028739002543, 359.56010048443454, -48.24847819667707, 478.97904680621764, 207.15832886805686, 142.36730462981723); + double2x3 r0 = double2x3(9.9107294128792773, -491.39221881860504, -149.04466588285032, -964.26561781962664, -544.708659902545, 329.29980007247059); + TestUtils.AreEqual(a0 - b0, r0); + + double2x3 a1 = double2x3(146.5066197600712, -130.58504372955537, 110.77707367333448, -235.54160486699158, 78.879356659427, -347.68616811730254); + double2x3 b1 = double2x3(-125.60551005490379, -65.299004823574307, -477.876434787119, 164.50000031501986, 428.00958915614035, 72.6278169493321); + double2x3 r1 = double2x3(272.112129814975, -65.286038905981059, 588.65350846045351, -400.04160518201144, -349.13023249671335, -420.31398506663464); + TestUtils.AreEqual(a1 - b1, r1); + + double2x3 a2 = double2x3(-470.82054565419469, -11.459293609233271, -167.94791730118351, 330.67676917215658, -508.35086822339838, -252.03190457636111); + double2x3 b2 = double2x3(-446.880505531505, 432.09146114443035, -225.55465637219822, -112.45196705332586, -210.61278853687122, -172.92506011432272); + double2x3 r2 = double2x3(-23.940040122689709, -443.55075475366363, 57.606739071014715, 443.12873622548244, -297.73807968652716, -79.1068444620384); + TestUtils.AreEqual(a2 - b2, r2); + + double2x3 a3 = double2x3(-427.93418737311578, 192.6576150360786, 168.42931016182024, 457.3087858899072, 470.05851457550125, -299.71188058504458); + double2x3 b3 = double2x3(-80.60749415336528, 270.04610861001822, -154.25558550388348, 148.47577745675846, 13.661130673094249, 70.671096596248049); + double2x3 r3 = double2x3(-347.3266932197505, -77.388493573939627, 322.68489566570372, 308.83300843314873, 456.397383902407, -370.38297718129263); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_sub_wide_scalar() + { + double2x3 a0 = double2x3(48.936717294592768, 410.45158953706346, -364.44171612544062, 163.98060353285666, -460.06732318367222, 110.91942339340198); + double b0 = (-291.59041442144212); + double2x3 r0 = double2x3(340.52713171603489, 702.04200395850557, -72.8513017039985, 455.57101795429878, -168.4769087622301, 402.5098378148441); + TestUtils.AreEqual(a0 - b0, r0); + + double2x3 a1 = double2x3(204.35834441164434, -377.92569344952972, -470.26204297983185, 400.53491968686455, 461.50756499800252, -246.28726660753006); + double b1 = (180.26971420099483); + double2x3 r1 = double2x3(24.088630210649512, -558.19540765052454, -650.53175718082662, 220.26520548586973, 281.2378507970077, -426.55698080852488); + TestUtils.AreEqual(a1 - b1, r1); + + double2x3 a2 = double2x3(21.605312595891405, -121.42736178330489, -122.71842413894757, -122.93872099879138, 360.15095417581074, 342.87457887403411); + double b2 = (246.35072171238755); + double2x3 r2 = double2x3(-224.74540911649615, -367.77808349569244, -369.06914585133512, -369.28944271117894, 113.80023246342319, 96.523857161646561); + TestUtils.AreEqual(a2 - b2, r2); + + double2x3 a3 = double2x3(18.929827460520869, 97.0436885808798, 485.9149813530571, -205.75765690848124, 253.44322717070725, -121.16305619159857); + double b3 = (164.60235245740148); + double2x3 r3 = double2x3(-145.67252499688061, -67.558663876521678, 321.31262889565562, -370.36000936588272, 88.840874713305766, -285.76540864900005); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_sub_scalar_wide() + { + double a0 = (294.58645905861); + double2x3 b0 = double2x3(452.35251757705237, 256.98980891750648, -275.159888634067, -89.027518075437968, 488.22838829840919, -333.21728030462623); + double2x3 r0 = double2x3(-157.76605851844238, 37.59665014110351, 569.746347692677, 383.61397713404796, -193.6419292397992, 627.80373936323622); + TestUtils.AreEqual(a0 - b0, r0); + + double a1 = (-64.232989102710519); + double2x3 b1 = double2x3(-66.041730196234653, 341.20492831859963, -385.775056303374, 75.394746577085357, 354.94371645289641, 169.13141520746581); + double2x3 r1 = double2x3(1.8087410935241337, -405.43791742131015, 321.5420672006635, -139.62773567979588, -419.17670555560693, -233.36440431017633); + TestUtils.AreEqual(a1 - b1, r1); + + double a2 = (88.216608326982964); + double2x3 b2 = double2x3(1.7350065716240124, 122.53803997977548, -264.94502771317264, -50.837180399725753, -347.65032283759228, 4.0655586738445209); + double2x3 r2 = double2x3(86.481601755358952, -34.321431652792512, 353.1616360401556, 139.05378872670872, 435.86693116457525, 84.151049653138443); + TestUtils.AreEqual(a2 - b2, r2); + + double a3 = (-79.095424450512724); + double2x3 b3 = double2x3(354.35833923628479, -292.4925116470514, -53.208983207684469, -246.34760033634848, 299.20334138497867, 432.18467422583353); + double2x3 r3 = double2x3(-433.45376368679752, 213.39708719653868, -25.886441242828255, 167.25217588583575, -378.29876583549139, -511.28009867634626); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_mul_wide_wide() + { + double2x3 a0 = double2x3(-394.78053898121254, -412.37219519744264, -25.874570143350638, -241.04595886964626, -93.675987525692221, 244.15999257013198); + double2x3 b0 = double2x3(-149.76397831261346, -345.04538671348496, -284.33404721148963, 267.97923648915219, -326.64849558782225, -150.68967754705329); + double2x3 r0 = double2x3(59123.904078224172, 142287.1235617903, 7357.0212487164608, -64595.312016683383, 30599.120397970968, -36792.390550284115); + TestUtils.AreEqual(a0 * b0, r0); + + double2x3 a1 = double2x3(494.68846606402121, 53.537962700025105, -239.49641167349017, 236.67584644848284, -211.85620818466703, -216.65482030466887); + double2x3 b1 = double2x3(207.73243794577775, 366.19289248352538, 358.88076202891807, 214.85359368792433, 253.42280900358355, -307.71382751488773); + double2x3 r1 = double2x3(102762.84107913627, 19605.221418797286, -85950.654724573629, 50850.6561485879, -53689.195383006307, 66667.684005499876); + TestUtils.AreEqual(a1 * b1, r1); + + double2x3 a2 = double2x3(467.95832870339893, -178.02191146557311, -386.3942503344241, -422.43540521265726, 464.58952758488692, -251.3156646468284); + double2x3 b2 = double2x3(184.4711149597872, 426.43644185850235, -144.28142625851621, 459.47961518703016, -358.31334917541284, -201.36521563370025); + double2x3 r2 = double2x3(86324.794650634591, -75915.030498228327, 55749.513536340863, -194100.45742848891, -166468.62962076368, 50606.233003735295); + TestUtils.AreEqual(a2 * b2, r2); + + double2x3 a3 = double2x3(-104.97877912641445, -66.934159071619717, -39.829896707008572, 401.56559080703448, 434.14618250082538, -336.45419589451245); + double2x3 b3 = double2x3(254.90996539541982, 168.52096303204121, 8.7945530455533572, -194.84647974504458, -405.36266178887462, -180.7321890242082); + double2x3 r3 = double2x3(-26760.136954367728, -11279.808946489193, -350.28613938869785, -78243.6417554897, -175986.65214401312, 60808.103330394995); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_mul_wide_scalar() + { + double2x3 a0 = double2x3(328.20302191758674, -290.10672272839895, 236.99572454998065, 120.48136692889102, 357.90315811610924, 134.86723214707672); + double b0 = (192.21119055161773); + double2x3 r0 = double2x3(63084.293585418032, -55761.758562653624, 45553.230371395039, 23157.866976688449, 68792.992123681237, 25922.99125739103); + TestUtils.AreEqual(a0 * b0, r0); + + double2x3 a1 = double2x3(-477.31047104173825, -46.729179165665585, -238.40500103608008, 422.08249374017237, -48.83483722099794, 355.30832998608628); + double b1 = (-438.272912467957); + double2x3 r1 = double2x3(209192.25029491508, 20480.133450173231, 104486.45415100912, -184987.32383324357, 21402.986338745359, -155722.01660712797); + TestUtils.AreEqual(a1 * b1, r1); + + double2x3 a2 = double2x3(119.35660391643489, 98.2360046367329, -325.55215683837991, 53.937323833786536, -87.4509838034636, -130.47412949915702); + double b2 = (-196.995807977857); + double2x3 r2 = double2x3(-23512.750626011144, -19352.081105929705, 64132.410175310673, -10625.426688800102, 17227.4772128218, 25702.856560893983); + TestUtils.AreEqual(a2 * b2, r2); + + double2x3 a3 = double2x3(-222.59457145565869, 293.36108769726059, 174.38195737375963, -327.12007704708731, 56.629123475695565, 257.54154241156834); + double b3 = (126.01503211167415); + double2x3 r3 = double2x3(-28050.262069869175, 36967.906886485951, 21974.747958150911, -41222.047013462026, 7136.1208132457368, 32454.105737083875); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_mul_scalar_wide() + { + double a0 = (-464.534700371574); + double2x3 b0 = double2x3(329.36093846399376, -198.68342671109525, 184.07942518223047, 256.01618754864489, 266.22629297255833, -97.894749448585685); + double2x3 r0 = double2x3(-152999.58486347177, 92295.346096036214, -85511.280621599, -118928.40297318244, -123671.35123704225, 45475.508103049062); + TestUtils.AreEqual(a0 * b0, r0); + + double a1 = (159.74810583877752); + double2x3 b1 = double2x3(-351.82222263506719, 491.80157660497423, 49.902031206480274, 424.46256871915546, 160.11807616060514, -395.99208492599058); + double2x3 r1 = double2x3(-56202.933657940659, 78564.37031116907, 7971.75496274279, 67807.091352347023, 25578.559377205791, -63258.985494075321); + TestUtils.AreEqual(a1 * b1, r1); + + double a2 = (125.20168858636248); + double2x3 b2 = double2x3(-265.01581991138676, 314.65609779705107, -292.71202029507236, -37.729878681586058, 165.3622206027444, 356.51773302467438); + double2x3 r2 = double2x3(-33180.428155004964, 39395.4747681864, -36648.039210468662, -4723.8445210931741, 20703.629247854176, 44636.6221856712); + TestUtils.AreEqual(a2 * b2, r2); + + double a3 = (-188.81332906932261); + double2x3 b3 = double2x3(504.91572475103465, 40.572113771257932, -206.77510581108515, -61.602680473403382, 118.97158938225903, 53.7483275186961); + double2x3 r3 = double2x3(-95334.818889692615, -7660.55586853052, 39041.896096852419, 11631.407179777047, -22463.4218559328, -10148.400650713294); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_div_wide_wide() + { + double2x3 a0 = double2x3(246.26574933075619, -269.85612953354428, -451.61952588130697, -7.38850236283082, -308.20558681534862, -373.394808704683); + double2x3 b0 = double2x3(172.11981423763552, -77.141104972521362, -325.8353723612779, -450.60868117334724, -261.26215398556656, -122.44949847201326); + double2x3 r0 = double2x3(1.4307809383918566, 3.4982144685336105, 1.3860359070548143, 0.016396715535066435, 1.1796794220427942, 3.0493780159501847); + TestUtils.AreEqual(a0 / b0, r0); + + double2x3 a1 = double2x3(360.41863482092447, 25.80972458133931, -274.050461181463, 127.53858977534742, -447.6717600522897, -137.4586017771897); + double2x3 b1 = double2x3(-93.210781379235357, -442.00522705633438, 484.36271380091216, -390.78178686219348, 402.02531714086672, 316.65072193585831); + double2x3 r1 = double2x3(-3.8667054335113131, -0.05839235149599218, -0.56579594872388561, -0.32636779415802974, -1.1135412148569459, -0.43410165287743668); + TestUtils.AreEqual(a1 / b1, r1); + + double2x3 a2 = double2x3(-136.13317424437645, 12.43763423545181, 228.51298319013461, 356.9723681681661, -24.762040865031111, 411.66839356518744); + double2x3 b2 = double2x3(397.15440744774151, -303.26218643005109, -118.59124451437555, -81.650312223308845, -84.346871176896116, -488.41943549011808); + double2x3 r2 = double2x3(-0.3427714050039572, -0.041012809351094658, -1.9268959030313104, -4.37196574572633, 0.29357391115432163, -0.84285833783843456); + TestUtils.AreEqual(a2 / b2, r2); + + double2x3 a3 = double2x3(-204.07890067066944, 11.365393882321882, 82.152295389283609, 37.389483230835481, 394.26582903147948, -429.91279645912016); + double2x3 b3 = double2x3(404.16049999937434, -136.72883731533256, -19.832707652744261, -102.6072290421497, 166.11604960547572, -112.84016590604568); + double2x3 r3 = double2x3(-0.50494519051462317, -0.083123605125890912, -4.1422632162843458, -0.36439423985883462, 2.3734361006528726, 3.8099270149698223); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_div_wide_scalar() + { + double2x3 a0 = double2x3(-244.51745116175965, 69.112274917360537, -333.02311888943575, 257.39682519500923, 403.24561257066466, 154.34436066185322); + double b0 = (-60.024377612408443); + double2x3 r0 = double2x3(4.0736357608014941, -1.1514034408425655, 5.5481311449798705, -4.2882048166676752, -6.7180307170282818, -2.5713612835520117); + TestUtils.AreEqual(a0 / b0, r0); + + double2x3 a1 = double2x3(131.52659160062979, -348.92380516087815, -275.53868187383688, 210.55792174607416, 287.64239968342815, 504.37224626185946); + double b1 = (-261.88639200007844); + double2x3 r1 = double2x3(-0.50222766672271535, 1.332347979198452, 1.0521305813925388, -0.80400482109055549, -1.0983480183397309, -1.9259200236020984); + TestUtils.AreEqual(a1 / b1, r1); + + double2x3 a2 = double2x3(491.78708600056689, -253.23667275776933, 272.89512098622276, 178.09617313095191, -460.87559030059521, -502.64601611655485); + double b2 = (-26.63160015392657); + double2x3 r2 = double2x3(-18.466298801353012, 9.50887934987384, -10.247041837851679, -6.6874003853160646, 17.305591389056794, 18.874044864421883); + TestUtils.AreEqual(a2 / b2, r2); + + double2x3 a3 = double2x3(-84.324793139623864, 83.796309271732525, 197.04206690427009, 317.16826525198678, 403.38711781212464, 81.646461763254592); + double b3 = (-174.69034036187935); + double2x3 r3 = double2x3(0.48271010844069023, -0.47968484747436224, -1.1279505580908942, -1.815602766558, -2.309155257105167, -0.4673782282072384); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_div_scalar_wide() + { + double a0 = (41.737658758525527); + double2x3 b0 = double2x3(-422.676129776368, 248.12963235011773, 449.39137741988122, 245.85813796047967, -326.62061253498337, 163.71510489457989); + double2x3 r0 = double2x3(-0.098746193168297289, 0.1682090863683405, 0.092875967042706856, 0.16976317767945767, -0.12778635871933872, 0.25494079355354177); + TestUtils.AreEqual(a0 / b0, r0); + + double a1 = (333.664472020075); + double2x3 b1 = double2x3(38.291076916405473, -472.97976062864984, 192.23013958345643, -200.29686960964318, -490.18150376257557, -211.10257468517057); + double2x3 r1 = double2x3(8.7138962622678129, -0.70545190258583745, 1.7357552397511267, -1.6658496594098089, -0.68069576158811729, -1.5805798319498852); + TestUtils.AreEqual(a1 / b1, r1); + + double a2 = (-322.85234108700058); + double2x3 b2 = double2x3(-137.98529035317961, 84.32973555677097, 355.06345550858578, 276.42724455354141, -382.9880213136729, -488.647160996053); + double2x3 r2 = double2x3(2.3397591167916914, -3.8284519565421338, -0.909280682306641, -1.1679468918067049, 0.8429828692281206, 0.660706470552089); + TestUtils.AreEqual(a2 / b2, r2); + + double a3 = (344.84603826368505); + double2x3 b3 = double2x3(168.85499938244698, -44.19558837087618, 420.550703959796, -175.6152060849663, -9.2205684227964753, -344.19428865248074); + double2x3 r3 = double2x3(2.0422613456805525, -7.8027253618582941, 0.81998682921394372, -1.9636456657223711, -37.399650699527896, -1.0018935514989395); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_mod_wide_wide() + { + double2x3 a0 = double2x3(-442.30985924336585, 368.50046246522129, -1.0938966279355213, -364.67383473211612, -197.34394487987458, -34.034902350062); + double2x3 b0 = double2x3(-43.245045443645211, -144.19587690392319, -62.640481739603217, -336.82826510855381, -154.6102545981343, -154.02935583611452); + double2x3 r0 = double2x3(-9.8594048069137443, 80.1087086573749, -1.0938966279355213, -27.845569623562312, -42.73369028174028, -34.034902350062); + TestUtils.AreEqual(a0 % b0, r0); + + double2x3 a1 = double2x3(-101.34858350704826, 208.31857142612273, -140.77031404374645, 183.446989383291, -463.36838100076113, 83.839106360375467); + double2x3 b1 = double2x3(487.0462093237071, -469.82909105244516, -145.20377237405802, -203.38401780062543, -22.520082245823062, 224.6900237652892); + double2x3 r1 = double2x3(-101.34858350704826, 208.31857142612273, -140.77031404374645, 183.446989383291, -12.966736084299896, 83.839106360375467); + TestUtils.AreEqual(a1 % b1, r1); + + double2x3 a2 = double2x3(-64.714058190916717, 295.06681050689281, 212.257051805154, 349.62829916068745, 119.87592106679267, -37.805828350505692); + double2x3 b2 = double2x3(-435.62674614210925, 12.095571285158144, 40.378765363422531, 345.78484813579587, -433.47126146474443, -355.64996712079733); + double2x3 r2 = double2x3(-64.714058190916717, 4.773099663097355, 10.363224988041338, 3.8434510248915785, 119.87592106679267, -37.805828350505692); + TestUtils.AreEqual(a2 % b2, r2); + + double2x3 a3 = double2x3(142.41158515886013, 332.24425593588694, -464.19427249589671, -296.14783801517814, 225.17535863871467, -212.06027732233531); + double2x3 b3 = double2x3(4.0154273528677322, 66.659781725453058, -221.85363088448236, -355.05676405274158, 357.93597118832918, 71.375334057666009); + double2x3 r3 = double2x3(1.8716278084895066, 65.605129034074707, -20.487010726932, -296.14783801517814, 225.17535863871467, -69.309609207003291); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_mod_wide_scalar() + { + double2x3 a0 = double2x3(-433.41699548876704, -5.5141427542614565, 393.39439958771425, 299.41153277988155, -120.80601626299602, -502.939041133476); + double b0 = (-90.499235433758827); + double2x3 r0 = double2x3(-71.420053753731736, -5.5141427542614565, 31.39745785267894, 27.913826478605074, -30.306780829237198, -50.442863964681862); + TestUtils.AreEqual(a0 % b0, r0); + + double2x3 a1 = double2x3(-450.80766245853511, -84.473635951277629, -318.78148356023314, 433.45469041981482, -54.6001856581309, -172.33886607565864); + double b1 = (186.09479698263794); + double2x3 r1 = double2x3(-78.618068493259216, -84.473635951277629, -132.6866865775952, 61.265096454538934, -54.6001856581309, -172.33886607565864); + TestUtils.AreEqual(a1 % b1, r1); + + double2x3 a2 = double2x3(-429.71466728193434, 5.796394112425105, 254.51082885196, -433.09369703433185, -203.08261284748215, -75.356399809641971); + double b2 = (222.36186109406958); + double2x3 r2 = double2x3(-207.35280618786476, 5.796394112425105, 32.148967757890432, -210.73183594026227, -203.08261284748215, -75.356399809641971); + TestUtils.AreEqual(a2 % b2, r2); + + double2x3 a3 = double2x3(252.28909385031511, 5.3372299696026175, -279.06042803407666, 483.55059097872606, -331.99334660730949, 335.99997655302286); + double b3 = (-69.403906139267576); + double2x3 r3 = double2x3(44.077375432512383, 5.3372299696026175, -1.44480347700636, 67.1271541431206, -54.377722050239186, 58.384351995952557); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_mod_scalar_wide() + { + double a0 = (-396.4224028049141); + double2x3 b0 = double2x3(-159.14024384279747, 230.17333399046834, 14.779358632294134, -303.15649738123477, 399.63502020371845, 206.69470534412881); + double2x3 r0 = double2x3(-78.141915119319151, -166.24906881444576, -12.159078365266623, -93.265905423679328, -396.4224028049141, -189.72769746078529); + TestUtils.AreEqual(a0 % b0, r0); + + double a1 = (397.04482263934096); + double2x3 b1 = double2x3(-393.89064735634747, -372.06709426085797, 201.01229796233224, -95.5668547598491, -258.95146882671463, 106.98357563232241); + double2x3 r1 = double2x3(3.1541752829934921, 24.977728378482993, 196.03252467700872, 14.777403599944591, 138.09335381262633, 76.094095742373725); + TestUtils.AreEqual(a1 % b1, r1); + + double a2 = (469.3235559264773); + double2x3 b2 = double2x3(-34.808985011097491, 184.83653434777466, 374.79425376224992, -131.87271911086174, -120.09286003936683, 4.506670715523228); + double2x3 r2 = double2x3(16.806750782209917, 99.650487230927979, 94.529302164227374, 73.705398593892085, 109.04497580837682, 0.62980151206159007); + TestUtils.AreEqual(a2 % b2, r2); + + double a3 = (-111.40195732535886); + double2x3 b3 = double2x3(391.54249710195813, -218.66887078931035, 196.37741980160467, -511.03262233689082, 499.95350598727987, -433.52306505363578); + double2x3 r3 = double2x3(-111.40195732535886, -111.40195732535886, -111.40195732535886, -111.40195732535886, -111.40195732535886, -111.40195732535886); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2x3_operator_plus() + { + double2x3 a0 = double2x3(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045, 315.44952860262686, 319.22218742930431); + double2x3 r0 = double2x3(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045, 315.44952860262686, 319.22218742930431); + TestUtils.AreEqual(+a0, r0); + + double2x3 a1 = double2x3(190.32466015141677, -320.51845875406565, 102.0544069288552, -107.00351267075331, -428.77622075973835, 377.23016208095021); + double2x3 r1 = double2x3(190.32466015141677, -320.51845875406565, 102.0544069288552, -107.00351267075331, -428.77622075973835, 377.23016208095021); + TestUtils.AreEqual(+a1, r1); + + double2x3 a2 = double2x3(234.77393042052813, 258.33039414991174, 465.35593555185756, 309.59316530339106, -316.93713655925222, -230.05266557915724); + double2x3 r2 = double2x3(234.77393042052813, 258.33039414991174, 465.35593555185756, 309.59316530339106, -316.93713655925222, -230.05266557915724); + TestUtils.AreEqual(+a2, r2); + + double2x3 a3 = double2x3(301.78512229667285, 350.24640981771347, 60.819777278611355, -472.44209526127304, -364.80255644619581, 239.15236937215195); + double2x3 r3 = double2x3(301.78512229667285, 350.24640981771347, 60.819777278611355, -472.44209526127304, -364.80255644619581, 239.15236937215195); + TestUtils.AreEqual(+a3, r3); + } + + [TestCompiler] + public static void double2x3_operator_neg() + { + double2x3 a0 = double2x3(420.22718854445372, -196.25749811728366, -335.42683068636188, 509.04366969924592, -33.014395013923945, -498.57532071442125); + double2x3 r0 = double2x3(-420.22718854445372, 196.25749811728366, 335.42683068636188, -509.04366969924592, 33.014395013923945, 498.57532071442125); + TestUtils.AreEqual(-a0, r0); + + double2x3 a1 = double2x3(-495.8379526063045, 19.686896571743773, 268.23670662019254, -180.60051473444349, 223.38126312167446, -410.39206070936848); + double2x3 r1 = double2x3(495.8379526063045, -19.686896571743773, -268.23670662019254, 180.60051473444349, -223.38126312167446, 410.39206070936848); + TestUtils.AreEqual(-a1, r1); + + double2x3 a2 = double2x3(-395.68154186554324, -110.9393032113739, -238.21960913307015, 292.54351224216794, 469.29257867731735, 48.290685914592245); + double2x3 r2 = double2x3(395.68154186554324, 110.9393032113739, 238.21960913307015, -292.54351224216794, -469.29257867731735, -48.290685914592245); + TestUtils.AreEqual(-a2, r2); + + double2x3 a3 = double2x3(88.7237785275671, 55.707977559281517, 464.54141090090457, 499.24280213715645, 175.01502259774838, 196.38759169186824); + double2x3 r3 = double2x3(-88.7237785275671, -55.707977559281517, -464.54141090090457, -499.24280213715645, -175.01502259774838, -196.38759169186824); + TestUtils.AreEqual(-a3, r3); + } + + [TestCompiler] + public static void double2x3_operator_prefix_inc() + { + double2x3 a0 = double2x3(-99.79557113526181, 458.74185082816609, 96.179026886904126, -48.552469514567633, -315.728967098393, -299.23014583216525); + double2x3 r0 = double2x3(-98.79557113526181, 459.74185082816609, 97.179026886904126, -47.552469514567633, -314.728967098393, -298.23014583216525); + TestUtils.AreEqual(++a0, r0); + + double2x3 a1 = double2x3(-323.61485853959567, -76.507656371457358, -305.58477344437722, 64.0964734852763, 148.67930967578627, 363.2849182390072); + double2x3 r1 = double2x3(-322.61485853959567, -75.507656371457358, -304.58477344437722, 65.0964734852763, 149.67930967578627, 364.2849182390072); + TestUtils.AreEqual(++a1, r1); + + double2x3 a2 = double2x3(-115.5592263283018, -179.89464839729231, 339.8765849265626, -38.410431164507941, -153.3736775635619, 261.62557304167444); + double2x3 r2 = double2x3(-114.5592263283018, -178.89464839729231, 340.8765849265626, -37.410431164507941, -152.3736775635619, 262.62557304167444); + TestUtils.AreEqual(++a2, r2); + + double2x3 a3 = double2x3(155.03081877298223, 301.30576791488829, -221.35540328796736, -429.69815011960367, -271.28932893988178, -264.38006246480165); + double2x3 r3 = double2x3(156.03081877298223, 302.30576791488829, -220.35540328796736, -428.69815011960367, -270.28932893988178, -263.38006246480165); + TestUtils.AreEqual(++a3, r3); + } + + [TestCompiler] + public static void double2x3_operator_postfix_inc() + { + double2x3 a0 = double2x3(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888, -31.420532002775246, 455.33662459595905); + double2x3 r0 = double2x3(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888, -31.420532002775246, 455.33662459595905); + TestUtils.AreEqual(a0++, r0); + + double2x3 a1 = double2x3(271.45466840986842, 153.75031645305, -174.17301925186672, -427.40105100506969, 215.11022744658874, 159.86103184514729); + double2x3 r1 = double2x3(271.45466840986842, 153.75031645305, -174.17301925186672, -427.40105100506969, 215.11022744658874, 159.86103184514729); + TestUtils.AreEqual(a1++, r1); + + double2x3 a2 = double2x3(-333.05045262586816, 287.22045649551808, -170.10464366250886, -270.65246380057766, -162.86024792625579, 454.48881003562769); + double2x3 r2 = double2x3(-333.05045262586816, 287.22045649551808, -170.10464366250886, -270.65246380057766, -162.86024792625579, 454.48881003562769); + TestUtils.AreEqual(a2++, r2); + + double2x3 a3 = double2x3(-449.92732045144186, -311.43587103087259, 69.731466087387616, -232.29964433996923, -341.49855271982892, 188.00656685047159); + double2x3 r3 = double2x3(-449.92732045144186, -311.43587103087259, 69.731466087387616, -232.29964433996923, -341.49855271982892, 188.00656685047159); + TestUtils.AreEqual(a3++, r3); + } + + [TestCompiler] + public static void double2x3_operator_prefix_dec() + { + double2x3 a0 = double2x3(-416.20121712992022, -96.637880131899351, -50.145671629414721, -207.31644759295341, 439.47906156977592, -304.40081920493435); + double2x3 r0 = double2x3(-417.20121712992022, -97.637880131899351, -51.145671629414721, -208.31644759295341, 438.47906156977592, -305.40081920493435); + TestUtils.AreEqual(--a0, r0); + + double2x3 a1 = double2x3(337.96895734312432, 171.96452935597142, -227.44280134301761, 298.28480710568135, 326.50782338087811, 400.720900006928); + double2x3 r1 = double2x3(336.96895734312432, 170.96452935597142, -228.44280134301761, 297.28480710568135, 325.50782338087811, 399.720900006928); + TestUtils.AreEqual(--a1, r1); + + double2x3 a2 = double2x3(-478.03137253133178, -24.584499132160317, 112.79684668071422, -341.97629300783217, -503.27416181158003, -79.635249413380052); + double2x3 r2 = double2x3(-479.03137253133178, -25.584499132160317, 111.79684668071422, -342.97629300783217, -504.27416181158003, -80.635249413380052); + TestUtils.AreEqual(--a2, r2); + + double2x3 a3 = double2x3(-131.0041454448384, -15.70865417258284, 188.75845274178243, 307.79193582562357, -406.667706917351, 181.47510703908051); + double2x3 r3 = double2x3(-132.0041454448384, -16.70865417258284, 187.75845274178243, 306.79193582562357, -407.667706917351, 180.47510703908051); + TestUtils.AreEqual(--a3, r3); + } + + [TestCompiler] + public static void double2x3_operator_postfix_dec() + { + double2x3 a0 = double2x3(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555, 409.55752940175944, 47.856652520530247); + double2x3 r0 = double2x3(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555, 409.55752940175944, 47.856652520530247); + TestUtils.AreEqual(a0--, r0); + + double2x3 a1 = double2x3(-281.11170376516492, -182.40572866350681, 450.12809559801974, -129.23265582380475, -332.15495768755443, -261.00890052551819); + double2x3 r1 = double2x3(-281.11170376516492, -182.40572866350681, 450.12809559801974, -129.23265582380475, -332.15495768755443, -261.00890052551819); + TestUtils.AreEqual(a1--, r1); + + double2x3 a2 = double2x3(205.46112570793423, -483.06653784358247, 378.64123433578811, 487.34482287212495, -192.17785772689518, -357.05418960985457); + double2x3 r2 = double2x3(205.46112570793423, -483.06653784358247, 378.64123433578811, 487.34482287212495, -192.17785772689518, -357.05418960985457); + TestUtils.AreEqual(a2--, r2); + + double2x3 a3 = double2x3(-396.30206627226528, 115.86774092347719, -20.823201427619551, 323.40538063803933, 379.15614026559342, 311.29903068733358); + double2x3 r3 = double2x3(-396.30206627226528, 115.86774092347719, -20.823201427619551, 323.40538063803933, 379.15614026559342, 311.29903068733358); + 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/TestDouble2x3.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/TestDouble2x3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..a38035f8c817ede622cb30330ec55f82d51ca6b0 --- /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/TestDouble2x3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: fa8d4556e4d042c4199dca8671bc2817 +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/TestDouble2x4.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/TestDouble2x4.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..47d9e2456bbc7b3579edea4de7f8f61acbc5e16d --- /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/TestDouble2x4.gen.cs @@ -0,0 +1,945 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestDouble2x4 + { + [TestCompiler] + public static void double2x4_zero() + { + TestUtils.AreEqual(double2x4.zero.c0.x, 0.0); + TestUtils.AreEqual(double2x4.zero.c0.y, 0.0); + TestUtils.AreEqual(double2x4.zero.c1.x, 0.0); + TestUtils.AreEqual(double2x4.zero.c1.y, 0.0); + TestUtils.AreEqual(double2x4.zero.c2.x, 0.0); + TestUtils.AreEqual(double2x4.zero.c2.y, 0.0); + TestUtils.AreEqual(double2x4.zero.c3.x, 0.0); + TestUtils.AreEqual(double2x4.zero.c3.y, 0.0); + } + + [TestCompiler] + public static void double2x4_operator_equal_wide_wide() + { + double2x4 a0 = double2x4(-135.18925172425304, -49.094127439471947, 169.12980778940482, 240.80529772527757, 314.73919382446411, 442.39301916695808, 177.92444881141398, 335.53340283759564); + double2x4 b0 = double2x4(-220.01464591734793, 66.980020792679852, 499.20158576369363, -371.113114291389, 208.44865212610398, 390.80369133074009, -72.443806920407269, 362.97643273089841); + bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double2x4 a1 = double2x4(168.1544516869609, 350.72955982327903, 367.17843668869625, 46.941470406456574, 188.76415094582558, -97.211392209497944, -293.3210057193977, -234.82292353120766); + double2x4 b1 = double2x4(194.6783255053117, 471.6448635867074, -404.04466719368691, -144.69675476136467, -494.44664334433463, -252.97038209297244, 234.41711746641306, 398.72397465199413); + bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double2x4 a2 = double2x4(417.03371329653714, 26.386443388828297, 269.24572265764959, 29.474191440955792, 479.48521469509467, -237.23094355186026, -221.98371349181224, -506.67253255596034); + double2x4 b2 = double2x4(260.42872083393331, 370.14420502732708, 89.579862397899774, -434.81684347373289, -109.84533815730612, 336.9730161805511, -409.15498156526826, 500.38755273278218); + bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double2x4 a3 = double2x4(-22.98943401453522, 487.26083802024868, -419.73195596213077, 337.20329324212082, 245.04388367619549, 390.21586984685428, 84.412977973191573, 434.20789142800868); + double2x4 b3 = double2x4(-174.08180888652885, 395.10115379612012, 350.33930723291792, -243.14458453056614, -416.39737267810727, 151.5764511337394, -18.224320181749931, -431.67792364194895); + bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_equal_wide_scalar() + { + double2x4 a0 = double2x4(65.671194345537174, 404.41550440546848, -269.7301577393572, 83.630607882342588, 152.99450476141385, -155.86829836474186, 314.67125597348024, 386.36515325417986); + double b0 = (-155.8157547245807); + bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double2x4 a1 = double2x4(290.04894007837811, -65.667489797653388, -69.683271678948415, -191.19075521789063, 186.84520086406042, -232.89569221851218, -319.14406481345372, -49.701092981594172); + double b1 = (-132.63519460178691); + bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double2x4 a2 = double2x4(-300.88189925853248, 386.377503336583, -296.70189084517858, -309.11719741910565, 141.54237968360189, -227.32334314441465, 83.872881689981, -410.91687483848858); + double b2 = (333.39685193328046); + bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double2x4 a3 = double2x4(110.50128345866744, 36.574313896044259, -427.54144235492754, -268.17085111707956, 175.81170590958175, -193.47994694182648, 291.05195368968509, 423.97165723516218); + double b3 = (-390.10359329269437); + bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_equal_scalar_wide() + { + double a0 = (36.383921878591195); + double2x4 b0 = double2x4(-400.48919958644046, -71.286823544319191, 156.97811491646712, -225.23872791288363, 499.14180993435059, -211.97992358542047, 428.31192394174263, -489.50133322621758); + bool2x4 r0 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double a1 = (-5.6915457275190988); + double2x4 b1 = double2x4(-30.865948453017495, -362.98307221149241, 184.50319322594589, -160.47062142215231, 316.66882315122928, 390.36923879681581, 505.10510301268891, -294.64870967280524); + bool2x4 r1 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double a2 = (443.19909283295226); + double2x4 b2 = double2x4(96.559236333034619, -257.01294601010761, -245.05497538533757, 326.46485176983515, -23.959890138339176, -168.6948808025079, 386.24859279498855, -227.09065185631192); + bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double a3 = (-336.61242524562982); + double2x4 b3 = double2x4(365.10812752559229, -405.39083952707745, -473.99549959320365, 298.43535174915348, -149.86322386090796, 450.06639191604518, 153.47643358701669, 56.287803437694834); + bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_not_equal_wide_wide() + { + double2x4 a0 = double2x4(279.99414576217259, -43.342018386042696, -465.72473523846116, 317.46655645848557, 85.714987079480238, 360.89050572034466, 366.08152668833804, 154.5428384070018); + double2x4 b0 = double2x4(-460.912120318465, -476.00904844515446, 468.13642070635058, -341.01254312182431, -62.658060341448561, -458.80166718866752, -457.73023316717251, -59.523265627922171); + bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double2x4 a1 = double2x4(332.426219856565, 397.11323160543725, -431.3749584776233, 489.01079319837072, 398.43358320669904, -489.81794594685454, 171.4049242340983, -67.829682620162941); + double2x4 b1 = double2x4(3.024243117787023, 155.81276352508587, -19.839918384253963, -6.0169332055453992, -406.20792145571107, -102.42070083619126, -40.362921018322425, 452.67542645552919); + bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double2x4 a2 = double2x4(-192.27871498478515, 227.84082494854965, 62.138187675801191, 262.18648755838467, -404.05309052209049, 34.449567572423007, -204.79578719138902, -285.41180314003111); + double2x4 b2 = double2x4(93.257571979080126, -258.37806689849964, -184.04980405794913, -379.23531192319251, -370.68729537105526, -255.94724023339677, 29.055771602809273, 322.40763226263584); + bool2x4 r2 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double2x4 a3 = double2x4(-72.206820760018559, 444.74925228801987, 238.81779991780309, 365.18011563139976, -437.92291351683571, -362.4426316518535, 445.95436665320506, -0.41746735592255391); + double2x4 b3 = double2x4(415.07170005099465, -467.72613189542949, -433.78467508488552, -212.16593585357344, 474.67491481950265, 452.48318621724991, -92.112742705323171, -385.92209190219739); + bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_not_equal_wide_scalar() + { + double2x4 a0 = double2x4(-155.44111282911206, -19.426602134214079, 174.63305409934048, 507.9207296352464, 59.177048472304364, 171.15146430356026, -58.923273352404692, -398.17684835855704); + double b0 = (-393.41354173860213); + bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double2x4 a1 = double2x4(492.20105361016522, 270.34102333259818, -380.24326222960059, 501.8990516615562, -134.34545642433011, 458.40042302496749, 46.771004937016869, 161.45995123752391); + double b1 = (-165.24150879925185); + bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double2x4 a2 = double2x4(261.51423442620512, -0.44992661497087738, 350.46143047439932, 202.22103724359579, 242.66402232025939, 382.67707675633812, -468.96794221781562, -497.45947789468778); + double b2 = (-145.61239559278471); + bool2x4 r2 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double2x4 a3 = double2x4(-80.932258882062627, -506.49033260088896, 449.34814640942409, 210.77098784724762, 249.18179690520367, -338.46854058768065, 229.67068420614612, -76.543291365980792); + double b3 = (-328.58774844211888); + bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_not_equal_scalar_wide() + { + double a0 = (478.35313938481409); + double2x4 b0 = double2x4(459.55319592894671, 436.45324369727314, -488.71416806090349, 392.76794475725296, -266.73665369056937, 338.55788270503183, -338.10012475498957, -152.3145445102428); + bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double a1 = (-452.82067868338); + double2x4 b1 = double2x4(209.43931422449612, 50.107968592135194, 372.4343656843688, -488.0213141329686, 489.74075697816011, 270.40006149485714, -472.8467831429312, -286.85046090132113); + bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double a2 = (-384.69186681541237); + double2x4 b2 = double2x4(443.42352959300558, 358.74720900074919, -15.414077527548216, -342.17916194637269, 468.96750400446706, -130.56808501601597, 401.7858013593526, -268.35225761511936); + bool2x4 r2 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double a3 = (-239.231014124691); + double2x4 b3 = double2x4(411.38655800902586, 139.76932460617707, 334.52206031164246, -223.62923036498449, -12.488468414400018, 113.46889238872984, -189.65225204716074, -212.84655127900027); + bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_less_wide_wide() + { + double2x4 a0 = double2x4(51.710243010758518, -313.85556450200062, 283.04767359562572, 235.02188621974642, 44.0783565249659, -207.25566659088042, 3.3829410091894943, -144.30134326978651); + double2x4 b0 = double2x4(-261.83523881707117, -19.810742149041403, -149.25882084167506, 205.99822316225539, -306.02438535635565, 102.12168006884008, 231.90633760760829, 179.49885305180158); + bool2x4 r0 = bool2x4(false, true, false, false, false, true, true, true); + TestUtils.AreEqual(a0 < b0, r0); + + double2x4 a1 = double2x4(-69.369597705718888, -135.66796762108243, -194.78736576567746, -33.473868147225062, -19.675088653189619, 423.23796697297973, -71.698315415390937, -501.88598870760109); + double2x4 b1 = double2x4(473.22488496882136, 15.891647107848712, 270.04990614114786, 490.91400240869916, -185.73412164753961, 76.433086669274189, 97.75231246731812, 419.30080600236579); + bool2x4 r1 = bool2x4(true, true, true, true, false, false, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double2x4 a2 = double2x4(7.6438391244242894, 302.26289214857991, -140.55051786291904, -436.586703265359, -351.441728040316, 364.97084896870467, 301.894133946809, 407.55097336673691); + double2x4 b2 = double2x4(73.953208242521214, 481.03232382285978, 7.00747371046225, -7.3240954910051528, -413.07575793428146, -154.1188920261892, 449.20288989003882, 502.01430797111914); + bool2x4 r2 = bool2x4(true, true, true, true, false, false, true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double2x4 a3 = double2x4(269.10777128353141, 462.98824737173891, 223.8841808884797, -287.18923319838439, 283.63862933015389, 511.86434650414822, -60.496787814654795, -234.30346142235373); + double2x4 b3 = double2x4(-382.31586259525079, 251.53517758638372, 143.17396957388803, 293.66033686961066, -292.76956691069972, -43.218204756834666, -353.41120044952777, 458.32604405764766); + bool2x4 r3 = bool2x4(false, false, false, true, false, false, false, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_less_wide_scalar() + { + double2x4 a0 = double2x4(-221.86977325280651, -121.54646807608498, -97.52392511140738, 479.88107775146193, 67.118990214131259, 137.32880574899207, 282.96659601990439, 258.27909362422258); + double b0 = (199.06751808853244); + bool2x4 r0 = bool2x4(true, true, true, false, true, true, false, false); + TestUtils.AreEqual(a0 < b0, r0); + + double2x4 a1 = double2x4(-111.41316061439608, 82.665427008022334, -361.64292042406413, -68.088202269788951, 12.788020378345664, -66.703050406045747, -78.762971199472872, 25.727694284975428); + double b1 = (-288.08113278452356); + bool2x4 r1 = bool2x4(false, false, true, false, false, false, false, false); + TestUtils.AreEqual(a1 < b1, r1); + + double2x4 a2 = double2x4(101.37087182950734, -48.920521520506838, 359.60440914686978, -8.15008759878117, 241.27682101040932, -183.43778165776178, 423.02713580756779, -334.62272349680904); + double b2 = (-330.442660724019); + bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, true); + TestUtils.AreEqual(a2 < b2, r2); + + double2x4 a3 = double2x4(-98.315578744893685, 297.92523850962766, -492.108162870681, -395.80724806143309, 95.788790032169231, -220.62145791790516, -455.37556740985048, 360.29156344025); + double b3 = (300.41017617863145); + bool2x4 r3 = bool2x4(true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_less_scalar_wide() + { + double a0 = (-250.4849370692321); + double2x4 b0 = double2x4(-377.19654887597846, -505.14754104295167, 375.92672198634909, 110.17393474940855, -118.09757452742082, -40.45089079833167, -299.74430932651478, 31.437125935888389); + bool2x4 r0 = bool2x4(false, false, true, true, true, true, false, true); + TestUtils.AreEqual(a0 < b0, r0); + + double a1 = (-458.904539560389); + double2x4 b1 = double2x4(13.684679276163024, -458.50690839183841, 248.27646624682302, 389.23142999654237, 488.74553679337055, -221.63786731550368, -424.26720329013989, 249.05904948388184); + bool2x4 r1 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double a2 = (-22.136127720650336); + double2x4 b2 = double2x4(-442.24773928255206, -340.85755721705851, -95.1117256130612, 15.409410245441563, 87.292497437117845, 495.06764220402931, 316.01850309782594, -125.56811505442863); + bool2x4 r2 = bool2x4(false, false, false, true, true, true, true, false); + TestUtils.AreEqual(a2 < b2, r2); + + double a3 = (122.16476803746298); + double2x4 b3 = double2x4(96.75540046429046, -228.90633808304852, -143.95269662884652, -230.238279688283, -327.61262885090548, 103.39802770661095, 434.488835775521, -157.45019228637693); + bool2x4 r3 = bool2x4(false, false, false, false, false, false, true, false); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_greater_wide_wide() + { + double2x4 a0 = double2x4(-229.29066501804192, 505.536608216137, -73.80706862071861, 100.29203777215071, -419.21478124112582, -159.55974753180504, -396.7703608929973, 127.03739482119556); + double2x4 b0 = double2x4(-445.84502407808088, -420.03529210576568, 299.02440108872224, -13.880978829171966, 151.56173593903043, -163.5094302461992, -391.09603733154762, 479.2837710228207); + bool2x4 r0 = bool2x4(true, true, false, true, false, true, false, false); + TestUtils.AreEqual(a0 > b0, r0); + + double2x4 a1 = double2x4(489.13989733585151, 51.91890885863404, 155.38475544535777, -135.63165027258526, -425.97813554572787, -228.430505143679, 383.03834909155887, 136.53358298937496); + double2x4 b1 = double2x4(-77.674873149802409, -46.5841996886694, -415.37701888353422, 71.466978344818131, -206.06102643071722, 360.83628218287424, 236.96878658838978, 14.550342328171382); + bool2x4 r1 = bool2x4(true, true, true, false, false, false, true, true); + TestUtils.AreEqual(a1 > b1, r1); + + double2x4 a2 = double2x4(8.602427725029429, -251.3243674018068, -345.954920691417, -170.565928777012, -293.25441588706076, 139.1249764613458, 214.3030732675935, 238.76991211565678); + double2x4 b2 = double2x4(364.735178402036, -159.0612996365229, 226.63117490831348, 182.79602512288659, 341.83937398616195, -79.130463875425278, -247.29681956362765, 164.58913882290437); + bool2x4 r2 = bool2x4(false, false, false, false, false, true, true, true); + TestUtils.AreEqual(a2 > b2, r2); + + double2x4 a3 = double2x4(105.53519086983761, -170.92529280992471, 26.98023964230913, -188.92831405854241, 201.78662619450438, -506.05715656003781, 15.454906232401186, 115.08067207926911); + double2x4 b3 = double2x4(-352.15977327533056, 9.8226540134394327, 186.72162613026876, -325.91364613450764, -77.930370128681147, -379.74604219000139, 251.45575558927646, -144.1835678295156); + bool2x4 r3 = bool2x4(true, false, false, true, true, false, false, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_greater_wide_scalar() + { + double2x4 a0 = double2x4(11.156317000815761, -411.02322382993214, 385.88556188432756, -485.10304831206008, -491.18003033622171, 405.17534632476759, 173.57509740329124, 69.269281181166548); + double b0 = (-302.81693877969724); + bool2x4 r0 = bool2x4(true, false, true, false, false, true, true, true); + TestUtils.AreEqual(a0 > b0, r0); + + double2x4 a1 = double2x4(501.30683183172107, -86.124509613087639, -489.09058998948456, -172.51816066192379, -18.149639853346002, -236.41493498367021, -238.8945134798505, -27.239137900638923); + double b1 = (-367.027771405423); + bool2x4 r1 = bool2x4(true, true, false, true, true, true, true, true); + TestUtils.AreEqual(a1 > b1, r1); + + double2x4 a2 = double2x4(471.77934072528933, -481.47807930478734, 185.59438547193747, 33.294723764664809, -510.22814702905163, -183.28619607877278, -386.12766260007754, -13.638212448748845); + double b2 = (240.16453253485474); + bool2x4 r2 = bool2x4(true, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 > b2, r2); + + double2x4 a3 = double2x4(-7.3478887115362568, 52.24950768996473, 16.323217637987455, -410.51010985416832, -262.26747978025463, -458.25599000335484, -218.86613069235631, -34.692342535915031); + double b3 = (-261.86596477304863); + bool2x4 r3 = bool2x4(true, true, true, false, false, false, true, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_greater_scalar_wide() + { + double a0 = (453.54610201974685); + double2x4 b0 = double2x4(-226.20441423459187, -423.46500487973213, 409.40550227156166, 453.87706277048073, 87.475727837288673, 113.79560308987072, 176.40926154721956, -140.44002944810319); + bool2x4 r0 = bool2x4(true, true, true, false, true, true, true, true); + TestUtils.AreEqual(a0 > b0, r0); + + double a1 = (-182.48286804113673); + double2x4 b1 = double2x4(-158.29329188088576, -162.68531830733889, -193.328676075362, 230.18129955519987, -102.58784227379965, 392.5205878655056, -177.47865947404813, -10.295010809924008); + bool2x4 r1 = bool2x4(false, false, true, false, false, false, false, false); + TestUtils.AreEqual(a1 > b1, r1); + + double a2 = (-24.048938524000789); + double2x4 b2 = double2x4(172.44867499752377, 374.04800503982608, -368.99763958947619, -210.19528804076617, 149.47022325800276, -281.34327019441093, -100.46916608720511, 304.86444320569956); + bool2x4 r2 = bool2x4(false, false, true, true, false, true, true, false); + TestUtils.AreEqual(a2 > b2, r2); + + double a3 = (-361.52483360912879); + double2x4 b3 = double2x4(-372.45236056505348, -33.909547583157917, -69.595290454847429, -460.43241498453187, -309.34166278938841, 486.13155602204222, 471.92098138850224, 479.36154411703421); + bool2x4 r3 = bool2x4(true, false, false, true, false, false, false, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_less_equal_wide_wide() + { + double2x4 a0 = double2x4(240.09053169940159, 462.2131528622532, 293.08251561461134, -427.87067361728782, -405.5227226715175, 204.59190211286386, 294.670105832941, -327.56444445604666); + double2x4 b0 = double2x4(-81.203838624620744, 493.63743876555816, -411.47211451617636, 99.164449499530974, -295.66769875943089, -480.46254824123463, 74.414040361723892, 260.916124226952); + bool2x4 r0 = bool2x4(false, true, false, true, true, false, false, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double2x4 a1 = double2x4(-456.12326667091031, 282.3012408140587, 421.8811549720732, -311.71284809322697, 84.5674827492644, 447.24461647832982, -154.49435217422172, -424.36474986763892); + double2x4 b1 = double2x4(306.17329730939741, 139.56480438055689, -505.75247955031341, -489.62680958659706, -280.03260267899958, 303.15991058161478, 511.19015788994272, -104.65973358259527); + bool2x4 r1 = bool2x4(true, false, false, false, false, false, true, true); + TestUtils.AreEqual(a1 <= b1, r1); + + double2x4 a2 = double2x4(36.684489505684269, 267.07029283562224, 307.89391937288167, -351.76015369582927, -157.36036570247279, 152.70902712303632, 372.26716750313858, 202.36828837281485); + double2x4 b2 = double2x4(95.1465771641333, -125.6363432992419, 376.239777024947, -415.7747320680761, -47.481050275024529, 117.72210293529656, 469.37837264937275, -263.04235780567041); + bool2x4 r2 = bool2x4(true, false, true, false, true, false, true, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double2x4 a3 = double2x4(-77.043453014010311, 438.18483253856414, 260.28234088620275, 386.03408759927106, -281.49099053139378, -102.9300439837063, -346.71673099450618, -258.34119832624737); + double2x4 b3 = double2x4(-216.00231109187115, 66.734246046624207, 99.218598173567329, 233.843011249715, 439.8399624488502, 61.115118293610976, -219.03058419890266, -404.71288056146022); + bool2x4 r3 = bool2x4(false, false, false, false, true, true, true, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_less_equal_wide_scalar() + { + double2x4 a0 = double2x4(309.1924356469849, 69.673792633076118, -101.72418622939114, -315.97240629604664, -346.01106731314724, 424.15386577330241, -410.87006945669191, -483.90265320423185); + double b0 = (292.92427148154206); + bool2x4 r0 = bool2x4(false, true, true, true, true, false, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double2x4 a1 = double2x4(183.82114538169515, -257.87003791419329, -386.801748694294, -182.9388249772316, 349.25012962392077, 485.31159304329731, 373.56911652794531, 259.15151822713744); + double b1 = (320.44249287268258); + bool2x4 r1 = bool2x4(true, true, true, true, false, false, false, true); + TestUtils.AreEqual(a1 <= b1, r1); + + double2x4 a2 = double2x4(450.13007828692446, -43.874866744445114, 457.38574549992836, -77.638293064030961, 479.45184038553941, -499.51644372358754, -398.13294643821797, 402.48485893871862); + double b2 = (-128.5255282523695); + bool2x4 r2 = bool2x4(false, false, false, false, false, true, true, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double2x4 a3 = double2x4(87.9161055497434, 125.95081263685177, -54.493607308014134, 250.66739737739204, 97.942930982421558, 228.02151809820043, -213.37865243357544, 42.260789175639275); + double b3 = (-502.17362308044619); + bool2x4 r3 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_less_equal_scalar_wide() + { + double a0 = (-511.15238141974078); + double2x4 b0 = double2x4(51.159012579898786, 340.44369022010062, 312.81429519914752, 354.19252626699983, 136.39671165142056, -94.767871185563422, 288.544332877055, 304.04282369466625); + bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double a1 = (-148.61806089646092); + double2x4 b1 = double2x4(-506.30010127755816, 27.581254256694251, 48.471146844546865, 104.88351326104419, -488.6858386884843, -480.43516968210935, 421.9366516647566, 239.72105299668431); + bool2x4 r1 = bool2x4(false, true, true, true, false, false, true, true); + TestUtils.AreEqual(a1 <= b1, r1); + + double a2 = (-101.01844673092404); + double2x4 b2 = double2x4(-283.95147551407638, -55.2435333986038, -455.80483147865385, 131.10721618081777, -461.69878099006542, -388.48285001725094, -258.93605125087129, -225.2235287284588); + bool2x4 r2 = bool2x4(false, true, false, true, false, false, false, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double a3 = (-116.01998215355911); + double2x4 b3 = double2x4(-442.59525629626364, 297.33334579008317, 36.687250392831515, 485.09780930220052, 344.44564859217292, 237.59216724969087, 230.39086471795611, -413.98479266370873); + bool2x4 r3 = bool2x4(false, true, true, true, true, true, true, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_greater_equal_wide_wide() + { + double2x4 a0 = double2x4(-386.59181302906563, -157.12078221008215, 391.01526445477054, -511.88687133783793, -5.4220387960886569, 287.64527501149348, -122.53520184500849, 7.4814426933794493); + double2x4 b0 = double2x4(153.44301350109424, 49.892483019219981, 78.025787628267835, 138.81373292711271, -225.51057802211056, -339.35611335344436, -373.302078182484, 364.9358934671319); + bool2x4 r0 = bool2x4(false, false, true, false, true, true, true, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double2x4 a1 = double2x4(152.94642765491574, 48.986223482054811, 57.338148859021317, 300.46493138953338, 349.25705139211243, 85.749700824613569, -230.95330654408468, 418.7112159294594); + double2x4 b1 = double2x4(-322.71539870030961, 125.47818165900105, -25.776589167200314, 297.51890792395864, 73.222349439385539, 462.78374288174496, 393.19134515951919, -95.001432224643168); + bool2x4 r1 = bool2x4(true, false, true, true, true, false, false, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double2x4 a2 = double2x4(-131.03991824530061, -126.51221257378916, -156.81847841889527, 422.37748761772059, -413.08933348818186, 219.44273553576443, 35.591133372667741, 447.18153521380464); + double2x4 b2 = double2x4(381.35702556248611, 93.031928344178937, 254.25326287665087, 90.672789377473691, 348.93816892660141, 161.33763106229605, 79.435611046587837, 420.24346824187944); + bool2x4 r2 = bool2x4(false, false, false, true, false, true, false, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double2x4 a3 = double2x4(-223.49299560463663, 302.12299194099523, 459.85272834256887, -347.12802879285442, 364.97808211156075, 212.63543162710755, 504.27608680365427, -142.23296052880255); + double2x4 b3 = double2x4(453.68485209610537, -154.0116427661905, -97.290078923706915, 151.18477613813468, 57.360309865959152, -194.207084984615, -462.67061421958294, 113.38661604439221); + bool2x4 r3 = bool2x4(false, true, true, false, true, true, true, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_greater_equal_wide_scalar() + { + double2x4 a0 = double2x4(495.457423679278, -14.345115906719627, -463.47478053694346, 217.51749215718246, -246.86571776441565, -377.65869706573835, 53.815095211293169, -123.33294373533357); + double b0 = (189.20512804258851); + bool2x4 r0 = bool2x4(true, false, false, true, false, false, false, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double2x4 a1 = double2x4(-221.50546441856096, -116.44038277326172, -395.36331028275345, 164.77259667439978, -287.00733889593153, 355.83704559683667, 184.19556316369938, 273.01225555735277); + double b1 = (252.99433410027734); + bool2x4 r1 = bool2x4(false, false, false, false, false, true, false, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double2x4 a2 = double2x4(-418.14240308205706, 396.39213938098032, 332.66542044871744, 243.76141392614761, -335.121477998384, -302.08690442800844, 254.44223344253476, 179.00504287472234); + double b2 = (249.38409697701411); + bool2x4 r2 = bool2x4(false, true, true, false, false, false, true, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double2x4 a3 = double2x4(71.176674637560154, 307.89058008226129, -388.57851737950858, 150.60576422075076, -219.89257989632551, -491.68100213058341, 30.997067704329766, 199.23222861030706); + double b3 = (-331.27167788672807); + bool2x4 r3 = bool2x4(true, true, false, true, true, false, true, true); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_greater_equal_scalar_wide() + { + double a0 = (215.43534169692327); + double2x4 b0 = double2x4(204.80295310020585, -101.10404853760451, -122.05503827056617, -70.456147941973143, -239.62025677395064, -185.99272426683115, -455.61258027312, 276.66581476697036); + bool2x4 r0 = bool2x4(true, true, true, true, true, true, true, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double a1 = (79.39918831707871); + double2x4 b1 = double2x4(416.42054791768112, 379.27350801009379, -439.51472612820322, 67.141009600433108, -74.560638224035813, -367.25635474140586, 494.950765601802, -61.235545425319856); + bool2x4 r1 = bool2x4(false, false, true, true, true, true, false, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double a2 = (-429.17024846988278); + double2x4 b2 = double2x4(-213.82468924942646, -264.31016242891093, 243.11378275748052, -22.383876095704693, 304.86197175870745, -323.68615332417477, 67.938025267765852, 125.30356818312009); + bool2x4 r2 = bool2x4(false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double a3 = (-400.47050280145857); + double2x4 b3 = double2x4(-283.15963162256389, -42.319595595039232, -429.51037355396448, 499.3958854616601, -289.96307887228352, -136.00878554955534, -351.12526123184955, -381.81828921931719); + bool2x4 r3 = bool2x4(false, false, true, false, false, false, false, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_add_wide_wide() + { + double2x4 a0 = double2x4(465.14837644302679, 278.91072548502621, -277.52992237616792, -65.197214395365336, -473.32437561141529, -4.6955420992782138, -470.53676698661258, -109.95011453980118); + double2x4 b0 = double2x4(483.99436186440028, -204.07667193379098, -365.67356007437854, -509.92086076639634, -270.69751108377125, 486.76397846954126, 267.49177587567442, 251.6425212601398); + double2x4 r0 = double2x4(949.14273830742707, 74.834053551235229, -643.20348245054652, -575.11807516176168, -744.02188669518659, 482.06843637026304, -203.04499111093816, 141.69240672033862); + TestUtils.AreEqual(a0 + b0, r0); + + double2x4 a1 = double2x4(-178.70145782209067, -420.03378339299644, 290.71109236903078, -446.5296368294068, 491.066454400805, -261.11730039358014, -298.40688409395835, 502.42861890347149); + double2x4 b1 = double2x4(244.4951094335388, -78.675763882079991, 352.20551340291536, 82.779185095233515, 462.54732606492348, -405.492017696375, -428.4983238785054, -41.872599859662614); + double2x4 r1 = double2x4(65.793651611448126, -498.70954727507643, 642.91660577194614, -363.75045173417328, 953.6137804657285, -666.6093180899552, -726.90520797246381, 460.55601904380887); + TestUtils.AreEqual(a1 + b1, r1); + + double2x4 a2 = double2x4(284.59432925125316, 401.12844366632794, -36.263498084742366, -102.94915657069026, 503.19817161150195, -384.42911857386542, -45.22821452339565, -198.67394337368847); + double2x4 b2 = double2x4(-269.9274958436971, 75.204465662690041, -141.91339380196922, -222.1867559990784, 41.305726308983594, 148.33947117083676, -177.23311217931712, -176.51887830370987); + double2x4 r2 = double2x4(14.666833407556055, 476.332909329018, -178.17689188671159, -325.13591256976866, 544.50389792048554, -236.08964740302866, -222.46132670271277, -375.19282167739834); + TestUtils.AreEqual(a2 + b2, r2); + + double2x4 a3 = double2x4(-62.8800013358146, -79.55225447544467, 413.0982751385767, -100.87757997441923, 418.523998693807, -183.143126334596, 407.44374031920165, 300.48602332756207); + double2x4 b3 = double2x4(492.69246768052335, 439.04383942067807, -511.74275922763292, -399.05713695988857, -315.8684596102072, -228.0772484410914, -171.70519669899028, 467.17394826709005); + double2x4 r3 = double2x4(429.81246634470875, 359.4915849452334, -98.64448408905622, -499.9347169343078, 102.65553908359982, -411.22037477568739, 235.73854362021137, 767.65997159465212); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_add_wide_scalar() + { + double2x4 a0 = double2x4(459.89829728561369, -447.66336104258119, -94.438627525436971, 126.42986279652916, -36.254356162741033, -349.64130060264904, -2.7912590516690443, -478.41478489265535); + double b0 = (500.99725913489112); + double2x4 r0 = double2x4(960.89555642050482, 53.333898092309937, 406.55863160945415, 627.42712193142029, 464.74290297215009, 151.35595853224208, 498.20600008322208, 22.582474242235776); + TestUtils.AreEqual(a0 + b0, r0); + + double2x4 a1 = double2x4(443.11525246273504, 41.32102133767728, -471.25607584009697, -2.6649749291431704, 78.985822952811532, 202.14799151297098, 311.7254551908585, 10.345855002452595); + double b1 = (268.092225914864); + double2x4 r1 = double2x4(711.207478377599, 309.41324725254128, -203.16384992523297, 265.42725098572083, 347.07804886767553, 470.240217427835, 579.8176811057225, 278.4380809173166); + TestUtils.AreEqual(a1 + b1, r1); + + double2x4 a2 = double2x4(-151.24445898423181, -197.80076584490052, 255.95526587961024, 244.14709793969394, -181.6265695940827, -2.4549267303454485, 300.90065469448484, -236.49194895312746); + double b2 = (355.23276703210206); + double2x4 r2 = double2x4(203.98830804787025, 157.43200118720154, 611.1880329117123, 599.379864971796, 173.60619743801936, 352.77784030175661, 656.1334217265869, 118.7408180789746); + TestUtils.AreEqual(a2 + b2, r2); + + double2x4 a3 = double2x4(-160.5840962680914, -242.9410861669765, 466.34409902353957, 237.98745810146795, 264.294014815378, 372.86684029775995, -198.83777699192882, -381.930974899759); + double b3 = (-172.54221566605486); + double2x4 r3 = double2x4(-333.12631193414626, -415.48330183303136, 293.80188335748471, 65.445242435413093, 91.751799149323119, 200.32462463170509, -371.37999265798368, -554.47319056581387); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_add_scalar_wide() + { + double a0 = (-325.51276484388518); + double2x4 b0 = double2x4(-264.08813178915909, -106.00925998855814, -355.44729320865463, -447.33029362528134, -158.70021040677102, -199.48369154682553, 180.31809123806568, 337.57936898692481); + double2x4 r0 = double2x4(-589.60089663304427, -431.52202483244332, -680.96005805253981, -772.84305846916652, -484.2129752506562, -524.9964563907107, -145.1946736058195, 12.066604143039626); + TestUtils.AreEqual(a0 + b0, r0); + + double a1 = (-37.05501486596421); + double2x4 b1 = double2x4(230.80498014707348, -140.17433339924287, 18.02419591789328, -138.61435825126915, 26.904163611542458, -374.53758233345, 154.4676006559597, 268.3838204203098); + double2x4 r1 = double2x4(193.74996528110927, -177.22934826520708, -19.03081894807093, -175.66937311723336, -10.150851254421752, -411.59259719941423, 117.41258578999549, 231.32880555434559); + TestUtils.AreEqual(a1 + b1, r1); + + double a2 = (-190.96302255939833); + double2x4 b2 = double2x4(188.61725362977813, -504.91612386373623, 20.454013595568995, 197.94534525552081, 251.41194474483461, -421.09037538109828, 111.44540052835146, -73.268883024001923); + double2x4 r2 = double2x4(-2.345768929620192, -695.87914642313456, -170.50900896382933, 6.9823226961224805, 60.448922185436288, -612.05339794049655, -79.517622031046869, -264.23190558340025); + TestUtils.AreEqual(a2 + b2, r2); + + double a3 = (480.88455770950975); + double2x4 b3 = double2x4(438.05301233662897, 66.844289095534123, -270.79599941465818, -44.02192189359198, 197.69471916821544, 19.113929995854392, 349.23776857426287, 366.23449271090067); + double2x4 r3 = double2x4(918.93757004613872, 547.72884680504387, 210.08855829485157, 436.86263581591777, 678.57927687772519, 499.99848770536414, 830.12232628377262, 847.11905042041042); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_sub_wide_wide() + { + double2x4 a0 = double2x4(133.37101680290471, -131.8321183341705, -197.29314407952739, -485.286571013409, -337.55033103448818, 471.66710470228782, 146.5066197600712, -130.58504372955537); + double2x4 b0 = double2x4(123.46028739002543, 359.56010048443454, -48.24847819667707, 478.97904680621764, 207.15832886805686, 142.36730462981723, -125.60551005490379, -65.299004823574307); + double2x4 r0 = double2x4(9.9107294128792773, -491.39221881860504, -149.04466588285032, -964.26561781962664, -544.708659902545, 329.29980007247059, 272.112129814975, -65.286038905981059); + TestUtils.AreEqual(a0 - b0, r0); + + double2x4 a1 = double2x4(110.77707367333448, -235.54160486699158, 78.879356659427, -347.68616811730254, -470.82054565419469, -11.459293609233271, -167.94791730118351, 330.67676917215658); + double2x4 b1 = double2x4(-477.876434787119, 164.50000031501986, 428.00958915614035, 72.6278169493321, -446.880505531505, 432.09146114443035, -225.55465637219822, -112.45196705332586); + double2x4 r1 = double2x4(588.65350846045351, -400.04160518201144, -349.13023249671335, -420.31398506663464, -23.940040122689709, -443.55075475366363, 57.606739071014715, 443.12873622548244); + TestUtils.AreEqual(a1 - b1, r1); + + double2x4 a2 = double2x4(-508.35086822339838, -252.03190457636111, -427.93418737311578, 192.6576150360786, 168.42931016182024, 457.3087858899072, 470.05851457550125, -299.71188058504458); + double2x4 b2 = double2x4(-210.61278853687122, -172.92506011432272, -80.60749415336528, 270.04610861001822, -154.25558550388348, 148.47577745675846, 13.661130673094249, 70.671096596248049); + double2x4 r2 = double2x4(-297.73807968652716, -79.1068444620384, -347.3266932197505, -77.388493573939627, 322.68489566570372, 308.83300843314873, 456.397383902407, -370.38297718129263); + TestUtils.AreEqual(a2 - b2, r2); + + double2x4 a3 = double2x4(-308.93956937870922, 454.53341052240387, 26.106923830745245, -482.71181105203544, -40.853544492671972, 318.38064613862923, 475.21081541255614, 134.9269641074012); + double2x4 b3 = double2x4(-221.32544551665217, -9.2588145775994235, 288.1738385111903, 217.36142764676424, 307.54006471649745, -262.41263854802241, -405.3780321578393, 400.00432533771004); + double2x4 r3 = double2x4(-87.614123862057056, 463.79222510000329, -262.06691468044505, -700.07323869879974, -348.39360920916943, 580.79328468665165, 880.5888475703955, -265.07736123030884); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_sub_wide_scalar() + { + double2x4 a0 = double2x4(48.936717294592768, 410.45158953706346, -364.44171612544062, 163.98060353285666, -460.06732318367222, 110.91942339340198, 204.35834441164434, 180.26971420099483); + double b0 = (-291.59041442144212); + double2x4 r0 = double2x4(340.52713171603489, 702.04200395850557, -72.8513017039985, 455.57101795429878, -168.4769087622301, 402.5098378148441, 495.94875883308646, 471.86012862243695); + TestUtils.AreEqual(a0 - b0, r0); + + double2x4 a1 = double2x4(-377.92569344952972, 400.53491968686455, 461.50756499800252, -246.28726660753006, 21.605312595891405, 246.35072171238755, -121.42736178330489, -122.71842413894757); + double b1 = (-470.26204297983185); + double2x4 r1 = double2x4(92.33634953030213, 870.79696266669634, 931.76960797783431, 223.97477637230179, 491.86735557572325, 716.61276469221934, 348.83468119652696, 347.54361884088428); + TestUtils.AreEqual(a1 - b1, r1); + + double2x4 a2 = double2x4(-122.93872099879138, 342.87457887403411, 18.929827460520869, 164.60235245740148, 97.0436885808798, 485.9149813530571, -205.75765690848124, 253.44322717070725); + double b2 = (360.15095417581074); + double2x4 r2 = double2x4(-483.08967517460212, -17.276375301776625, -341.22112671528987, -195.54860171840926, -263.10726559493094, 125.76402717724636, -565.908611084292, -106.70772700510349); + TestUtils.AreEqual(a2 - b2, r2); + + double2x4 a3 = double2x4(-121.16305619159857, -450.820273370864, -248.07337128746946, -26.996065390760123, 441.55261942444031, 449.91060969322484, 354.88602678612153, 98.821485803845121); + double b3 = (187.99838813953022); + double2x4 r3 = double2x4(-309.16144433112879, -638.81866151039424, -436.07175942699968, -214.99445353029034, 253.55423128491009, 261.91222155369462, 166.88763864659131, -89.1769023356851); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_sub_scalar_wide() + { + double a0 = (294.58645905861); + double2x4 b0 = double2x4(452.35251757705237, 256.98980891750648, -275.159888634067, -89.027518075437968, 488.22838829840919, -333.21728030462623, -64.232989102710519, -66.041730196234653); + double2x4 r0 = double2x4(-157.76605851844238, 37.59665014110351, 569.746347692677, 383.61397713404796, -193.6419292397992, 627.80373936323622, 358.81944816132051, 360.62818925484464); + TestUtils.AreEqual(a0 - b0, r0); + + double a1 = (341.20492831859963); + double2x4 b1 = double2x4(-385.775056303374, 75.394746577085357, 354.94371645289641, 169.13141520746581, 88.216608326982964, 1.7350065716240124, 122.53803997977548, -264.94502771317264); + double2x4 r1 = double2x4(726.9799846219737, 265.81018174151427, -13.738788134296783, 172.07351311113382, 252.98831999161666, 339.46992174697561, 218.66688833882415, 606.14995603177226); + TestUtils.AreEqual(a1 - b1, r1); + + double a2 = (-50.837180399725753); + double2x4 b2 = double2x4(-347.65032283759228, 4.0655586738445209, -79.095424450512724, 354.35833923628479, -292.4925116470514, -53.208983207684469, -246.34760033634848, 299.20334138497867); + double2x4 r2 = double2x4(296.81314243786653, -54.902739073570274, 28.258244050786971, -405.19551963601054, 241.65533124732565, 2.3718028079587157, 195.51041993662272, -350.04052178470442); + TestUtils.AreEqual(a2 - b2, r2); + + double a3 = (432.18467422583353); + double2x4 b3 = double2x4(-163.88000090600923, 176.74255546216978, -104.9858415615679, -445.7976302792307, -28.873155368898608, -169.58822901993443, -270.35924614144454, 68.0476272423042); + double2x4 r3 = double2x4(596.06467513184271, 255.44211876366376, 537.17051578740143, 877.98230450506423, 461.05782959473214, 601.772903245768, 702.54392036727813, 364.13704698352933); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_mul_wide_wide() + { + double2x4 a0 = double2x4(-394.78053898121254, -412.37219519744264, -25.874570143350638, -241.04595886964626, -93.675987525692221, 244.15999257013198, 494.68846606402121, 53.537962700025105); + double2x4 b0 = double2x4(-149.76397831261346, -345.04538671348496, -284.33404721148963, 267.97923648915219, -326.64849558782225, -150.68967754705329, 207.73243794577775, 366.19289248352538); + double2x4 r0 = double2x4(59123.904078224172, 142287.1235617903, 7357.0212487164608, -64595.312016683383, 30599.120397970968, -36792.390550284115, 102762.84107913627, 19605.221418797286); + TestUtils.AreEqual(a0 * b0, r0); + + double2x4 a1 = double2x4(-239.49641167349017, 236.67584644848284, -211.85620818466703, -216.65482030466887, 467.95832870339893, -178.02191146557311, -386.3942503344241, -422.43540521265726); + double2x4 b1 = double2x4(358.88076202891807, 214.85359368792433, 253.42280900358355, -307.71382751488773, 184.4711149597872, 426.43644185850235, -144.28142625851621, 459.47961518703016); + double2x4 r1 = double2x4(-85950.654724573629, 50850.6561485879, -53689.195383006307, 66667.684005499876, 86324.794650634591, -75915.030498228327, 55749.513536340863, -194100.45742848891); + TestUtils.AreEqual(a1 * b1, r1); + + double2x4 a2 = double2x4(464.58952758488692, -251.3156646468284, -104.97877912641445, -66.934159071619717, -39.829896707008572, 401.56559080703448, 434.14618250082538, -336.45419589451245); + double2x4 b2 = double2x4(-358.31334917541284, -201.36521563370025, 254.90996539541982, 168.52096303204121, 8.7945530455533572, -194.84647974504458, -405.36266178887462, -180.7321890242082); + double2x4 r2 = double2x4(-166468.62962076368, 50606.233003735295, -26760.136954367728, -11279.808946489193, -350.28613938869785, -78243.6417554897, -175986.65214401312, 60808.103330394995); + TestUtils.AreEqual(a2 * b2, r2); + + double2x4 a3 = double2x4(-83.11415318544681, 329.96027842627848, -316.97214594342381, 474.9379296130212, -445.10915800794453, -301.00371541688389, 405.68786425408337, 142.37348682357629); + double2x4 b3 = double2x4(-189.74690946831691, -35.518455760329232, 120.31664210200154, -136.2033479847961, 407.34163231744503, 301.65431489686216, -155.4824007281486, -461.39456126717596); + double2x4 r3 = double2x4(15770.6537000148, -11719.679551949688, -38137.024239778322, -64688.136098260919, -181311.49098239967, -90799.069555490176, -63077.323080500144, -65690.352489042038); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_mul_wide_scalar() + { + double2x4 a0 = double2x4(328.20302191758674, -290.10672272839895, 236.99572454998065, 120.48136692889102, 357.90315811610924, 134.86723214707672, -477.31047104173825, -438.272912467957); + double b0 = (192.21119055161773); + double2x4 r0 = double2x4(63084.293585418032, -55761.758562653624, 45553.230371395039, 23157.866976688449, 68792.992123681237, 25922.99125739103, -91744.41390168597, -84240.958291990959); + TestUtils.AreEqual(a0 * b0, r0); + + double2x4 a1 = double2x4(-46.729179165665585, 422.08249374017237, -48.83483722099794, 355.30832998608628, 119.35660391643489, -196.995807977857, 98.2360046367329, -325.55215683837991); + double b1 = (-238.40500103608008); + double2x4 r1 = double2x4(11140.470007405675, -100626.57735743705, 11642.469418268816, -84707.28277846078, -28455.211280360661, 46964.785805064428, -23419.954787200673, 77613.262288352067); + TestUtils.AreEqual(a1 * b1, r1); + + double2x4 a2 = double2x4(53.937323833786536, -130.47412949915702, -222.59457145565869, 126.01503211167415, 293.36108769726059, 174.38195737375963, -327.12007704708731, 56.629123475695565); + double b2 = (-87.4509838034636); + double2x4 r2 = double2x4(-4716.8720329906373, 11410.090985601793, 19466.114263107731, -11020.138532190962, -25654.7157287796, -15249.873729908933, 28606.9725596326, -4952.2725598773932); + TestUtils.AreEqual(a2 * b2, r2); + + double2x4 a3 = double2x4(257.54154241156834, -452.69189450363251, -49.220605157884108, 141.60094959177115, 431.58568330834885, 180.35518583113105, -40.92345454214302, 279.54350842141707); + double b3 = (-475.60871551726422); + double2x4 r3 = double2x4(-122489.00217870105, 215304.21046994952, 23409.748796123691, -67346.645751367163, -205265.91247392457, -85778.498270021737, 19463.551649317793, -132953.32897149969); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_mul_scalar_wide() + { + double a0 = (-464.534700371574); + double2x4 b0 = double2x4(329.36093846399376, -198.68342671109525, 184.07942518223047, 256.01618754864489, 266.22629297255833, -97.894749448585685, 159.74810583877752, -351.82222263506719); + double2x4 r0 = double2x4(-152999.58486347177, 92295.346096036214, -85511.280621599, -118928.40297318244, -123671.35123704225, 45475.508103049062, -74208.538480743009, 163433.63077584215); + TestUtils.AreEqual(a0 * b0, r0); + + double a1 = (491.80157660497423); + double2x4 b1 = double2x4(49.902031206480274, 424.46256871915546, 160.11807616060514, -395.99208492599058, 125.20168858636248, -265.01581991138676, 314.65609779705107, -292.71202029507236); + double2x4 r1 = double2x4(24541.897623137622, 208751.36050587788, 78746.322298740954, -194749.53168969302, 61574.387840378076, -130335.19805767993, 154748.36498495867, -143956.23307234381); + TestUtils.AreEqual(a1 * b1, r1); + + double a2 = (-37.729878681586058); + double2x4 b2 = double2x4(165.3622206027444, 356.51773302467438, -188.81332906932261, 504.91572475103465, 40.572113771257932, -206.77510581108515, -61.602680473403382, 118.97158938225903); + double2x4 r2 = double2x4(-6239.0965218592164, -13451.370814855052, 7123.9039992519283, -19050.409039281636, -1530.7809304450689, 7801.599656624363, 2324.2616607220198, -4488.7836339481055); + TestUtils.AreEqual(a2 * b2, r2); + + double a3 = (53.7483275186961); + double2x4 b3 = double2x4(-198.66941771221786, 96.23611287783649, -20.241880664714529, -31.123976006696012, 38.890465516080326, -13.133307701504464, 507.87128209875493, 95.017933651347562); + double2x4 r3 = double2x4(-10678.14893114493, 5172.530114084163, -1087.9672315614384, -1672.8616560919363, 2090.2974779128417, -705.89332374427579, 27297.232007583982, 5107.0550180423643); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_div_wide_wide() + { + double2x4 a0 = double2x4(246.26574933075619, -269.85612953354428, -451.61952588130697, -7.38850236283082, -308.20558681534862, -373.394808704683, 360.41863482092447, 25.80972458133931); + double2x4 b0 = double2x4(172.11981423763552, -77.141104972521362, -325.8353723612779, -450.60868117334724, -261.26215398556656, -122.44949847201326, -93.210781379235357, -442.00522705633438); + double2x4 r0 = double2x4(1.4307809383918566, 3.4982144685336105, 1.3860359070548143, 0.016396715535066435, 1.1796794220427942, 3.0493780159501847, -3.8667054335113131, -0.05839235149599218); + TestUtils.AreEqual(a0 / b0, r0); + + double2x4 a1 = double2x4(-274.050461181463, 127.53858977534742, -447.6717600522897, -137.4586017771897, -136.13317424437645, 12.43763423545181, 228.51298319013461, 356.9723681681661); + double2x4 b1 = double2x4(484.36271380091216, -390.78178686219348, 402.02531714086672, 316.65072193585831, 397.15440744774151, -303.26218643005109, -118.59124451437555, -81.650312223308845); + double2x4 r1 = double2x4(-0.56579594872388561, -0.32636779415802974, -1.1135412148569459, -0.43410165287743668, -0.3427714050039572, -0.041012809351094658, -1.9268959030313104, -4.37196574572633); + TestUtils.AreEqual(a1 / b1, r1); + + double2x4 a2 = double2x4(-24.762040865031111, 411.66839356518744, -204.07890067066944, 11.365393882321882, 82.152295389283609, 37.389483230835481, 394.26582903147948, -429.91279645912016); + double2x4 b2 = double2x4(-84.346871176896116, -488.41943549011808, 404.16049999937434, -136.72883731533256, -19.832707652744261, -102.6072290421497, 166.11604960547572, -112.84016590604568); + double2x4 r2 = double2x4(0.29357391115432163, -0.84285833783843456, -0.50494519051462317, -0.083123605125890912, -4.1422632162843458, -0.36439423985883462, 2.3734361006528726, 3.8099270149698223); + TestUtils.AreEqual(a2 / b2, r2); + + double2x4 a3 = double2x4(315.37384071730719, -122.66599255551864, 447.52615067340719, -210.48151574399395, -202.42158398517483, -453.00793072814491, 173.7269934032704, -167.1216643634819); + double2x4 b3 = double2x4(-218.2096851888158, 458.51754042995981, 119.5872405132219, 356.24043218988948, -74.506851469402591, -336.77393332904853, -216.12631593277973, 322.385657699027); + double2x4 r3 = double2x4(-1.4452788401413792, -0.26752737188743669, 3.7422566885296384, -0.59084117557941718, 2.7168183864044027, 1.3451395309907455, -0.80382156450260089, -0.51839050643966134); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_div_wide_scalar() + { + double2x4 a0 = double2x4(-244.51745116175965, 69.112274917360537, -333.02311888943575, 257.39682519500923, 403.24561257066466, 154.34436066185322, 131.52659160062979, -261.88639200007844); + double b0 = (-60.024377612408443); + double2x4 r0 = double2x4(4.0736357608014941, -1.1514034408425655, 5.5481311449798705, -4.2882048166676752, -6.7180307170282818, -2.5713612835520117, -2.1912195816494422, 4.3630005410658415); + TestUtils.AreEqual(a0 / b0, r0); + + double2x4 a1 = double2x4(-348.92380516087815, 210.55792174607416, 287.64239968342815, 504.37224626185946, 491.78708600056689, -26.63160015392657, -253.23667275776933, 272.89512098622276); + double b1 = (-275.53868187383688); + double2x4 r1 = double2x4(1.26633328862567, -0.76416828415577609, -1.0439274722782237, -1.8304952423805252, -1.7848204929199212, 0.096652854593100634, 0.91906033314669355, -0.990405844763297); + TestUtils.AreEqual(a1 / b1, r1); + + double2x4 a2 = double2x4(178.09617313095191, -502.64601611655485, -84.324793139623864, -174.69034036187935, 83.796309271732525, 197.04206690427009, 317.16826525198678, 403.38711781212464); + double b2 = (-460.87559030059521); + double2x4 r2 = double2x4(-0.3864300407291974, 1.0906327579395469, 0.18296649879987137, 0.37904012284083372, -0.18181980351156884, -0.42753851809715948, -0.68818629566630174, -0.87526249231169939); + TestUtils.AreEqual(a2 / b2, r2); + + double2x4 a3 = double2x4(81.646461763254592, -413.56048102563273, 207.34099803089214, 358.5621036768714, 20.749072799807891, -68.577131064877449, 310.70246257945075, 417.40490193730443); + double b3 = (60.606869964211683); + double2x4 r3 = double2x4(1.3471486287192653, -6.8236568110156472, 3.4210807809960628, 5.9161957033683157, 0.34235512924624228, -1.1315075519552849, 5.1265221708845941, 6.88708890896002); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_div_scalar_wide() + { + double a0 = (41.737658758525527); + double2x4 b0 = double2x4(-422.676129776368, 248.12963235011773, 449.39137741988122, 245.85813796047967, -326.62061253498337, 163.71510489457989, 333.664472020075, 38.291076916405473); + double2x4 r0 = double2x4(-0.098746193168297289, 0.1682090863683405, 0.092875967042706856, 0.16976317767945767, -0.12778635871933872, 0.25494079355354177, 0.12508871114097631, 1.0900100524632514); + TestUtils.AreEqual(a0 / b0, r0); + + double a1 = (-472.97976062864984); + double2x4 b1 = double2x4(192.23013958345643, -200.29686960964318, -490.18150376257557, -211.10257468517057, -322.85234108700058, -137.98529035317961, 84.32973555677097, 355.06345550858578); + double2x4 r1 = double2x4(-2.4604870061143891, 2.3613936730535827, 0.96490740062224467, 2.2405210421238673, 1.4650033480822544, 3.4277549398058063, -5.6086949343062837, -1.332099243925746); + TestUtils.AreEqual(a1 / b1, r1); + + double a2 = (276.42724455354141); + double2x4 b2 = double2x4(-382.9880213136729, -488.647160996053, 344.84603826368505, 168.85499938244698, -44.19558837087618, 420.550703959796, -175.6152060849663, -9.2205684227964753); + double2x4 r2 = double2x4(-0.72176472675406045, -0.56569907004079412, 0.80159611502386607, 1.637068760560944, -6.2546343366637984, 0.65729825666863562, -1.574050736926506, -29.979414703991178); + TestUtils.AreEqual(a2 / b2, r2); + + double a3 = (-344.19428865248074); + double2x4 b3 = double2x4(-449.07149216582604, 117.70491724726969, -337.02741710144437, 239.39341389359595, -389.35516304027067, 242.71606718875285, 496.27646445495839, 91.745798392102984); + double2x4 r3 = double2x4(0.766457668003967, -2.9242133353648381, 1.0212649511208138, -1.4377767669308814, 0.8840111068897808, -1.4180943710859133, -0.69355351967072676, -3.751608190071702); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_mod_wide_wide() + { + double2x4 a0 = double2x4(-442.30985924336585, 368.50046246522129, -1.0938966279355213, -364.67383473211612, -197.34394487987458, -34.034902350062, -101.34858350704826, 208.31857142612273); + double2x4 b0 = double2x4(-43.245045443645211, -144.19587690392319, -62.640481739603217, -336.82826510855381, -154.6102545981343, -154.02935583611452, 487.0462093237071, -469.82909105244516); + double2x4 r0 = double2x4(-9.8594048069137443, 80.1087086573749, -1.0938966279355213, -27.845569623562312, -42.73369028174028, -34.034902350062, -101.34858350704826, 208.31857142612273); + TestUtils.AreEqual(a0 % b0, r0); + + double2x4 a1 = double2x4(-140.77031404374645, 183.446989383291, -463.36838100076113, 83.839106360375467, -64.714058190916717, 295.06681050689281, 212.257051805154, 349.62829916068745); + double2x4 b1 = double2x4(-145.20377237405802, -203.38401780062543, -22.520082245823062, 224.6900237652892, -435.62674614210925, 12.095571285158144, 40.378765363422531, 345.78484813579587); + double2x4 r1 = double2x4(-140.77031404374645, 183.446989383291, -12.966736084299896, 83.839106360375467, -64.714058190916717, 4.773099663097355, 10.363224988041338, 3.8434510248915785); + TestUtils.AreEqual(a1 % b1, r1); + + double2x4 a2 = double2x4(119.87592106679267, -37.805828350505692, 142.41158515886013, 332.24425593588694, -464.19427249589671, -296.14783801517814, 225.17535863871467, -212.06027732233531); + double2x4 b2 = double2x4(-433.47126146474443, -355.64996712079733, 4.0154273528677322, 66.659781725453058, -221.85363088448236, -355.05676405274158, 357.93597118832918, 71.375334057666009); + double2x4 r2 = double2x4(119.87592106679267, -37.805828350505692, 1.8716278084895066, 65.605129034074707, -20.487010726932, -296.14783801517814, 225.17535863871467, -69.309609207003291); + TestUtils.AreEqual(a2 % b2, r2); + + double2x4 a3 = double2x4(156.98570425668061, 507.61831092630439, 270.83043897842538, 337.734341063413, 384.91584819597927, 432.51818128699347, 154.29270775350403, -37.0853169137078); + double2x4 b3 = double2x4(-131.41830188195144, -473.98760078567432, 76.2178585884244, 92.210223002457155, -368.18956130006796, -77.467150485826267, 135.23059398272574, 274.27728975670288); + double2x4 r3 = double2x4(25.56740237472917, 33.630710140630072, 42.17686321315216, 61.103672056041546, 16.7262868959113, 45.182428857862135, 19.062113770778296, -37.0853169137078); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_mod_wide_scalar() + { + double2x4 a0 = double2x4(-433.41699548876704, -5.5141427542614565, 393.39439958771425, 299.41153277988155, -120.80601626299602, -502.939041133476, -450.80766245853511, 186.09479698263794); + double b0 = (-90.499235433758827); + double2x4 r0 = double2x4(-71.420053753731736, -5.5141427542614565, 31.39745785267894, 27.913826478605074, -30.306780829237198, -50.442863964681862, -88.8107207234998, 5.0963261151202914); + TestUtils.AreEqual(a0 % b0, r0); + + double2x4 a1 = double2x4(-84.473635951277629, 433.45469041981482, -54.6001856581309, -172.33886607565864, -429.71466728193434, 222.36186109406958, 5.796394112425105, 254.51082885196); + double b1 = (-318.78148356023314); + double2x4 r1 = double2x4(-84.473635951277629, 114.67320685958168, -54.6001856581309, -172.33886607565864, -110.9331837217012, 222.36186109406958, 5.796394112425105, 254.51082885196); + TestUtils.AreEqual(a1 % b1, r1); + + double2x4 a2 = double2x4(-433.09369703433185, -75.356399809641971, 252.28909385031511, -69.403906139267576, 5.3372299696026175, -279.06042803407666, 483.55059097872606, -331.99334660730949); + double b2 = (-203.08261284748215); + double2x4 r2 = double2x4(-26.928471339367547, -75.356399809641971, 49.206481002832959, -69.403906139267576, 5.3372299696026175, -75.977815186594512, 77.385365283761757, -128.91073375982734); + TestUtils.AreEqual(a2 % b2, r2); + + double2x4 a3 = double2x4(335.99997655302286, -124.72076731767544, 38.175906437531125, 271.28698671575955, 405.77360100567978, -194.76144489774549, 235.72397314557986, 465.98487804177444); + double b3 = (67.839589388966374); + double2x4 r3 = double2x4(64.641618997157366, -56.881177928709064, 38.175906437531125, 67.768218548860432, 66.57565406084791, -59.082266119812743, 32.20520497868074, 58.947341707976193); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_mod_scalar_wide() + { + double a0 = (-396.4224028049141); + double2x4 b0 = double2x4(-159.14024384279747, 230.17333399046834, 14.779358632294134, -303.15649738123477, 399.63502020371845, 206.69470534412881, 397.04482263934096, -393.89064735634747); + double2x4 r0 = double2x4(-78.141915119319151, -166.24906881444576, -12.159078365266623, -93.265905423679328, -396.4224028049141, -189.72769746078529, -396.4224028049141, -2.5317554485666278); + TestUtils.AreEqual(a0 % b0, r0); + + double a1 = (-372.06709426085797); + double2x4 b1 = double2x4(201.01229796233224, -95.5668547598491, -258.95146882671463, 106.98357563232241, 469.3235559264773, -34.808985011097491, 184.83653434777466, 374.79425376224992); + double2x4 r1 = double2x4(-171.05479629852573, -85.366529981310691, -113.11562543414334, -51.116367363890731, -372.06709426085797, -23.977244149883063, -2.3940255653086524, -372.06709426085797); + TestUtils.AreEqual(a1 % b1, r1); + + double a2 = (-131.87271911086174); + double2x4 b2 = double2x4(-120.09286003936683, 4.506670715523228, -111.40195732535886, 391.54249710195813, -218.66887078931035, 196.37741980160467, -511.03262233689082, 499.95350598727987); + double2x4 r2 = double2x4(-11.779859071494911, -1.1792683606881269, -20.470761785502873, -131.87271911086174, -131.87271911086174, -131.87271911086174, -131.87271911086174, -131.87271911086174); + TestUtils.AreEqual(a2 % b2, r2); + + double a3 = (-433.52306505363578); + double2x4 b3 = double2x4(-163.8668559360629, 177.00401099818009, 110.65016441729392, 17.68454910148148, -95.85296754532169, -432.44096561541824, 192.69208654793545, -268.13177621929526); + double2x4 r3 = double2x4(-105.78935318150997, -79.515043057275591, -101.57257180175401, -9.093886618080262, -50.111194872349017, -1.08209943821754, -48.138891957764884, -165.39128883434051); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double2x4_operator_plus() + { + double2x4 a0 = double2x4(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045, 315.44952860262686, 319.22218742930431, 190.32466015141677, -350.30858270745193); + double2x4 r0 = double2x4(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045, 315.44952860262686, 319.22218742930431, 190.32466015141677, -350.30858270745193); + TestUtils.AreEqual(+a0, r0); + + double2x4 a1 = double2x4(-320.51845875406565, -107.00351267075331, -428.77622075973835, 377.23016208095021, 234.77393042052813, 34.283600107898792, 258.33039414991174, 465.35593555185756); + double2x4 r1 = double2x4(-320.51845875406565, -107.00351267075331, -428.77622075973835, 377.23016208095021, 234.77393042052813, 34.283600107898792, 258.33039414991174, 465.35593555185756); + TestUtils.AreEqual(+a1, r1); + + double2x4 a2 = double2x4(309.59316530339106, -230.05266557915724, 301.78512229667285, 2.585727931273027, 350.24640981771347, 60.819777278611355, -472.44209526127304, -364.80255644619581); + double2x4 r2 = double2x4(309.59316530339106, -230.05266557915724, 301.78512229667285, 2.585727931273027, 350.24640981771347, 60.819777278611355, -472.44209526127304, -364.80255644619581); + TestUtils.AreEqual(+a2, r2); + + double2x4 a3 = double2x4(239.15236937215195, 285.80893935161123, -273.26378191321334, -206.68638310520276, -113.36231785331029, -351.7548708169511, -116.53621798219916, -496.05329274388652); + double2x4 r3 = double2x4(239.15236937215195, 285.80893935161123, -273.26378191321334, -206.68638310520276, -113.36231785331029, -351.7548708169511, -116.53621798219916, -496.05329274388652); + TestUtils.AreEqual(+a3, r3); + } + + [TestCompiler] + public static void double2x4_operator_neg() + { + double2x4 a0 = double2x4(420.22718854445372, -196.25749811728366, -335.42683068636188, 509.04366969924592, -33.014395013923945, -498.57532071442125, -495.8379526063045, -270.85946787095605); + double2x4 r0 = double2x4(-420.22718854445372, 196.25749811728366, 335.42683068636188, -509.04366969924592, 33.014395013923945, 498.57532071442125, 495.8379526063045, 270.85946787095605); + TestUtils.AreEqual(-a0, r0); + + double2x4 a1 = double2x4(19.686896571743773, -180.60051473444349, 223.38126312167446, -410.39206070936848, -395.68154186554324, -349.14948885010062, -110.9393032113739, -238.21960913307015); + double2x4 r1 = double2x4(-19.686896571743773, 180.60051473444349, -223.38126312167446, 410.39206070936848, 395.68154186554324, 349.14948885010062, 110.9393032113739, 238.21960913307015); + TestUtils.AreEqual(-a1, r1); + + double2x4 a2 = double2x4(292.54351224216794, 48.290685914592245, 88.7237785275671, 66.148520738886873, 55.707977559281517, 464.54141090090457, 499.24280213715645, 175.01502259774838); + double2x4 r2 = double2x4(-292.54351224216794, -48.290685914592245, -88.7237785275671, -66.148520738886873, -55.707977559281517, -464.54141090090457, -499.24280213715645, -175.01502259774838); + TestUtils.AreEqual(-a2, r2); + + double2x4 a3 = double2x4(196.38759169186824, 149.66006023700356, 320.3917383255399, -359.83381168909079, 22.03845144344416, -159.55426199713457, 419.82245011805674, 303.32339992342679); + double2x4 r3 = double2x4(-196.38759169186824, -149.66006023700356, -320.3917383255399, 359.83381168909079, -22.03845144344416, 159.55426199713457, -419.82245011805674, -303.32339992342679); + TestUtils.AreEqual(-a3, r3); + } + + [TestCompiler] + public static void double2x4_operator_prefix_inc() + { + double2x4 a0 = double2x4(-99.79557113526181, 458.74185082816609, 96.179026886904126, -48.552469514567633, -315.728967098393, -299.23014583216525, -323.61485853959567, -456.89028832730384); + double2x4 r0 = double2x4(-98.79557113526181, 459.74185082816609, 97.179026886904126, -47.552469514567633, -314.728967098393, -298.23014583216525, -322.61485853959567, -455.89028832730384); + TestUtils.AreEqual(++a0, r0); + + double2x4 a1 = double2x4(-76.507656371457358, 64.0964734852763, 148.67930967578627, 363.2849182390072, -115.5592263283018, -326.87781992874937, -179.89464839729231, 339.8765849265626); + double2x4 r1 = double2x4(-75.507656371457358, 65.0964734852763, 149.67930967578627, 364.2849182390072, -114.5592263283018, -325.87781992874937, -178.89464839729231, 340.8765849265626); + TestUtils.AreEqual(++a1, r1); + + double2x4 a2 = double2x4(-38.410431164507941, 261.62557304167444, 155.03081877298223, -396.65022892348946, 301.30576791488829, -221.35540328796736, -429.69815011960367, -271.28932893988178); + double2x4 r2 = double2x4(-37.410431164507941, 262.62557304167444, 156.03081877298223, -395.65022892348946, 302.30576791488829, -220.35540328796736, -428.69815011960367, -270.28932893988178); + TestUtils.AreEqual(++a2, r2); + + double2x4 a3 = double2x4(-264.38006246480165, 223.23241792583485, -71.076339993195745, -388.22791713673058, 131.28316909227669, 22.304934273615913, -480.76047228312143, 200.95175967037289); + double2x4 r3 = double2x4(-263.38006246480165, 224.23241792583485, -70.076339993195745, -387.22791713673058, 132.28316909227669, 23.304934273615913, -479.76047228312143, 201.95175967037289); + TestUtils.AreEqual(++a3, r3); + } + + [TestCompiler] + public static void double2x4_operator_postfix_inc() + { + double2x4 a0 = double2x4(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888, -31.420532002775246, 455.33662459595905, 271.45466840986842, 55.736877228942149); + double2x4 r0 = double2x4(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888, -31.420532002775246, 455.33662459595905, 271.45466840986842, 55.736877228942149); + TestUtils.AreEqual(a0++, r0); + + double2x4 a1 = double2x4(153.75031645305, -427.40105100506969, 215.11022744658874, 159.86103184514729, -333.05045262586816, 241.46487509527469, 287.22045649551808, -170.10464366250886); + double2x4 r1 = double2x4(153.75031645305, -427.40105100506969, 215.11022744658874, 159.86103184514729, -333.05045262586816, 241.46487509527469, 287.22045649551808, -170.10464366250886); + TestUtils.AreEqual(a1++, r1); + + double2x4 a2 = double2x4(-270.65246380057766, 454.48881003562769, -449.92732045144186, 209.52264294844247, -311.43587103087259, 69.731466087387616, -232.29964433996923, -341.49855271982892); + double2x4 r2 = double2x4(-270.65246380057766, 454.48881003562769, -449.92732045144186, 209.52264294844247, -311.43587103087259, 69.731466087387616, -232.29964433996923, -341.49855271982892); + TestUtils.AreEqual(a2++, r2); + + double2x4 a3 = double2x4(188.00656685047159, 25.565661203845252, -463.72565982478005, 504.44898509627626, -310.1449584020977, -117.39846258861871, 403.50871271803453, -111.27954178269931); + double2x4 r3 = double2x4(188.00656685047159, 25.565661203845252, -463.72565982478005, 504.44898509627626, -310.1449584020977, -117.39846258861871, 403.50871271803453, -111.27954178269931); + TestUtils.AreEqual(a3++, r3); + } + + [TestCompiler] + public static void double2x4_operator_prefix_dec() + { + double2x4 a0 = double2x4(-416.20121712992022, -96.637880131899351, -50.145671629414721, -207.31644759295341, 439.47906156977592, -304.40081920493435, 337.96895734312432, 246.08898293510492); + double2x4 r0 = double2x4(-417.20121712992022, -97.637880131899351, -51.145671629414721, -208.31644759295341, 438.47906156977592, -305.40081920493435, 336.96895734312432, 245.08898293510492); + TestUtils.AreEqual(--a0, r0); + + double2x4 a1 = double2x4(171.96452935597142, 298.28480710568135, 326.50782338087811, 400.720900006928, -478.03137253133178, -326.45297852459038, -24.584499132160317, 112.79684668071422); + double2x4 r1 = double2x4(170.96452935597142, 297.28480710568135, 325.50782338087811, 399.720900006928, -479.03137253133178, -327.45297852459038, -25.584499132160317, 111.79684668071422); + TestUtils.AreEqual(--a1, r1); + + double2x4 a2 = double2x4(-341.97629300783217, -79.635249413380052, -131.0041454448384, 147.89369566174867, -15.70865417258284, 188.75845274178243, 307.79193582562357, -406.667706917351); + double2x4 r2 = double2x4(-342.97629300783217, -80.635249413380052, -132.0041454448384, 146.89369566174867, -16.70865417258284, 187.75845274178243, 306.79193582562357, -407.667706917351); + TestUtils.AreEqual(--a2, r2); + + double2x4 a3 = double2x4(181.47510703908051, -505.2156915633081, -372.24192898918034, -4.0317671317754957, 83.767736235525376, -30.631410374600193, -436.90656181653333, -51.668396258572329); + double2x4 r3 = double2x4(180.47510703908051, -506.2156915633081, -373.24192898918034, -5.0317671317754957, 82.767736235525376, -31.631410374600193, -437.90656181653333, -52.668396258572329); + TestUtils.AreEqual(--a3, r3); + } + + [TestCompiler] + public static void double2x4_operator_postfix_dec() + { + double2x4 a0 = double2x4(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555, 409.55752940175944, 47.856652520530247, -281.11170376516492, -262.062590959511); + double2x4 r0 = double2x4(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555, 409.55752940175944, 47.856652520530247, -281.11170376516492, -262.062590959511); + TestUtils.AreEqual(a0--, r0); + + double2x4 a1 = double2x4(-182.40572866350681, -129.23265582380475, -332.15495768755443, -261.00890052551819, 205.46112570793423, -230.22777878038016, -483.06653784358247, 378.64123433578811); + double2x4 r1 = double2x4(-182.40572866350681, -129.23265582380475, -332.15495768755443, -261.00890052551819, 205.46112570793423, -230.22777878038016, -483.06653784358247, 378.64123433578811); + TestUtils.AreEqual(a1--, r1); + + double2x4 a2 = double2x4(487.34482287212495, -357.05418960985457, -396.30206627226528, 279.42425287860647, 115.86774092347719, -20.823201427619551, 323.40538063803933, 379.15614026559342); + double2x4 r2 = double2x4(487.34482287212495, -357.05418960985457, -396.30206627226528, 279.42425287860647, 115.86774092347719, -20.823201427619551, 323.40538063803933, 379.15614026559342); + TestUtils.AreEqual(a2--, r2); + + double2x4 a3 = double2x4(311.29903068733358, -428.25672479544613, -425.2883748604396, -194.64129671577427, -258.84836089743692, -208.98576388553982, -313.42591657928466, 178.31252797800698); + double2x4 r3 = double2x4(311.29903068733358, -428.25672479544613, -425.2883748604396, -194.64129671577427, -258.84836089743692, -208.98576388553982, -313.42591657928466, 178.31252797800698); + 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/TestDouble2x4.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/TestDouble2x4.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1c44a3ff9c904b6dc743aa0cecadb779b0c03408 --- /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/TestDouble2x4.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 93f2834619d034346a15285ea2156089 +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/TestDouble3.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/TestDouble3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..fba5107c3545a525d25eae016a51f66b246d2850 --- /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/TestDouble3.gen.cs @@ -0,0 +1,1062 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestDouble3 + { + [TestCompiler] + public static void double3_zero() + { + TestUtils.AreEqual(double3.zero.x, 0.0); + TestUtils.AreEqual(double3.zero.y, 0.0); + TestUtils.AreEqual(double3.zero.z, 0.0); + } + + [TestCompiler] + public static void double3_constructor() + { + double3 a = new double3(1, 2, 3); + TestUtils.AreEqual(a.x, 1); + TestUtils.AreEqual(a.y, 2); + TestUtils.AreEqual(a.z, 3); + } + + [TestCompiler] + public static void double3_scalar_constructor() + { + double3 a = new double3(17.0); + TestUtils.AreEqual(a.x, 17.0); + TestUtils.AreEqual(a.y, 17.0); + TestUtils.AreEqual(a.z, 17.0); + } + + [TestCompiler] + public static void double3_static_constructor() + { + double3 a = double3(1, 2, 3); + TestUtils.AreEqual(a.x, 1); + TestUtils.AreEqual(a.y, 2); + TestUtils.AreEqual(a.z, 3); + } + + [TestCompiler] + public static void double3_static_scalar_constructor() + { + double3 a = double3(17.0); + TestUtils.AreEqual(a.x, 17.0); + TestUtils.AreEqual(a.y, 17.0); + TestUtils.AreEqual(a.z, 17.0); + } + + [TestCompiler] + public static void double3_operator_equal_wide_wide() + { + double3 a0 = double3(-135.18925172425304, -49.094127439471947, 169.12980778940482); + double3 b0 = double3(-220.01464591734793, 66.980020792679852, 499.20158576369363); + bool3 r0 = bool3(false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double3 a1 = double3(240.80529772527757, 314.73919382446411, 442.39301916695808); + double3 b1 = double3(-371.113114291389, 208.44865212610398, 390.80369133074009); + bool3 r1 = bool3(false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double3 a2 = double3(177.92444881141398, 335.53340283759564, 168.1544516869609); + double3 b2 = double3(-72.443806920407269, 362.97643273089841, 194.6783255053117); + bool3 r2 = bool3(false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double3 a3 = double3(350.72955982327903, 367.17843668869625, 46.941470406456574); + double3 b3 = double3(471.6448635867074, -404.04466719368691, -144.69675476136467); + bool3 r3 = bool3(false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double3_operator_equal_wide_scalar() + { + double3 a0 = double3(65.671194345537174, 404.41550440546848, -269.7301577393572); + double b0 = (-155.8157547245807); + bool3 r0 = bool3(false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double3 a1 = double3(83.630607882342588, -155.86829836474186, 314.67125597348024); + double b1 = (152.99450476141385); + bool3 r1 = bool3(false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double3 a2 = double3(386.36515325417986, -132.63519460178691, -65.667489797653388); + double b2 = (290.04894007837811); + bool3 r2 = bool3(false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double3 a3 = double3(-69.683271678948415, 186.84520086406042, -232.89569221851218); + double b3 = (-191.19075521789063); + bool3 r3 = bool3(false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double3_operator_equal_scalar_wide() + { + double a0 = (36.383921878591195); + double3 b0 = double3(-400.48919958644046, -71.286823544319191, 156.97811491646712); + bool3 r0 = bool3(false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double a1 = (-225.23872791288363); + double3 b1 = double3(499.14180993435059, -211.97992358542047, 428.31192394174263); + bool3 r1 = bool3(false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double a2 = (-489.50133322621758); + double3 b2 = double3(-5.6915457275190988, -30.865948453017495, -362.98307221149241); + bool3 r2 = bool3(false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double a3 = (184.50319322594589); + double3 b3 = double3(-160.47062142215231, 316.66882315122928, 390.36923879681581); + bool3 r3 = bool3(false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double3_operator_not_equal_wide_wide() + { + double3 a0 = double3(279.99414576217259, -43.342018386042696, -465.72473523846116); + double3 b0 = double3(-460.912120318465, -476.00904844515446, 468.13642070635058); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double3 a1 = double3(317.46655645848557, 85.714987079480238, 360.89050572034466); + double3 b1 = double3(-341.01254312182431, -62.658060341448561, -458.80166718866752); + bool3 r1 = bool3(true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double3 a2 = double3(366.08152668833804, 154.5428384070018, 332.426219856565); + double3 b2 = double3(-457.73023316717251, -59.523265627922171, 3.024243117787023); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double3 a3 = double3(397.11323160543725, -431.3749584776233, 489.01079319837072); + double3 b3 = double3(155.81276352508587, -19.839918384253963, -6.0169332055453992); + bool3 r3 = bool3(true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double3_operator_not_equal_wide_scalar() + { + double3 a0 = double3(-155.44111282911206, -19.426602134214079, 174.63305409934048); + double b0 = (-393.41354173860213); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double3 a1 = double3(507.9207296352464, 171.15146430356026, -58.923273352404692); + double b1 = (59.177048472304364); + bool3 r1 = bool3(true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double3 a2 = double3(-398.17684835855704, -165.24150879925185, 270.34102333259818); + double b2 = (492.20105361016522); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double3 a3 = double3(-380.24326222960059, -134.34545642433011, 458.40042302496749); + double b3 = (501.8990516615562); + bool3 r3 = bool3(true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double3_operator_not_equal_scalar_wide() + { + double a0 = (478.35313938481409); + double3 b0 = double3(459.55319592894671, 436.45324369727314, -488.71416806090349); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double a1 = (392.76794475725296); + double3 b1 = double3(-266.73665369056937, 338.55788270503183, -338.10012475498957); + bool3 r1 = bool3(true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double a2 = (-152.3145445102428); + double3 b2 = double3(-452.82067868338, 209.43931422449612, 50.107968592135194); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double a3 = (372.4343656843688); + double3 b3 = double3(-488.0213141329686, 489.74075697816011, 270.40006149485714); + bool3 r3 = bool3(true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double3_operator_less_wide_wide() + { + double3 a0 = double3(51.710243010758518, -313.85556450200062, 283.04767359562572); + double3 b0 = double3(-261.83523881707117, -19.810742149041403, -149.25882084167506); + bool3 r0 = bool3(false, true, false); + TestUtils.AreEqual(a0 < b0, r0); + + double3 a1 = double3(235.02188621974642, 44.0783565249659, -207.25566659088042); + double3 b1 = double3(205.99822316225539, -306.02438535635565, 102.12168006884008); + bool3 r1 = bool3(false, false, true); + TestUtils.AreEqual(a1 < b1, r1); + + double3 a2 = double3(3.3829410091894943, -144.30134326978651, -69.369597705718888); + double3 b2 = double3(231.90633760760829, 179.49885305180158, 473.22488496882136); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double3 a3 = double3(-135.66796762108243, -194.78736576567746, -33.473868147225062); + double3 b3 = double3(15.891647107848712, 270.04990614114786, 490.91400240869916); + bool3 r3 = bool3(true, true, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double3_operator_less_wide_scalar() + { + double3 a0 = double3(-221.86977325280651, -121.54646807608498, -97.52392511140738); + double b0 = (199.06751808853244); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 < b0, r0); + + double3 a1 = double3(479.88107775146193, 137.32880574899207, 282.96659601990439); + double b1 = (67.118990214131259); + bool3 r1 = bool3(false, false, false); + TestUtils.AreEqual(a1 < b1, r1); + + double3 a2 = double3(258.27909362422258, -288.08113278452356, 82.665427008022334); + double b2 = (-111.41316061439608); + bool3 r2 = bool3(false, true, false); + TestUtils.AreEqual(a2 < b2, r2); + + double3 a3 = double3(-361.64292042406413, 12.788020378345664, -66.703050406045747); + double b3 = (-68.088202269788951); + bool3 r3 = bool3(true, false, false); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double3_operator_less_scalar_wide() + { + double a0 = (-250.4849370692321); + double3 b0 = double3(-377.19654887597846, -505.14754104295167, 375.92672198634909); + bool3 r0 = bool3(false, false, true); + TestUtils.AreEqual(a0 < b0, r0); + + double a1 = (110.17393474940855); + double3 b1 = double3(-118.09757452742082, -40.45089079833167, -299.74430932651478); + bool3 r1 = bool3(false, false, false); + TestUtils.AreEqual(a1 < b1, r1); + + double a2 = (31.437125935888389); + double3 b2 = double3(-458.904539560389, 13.684679276163024, -458.50690839183841); + bool3 r2 = bool3(false, false, false); + TestUtils.AreEqual(a2 < b2, r2); + + double a3 = (248.27646624682302); + double3 b3 = double3(389.23142999654237, 488.74553679337055, -221.63786731550368); + bool3 r3 = bool3(true, true, false); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double3_operator_greater_wide_wide() + { + double3 a0 = double3(-229.29066501804192, 505.536608216137, -73.80706862071861); + double3 b0 = double3(-445.84502407808088, -420.03529210576568, 299.02440108872224); + bool3 r0 = bool3(true, true, false); + TestUtils.AreEqual(a0 > b0, r0); + + double3 a1 = double3(100.29203777215071, -419.21478124112582, -159.55974753180504); + double3 b1 = double3(-13.880978829171966, 151.56173593903043, -163.5094302461992); + bool3 r1 = bool3(true, false, true); + TestUtils.AreEqual(a1 > b1, r1); + + double3 a2 = double3(-396.7703608929973, 127.03739482119556, 489.13989733585151); + double3 b2 = double3(-391.09603733154762, 479.2837710228207, -77.674873149802409); + bool3 r2 = bool3(false, false, true); + TestUtils.AreEqual(a2 > b2, r2); + + double3 a3 = double3(51.91890885863404, 155.38475544535777, -135.63165027258526); + double3 b3 = double3(-46.5841996886694, -415.37701888353422, 71.466978344818131); + bool3 r3 = bool3(true, true, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double3_operator_greater_wide_scalar() + { + double3 a0 = double3(11.156317000815761, -411.02322382993214, 385.88556188432756); + double b0 = (-302.81693877969724); + bool3 r0 = bool3(true, false, true); + TestUtils.AreEqual(a0 > b0, r0); + + double3 a1 = double3(-485.10304831206008, 405.17534632476759, 173.57509740329124); + double b1 = (-491.18003033622171); + bool3 r1 = bool3(true, true, true); + TestUtils.AreEqual(a1 > b1, r1); + + double3 a2 = double3(69.269281181166548, -367.027771405423, -86.124509613087639); + double b2 = (501.30683183172107); + bool3 r2 = bool3(false, false, false); + TestUtils.AreEqual(a2 > b2, r2); + + double3 a3 = double3(-489.09058998948456, -18.149639853346002, -236.41493498367021); + double b3 = (-172.51816066192379); + bool3 r3 = bool3(false, true, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double3_operator_greater_scalar_wide() + { + double a0 = (453.54610201974685); + double3 b0 = double3(-226.20441423459187, -423.46500487973213, 409.40550227156166); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 > b0, r0); + + double a1 = (453.87706277048073); + double3 b1 = double3(87.475727837288673, 113.79560308987072, 176.40926154721956); + bool3 r1 = bool3(true, true, true); + TestUtils.AreEqual(a1 > b1, r1); + + double a2 = (-140.44002944810319); + double3 b2 = double3(-182.48286804113673, -158.29329188088576, -162.68531830733889); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 > b2, r2); + + double a3 = (-193.328676075362); + double3 b3 = double3(230.18129955519987, -102.58784227379965, 392.5205878655056); + bool3 r3 = bool3(false, false, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double3_operator_less_equal_wide_wide() + { + double3 a0 = double3(240.09053169940159, 462.2131528622532, 293.08251561461134); + double3 b0 = double3(-81.203838624620744, 493.63743876555816, -411.47211451617636); + bool3 r0 = bool3(false, true, false); + TestUtils.AreEqual(a0 <= b0, r0); + + double3 a1 = double3(-427.87067361728782, -405.5227226715175, 204.59190211286386); + double3 b1 = double3(99.164449499530974, -295.66769875943089, -480.46254824123463); + bool3 r1 = bool3(true, true, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double3 a2 = double3(294.670105832941, -327.56444445604666, -456.12326667091031); + double3 b2 = double3(74.414040361723892, 260.916124226952, 306.17329730939741); + bool3 r2 = bool3(false, true, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double3 a3 = double3(282.3012408140587, 421.8811549720732, -311.71284809322697); + double3 b3 = double3(139.56480438055689, -505.75247955031341, -489.62680958659706); + bool3 r3 = bool3(false, false, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double3_operator_less_equal_wide_scalar() + { + double3 a0 = double3(309.1924356469849, 69.673792633076118, -101.72418622939114); + double b0 = (292.92427148154206); + bool3 r0 = bool3(false, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double3 a1 = double3(-315.97240629604664, 424.15386577330241, -410.87006945669191); + double b1 = (-346.01106731314724); + bool3 r1 = bool3(false, false, true); + TestUtils.AreEqual(a1 <= b1, r1); + + double3 a2 = double3(-483.90265320423185, 320.44249287268258, -257.87003791419329); + double b2 = (183.82114538169515); + bool3 r2 = bool3(true, false, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double3 a3 = double3(-386.801748694294, 349.25012962392077, 485.31159304329731); + double b3 = (-182.9388249772316); + bool3 r3 = bool3(true, false, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double3_operator_less_equal_scalar_wide() + { + double a0 = (-511.15238141974078); + double3 b0 = double3(51.159012579898786, 340.44369022010062, 312.81429519914752); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double a1 = (354.19252626699983); + double3 b1 = double3(136.39671165142056, -94.767871185563422, 288.544332877055); + bool3 r1 = bool3(false, false, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double a2 = (304.04282369466625); + double3 b2 = double3(-148.61806089646092, -506.30010127755816, 27.581254256694251); + bool3 r2 = bool3(false, false, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double a3 = (48.471146844546865); + double3 b3 = double3(104.88351326104419, -488.6858386884843, -480.43516968210935); + bool3 r3 = bool3(true, false, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double3_operator_greater_equal_wide_wide() + { + double3 a0 = double3(-386.59181302906563, -157.12078221008215, 391.01526445477054); + double3 b0 = double3(153.44301350109424, 49.892483019219981, 78.025787628267835); + bool3 r0 = bool3(false, false, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double3 a1 = double3(-511.88687133783793, -5.4220387960886569, 287.64527501149348); + double3 b1 = double3(138.81373292711271, -225.51057802211056, -339.35611335344436); + bool3 r1 = bool3(false, true, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double3 a2 = double3(-122.53520184500849, 7.4814426933794493, 152.94642765491574); + double3 b2 = double3(-373.302078182484, 364.9358934671319, -322.71539870030961); + bool3 r2 = bool3(true, false, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double3 a3 = double3(48.986223482054811, 57.338148859021317, 300.46493138953338); + double3 b3 = double3(125.47818165900105, -25.776589167200314, 297.51890792395864); + bool3 r3 = bool3(false, true, true); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double3_operator_greater_equal_wide_scalar() + { + double3 a0 = double3(495.457423679278, -14.345115906719627, -463.47478053694346); + double b0 = (189.20512804258851); + bool3 r0 = bool3(true, false, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double3 a1 = double3(217.51749215718246, -377.65869706573835, 53.815095211293169); + double b1 = (-246.86571776441565); + bool3 r1 = bool3(true, false, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double3 a2 = double3(-123.33294373533357, 252.99433410027734, -116.44038277326172); + double b2 = (-221.50546441856096); + bool3 r2 = bool3(true, true, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double3 a3 = double3(-395.36331028275345, -287.00733889593153, 355.83704559683667); + double b3 = (164.77259667439978); + bool3 r3 = bool3(false, false, true); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double3_operator_greater_equal_scalar_wide() + { + double a0 = (215.43534169692327); + double3 b0 = double3(204.80295310020585, -101.10404853760451, -122.05503827056617); + bool3 r0 = bool3(true, true, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double a1 = (-70.456147941973143); + double3 b1 = double3(-239.62025677395064, -185.99272426683115, -455.61258027312); + bool3 r1 = bool3(true, true, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double a2 = (276.66581476697036); + double3 b2 = double3(79.39918831707871, 416.42054791768112, 379.27350801009379); + bool3 r2 = bool3(true, false, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double a3 = (-439.51472612820322); + double3 b3 = double3(67.141009600433108, -74.560638224035813, -367.25635474140586); + bool3 r3 = bool3(false, false, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double3_operator_add_wide_wide() + { + double3 a0 = double3(465.14837644302679, 278.91072548502621, -277.52992237616792); + double3 b0 = double3(483.99436186440028, -204.07667193379098, -365.67356007437854); + double3 r0 = double3(949.14273830742707, 74.834053551235229, -643.20348245054652); + TestUtils.AreEqual(a0 + b0, r0); + + double3 a1 = double3(-65.197214395365336, -473.32437561141529, -4.6955420992782138); + double3 b1 = double3(-509.92086076639634, -270.69751108377125, 486.76397846954126); + double3 r1 = double3(-575.11807516176168, -744.02188669518659, 482.06843637026304); + TestUtils.AreEqual(a1 + b1, r1); + + double3 a2 = double3(-470.53676698661258, -109.95011453980118, -178.70145782209067); + double3 b2 = double3(267.49177587567442, 251.6425212601398, 244.4951094335388); + double3 r2 = double3(-203.04499111093816, 141.69240672033862, 65.793651611448126); + TestUtils.AreEqual(a2 + b2, r2); + + double3 a3 = double3(-420.03378339299644, 290.71109236903078, -446.5296368294068); + double3 b3 = double3(-78.675763882079991, 352.20551340291536, 82.779185095233515); + double3 r3 = double3(-498.70954727507643, 642.91660577194614, -363.75045173417328); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double3_operator_add_wide_scalar() + { + double3 a0 = double3(459.89829728561369, -447.66336104258119, -94.438627525436971); + double b0 = (500.99725913489112); + double3 r0 = double3(960.89555642050482, 53.333898092309937, 406.55863160945415); + TestUtils.AreEqual(a0 + b0, r0); + + double3 a1 = double3(126.42986279652916, -349.64130060264904, -2.7912590516690443); + double b1 = (-36.254356162741033); + double3 r1 = double3(90.175506633788132, -385.89565676539007, -39.045615214410077); + TestUtils.AreEqual(a1 + b1, r1); + + double3 a2 = double3(-478.41478489265535, 268.092225914864, 41.32102133767728); + double b2 = (443.11525246273504); + double3 r2 = double3(-35.299532429920305, 711.207478377599, 484.43627380041232); + TestUtils.AreEqual(a2 + b2, r2); + + double3 a3 = double3(-471.25607584009697, 78.985822952811532, 202.14799151297098); + double b3 = (-2.6649749291431704); + double3 r3 = double3(-473.92105076924014, 76.320848023668361, 199.4830165838278); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double3_operator_add_scalar_wide() + { + double a0 = (-325.51276484388518); + double3 b0 = double3(-264.08813178915909, -106.00925998855814, -355.44729320865463); + double3 r0 = double3(-589.60089663304427, -431.52202483244332, -680.96005805253981); + TestUtils.AreEqual(a0 + b0, r0); + + double a1 = (-447.33029362528134); + double3 b1 = double3(-158.70021040677102, -199.48369154682553, 180.31809123806568); + double3 r1 = double3(-606.03050403205236, -646.81398517210687, -267.01220238721567); + TestUtils.AreEqual(a1 + b1, r1); + + double a2 = (337.57936898692481); + double3 b2 = double3(-37.05501486596421, 230.80498014707348, -140.17433339924287); + double3 r2 = double3(300.5243541209606, 568.38434913399828, 197.40503558768194); + TestUtils.AreEqual(a2 + b2, r2); + + double a3 = (18.02419591789328); + double3 b3 = double3(-138.61435825126915, 26.904163611542458, -374.53758233345); + double3 r3 = double3(-120.59016233337587, 44.928359529435738, -356.51338641555674); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double3_operator_sub_wide_wide() + { + double3 a0 = double3(133.37101680290471, -131.8321183341705, -197.29314407952739); + double3 b0 = double3(123.46028739002543, 359.56010048443454, -48.24847819667707); + double3 r0 = double3(9.9107294128792773, -491.39221881860504, -149.04466588285032); + TestUtils.AreEqual(a0 - b0, r0); + + double3 a1 = double3(-485.286571013409, -337.55033103448818, 471.66710470228782); + double3 b1 = double3(478.97904680621764, 207.15832886805686, 142.36730462981723); + double3 r1 = double3(-964.26561781962664, -544.708659902545, 329.29980007247059); + TestUtils.AreEqual(a1 - b1, r1); + + double3 a2 = double3(146.5066197600712, -130.58504372955537, 110.77707367333448); + double3 b2 = double3(-125.60551005490379, -65.299004823574307, -477.876434787119); + double3 r2 = double3(272.112129814975, -65.286038905981059, 588.65350846045351); + TestUtils.AreEqual(a2 - b2, r2); + + double3 a3 = double3(-235.54160486699158, 78.879356659427, -347.68616811730254); + double3 b3 = double3(164.50000031501986, 428.00958915614035, 72.6278169493321); + double3 r3 = double3(-400.04160518201144, -349.13023249671335, -420.31398506663464); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double3_operator_sub_wide_scalar() + { + double3 a0 = double3(48.936717294592768, 410.45158953706346, -364.44171612544062); + double b0 = (-291.59041442144212); + double3 r0 = double3(340.52713171603489, 702.04200395850557, -72.8513017039985); + TestUtils.AreEqual(a0 - b0, r0); + + double3 a1 = double3(163.98060353285666, 110.91942339340198, 204.35834441164434); + double b1 = (-460.06732318367222); + double3 r1 = double3(624.04792671652888, 570.9867465770742, 664.42566759531655); + TestUtils.AreEqual(a1 - b1, r1); + + double3 a2 = double3(180.26971420099483, -470.26204297983185, 400.53491968686455); + double b2 = (-377.92569344952972); + double3 r2 = double3(558.19540765052454, -92.33634953030213, 778.46061313639427); + TestUtils.AreEqual(a2 - b2, r2); + + double3 a3 = double3(461.50756499800252, 21.605312595891405, 246.35072171238755); + double b3 = (-246.28726660753006); + double3 r3 = double3(707.79483160553264, 267.89257920342146, 492.63798831991761); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double3_operator_sub_scalar_wide() + { + double a0 = (294.58645905861); + double3 b0 = double3(452.35251757705237, 256.98980891750648, -275.159888634067); + double3 r0 = double3(-157.76605851844238, 37.59665014110351, 569.746347692677); + TestUtils.AreEqual(a0 - b0, r0); + + double a1 = (-89.027518075437968); + double3 b1 = double3(488.22838829840919, -333.21728030462623, -64.232989102710519); + double3 r1 = double3(-577.25590637384721, 244.18976222918826, -24.794528972727448); + TestUtils.AreEqual(a1 - b1, r1); + + double a2 = (-66.041730196234653); + double3 b2 = double3(341.20492831859963, -385.775056303374, 75.394746577085357); + double3 r2 = double3(-407.24665851483428, 319.73332610713936, -141.43647677332); + TestUtils.AreEqual(a2 - b2, r2); + + double a3 = (354.94371645289641); + double3 b3 = double3(169.13141520746581, 88.216608326982964, 1.7350065716240124); + double3 r3 = double3(185.8123012454306, 266.72710812591345, 353.2087098812724); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double3_operator_mul_wide_wide() + { + double3 a0 = double3(-394.78053898121254, -412.37219519744264, -25.874570143350638); + double3 b0 = double3(-149.76397831261346, -345.04538671348496, -284.33404721148963); + double3 r0 = double3(59123.904078224172, 142287.1235617903, 7357.0212487164608); + TestUtils.AreEqual(a0 * b0, r0); + + double3 a1 = double3(-241.04595886964626, -93.675987525692221, 244.15999257013198); + double3 b1 = double3(267.97923648915219, -326.64849558782225, -150.68967754705329); + double3 r1 = double3(-64595.312016683383, 30599.120397970968, -36792.390550284115); + TestUtils.AreEqual(a1 * b1, r1); + + double3 a2 = double3(494.68846606402121, 53.537962700025105, -239.49641167349017); + double3 b2 = double3(207.73243794577775, 366.19289248352538, 358.88076202891807); + double3 r2 = double3(102762.84107913627, 19605.221418797286, -85950.654724573629); + TestUtils.AreEqual(a2 * b2, r2); + + double3 a3 = double3(236.67584644848284, -211.85620818466703, -216.65482030466887); + double3 b3 = double3(214.85359368792433, 253.42280900358355, -307.71382751488773); + double3 r3 = double3(50850.6561485879, -53689.195383006307, 66667.684005499876); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double3_operator_mul_wide_scalar() + { + double3 a0 = double3(328.20302191758674, -290.10672272839895, 236.99572454998065); + double b0 = (192.21119055161773); + double3 r0 = double3(63084.293585418032, -55761.758562653624, 45553.230371395039); + TestUtils.AreEqual(a0 * b0, r0); + + double3 a1 = double3(120.48136692889102, 134.86723214707672, -477.31047104173825); + double b1 = (357.90315811610924); + double3 r1 = double3(43120.661717995856, 48269.408311817213, -170830.92498772583); + TestUtils.AreEqual(a1 * b1, r1); + + double3 a2 = double3(-438.272912467957, -238.40500103608008, 422.08249374017237); + double b2 = (-46.729179165665585); + double3 r2 = double3(20480.133450173231, 11140.470007405675, -19723.568472675437); + TestUtils.AreEqual(a2 * b2, r2); + + double3 a3 = double3(-48.83483722099794, 119.35660391643489, -196.995807977857); + double b3 = (355.30832998608628); + double3 r3 = double3(-17351.424458135145, 42408.39561035925, -69994.2515468721); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double3_operator_mul_scalar_wide() + { + double a0 = (-464.534700371574); + double3 b0 = double3(329.36093846399376, -198.68342671109525, 184.07942518223047); + double3 r0 = double3(-152999.58486347177, 92295.346096036214, -85511.280621599); + TestUtils.AreEqual(a0 * b0, r0); + + double a1 = (256.01618754864489); + double3 b1 = double3(266.22629297255833, -97.894749448585685, 159.74810583877752); + double3 r1 = double3(68158.240552042975, -25062.640534856713, 40898.101024961237); + TestUtils.AreEqual(a1 * b1, r1); + + double a2 = (-351.82222263506719); + double3 b2 = double3(491.80157660497423, 49.902031206480274, 424.46256871915546); + double3 r2 = double3(-173026.72377659229, -17556.643533068374, -149335.36435216322); + TestUtils.AreEqual(a2 * b2, r2); + + double a3 = (160.11807616060514); + double3 b3 = double3(-395.99208492599058, 125.20168858636248, -265.01581991138676); + double3 r3 = double3(-63405.490813176577, 20047.053508507553, -42433.823236336641); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double3_operator_div_wide_wide() + { + double3 a0 = double3(246.26574933075619, -269.85612953354428, -451.61952588130697); + double3 b0 = double3(172.11981423763552, -77.141104972521362, -325.8353723612779); + double3 r0 = double3(1.4307809383918566, 3.4982144685336105, 1.3860359070548143); + TestUtils.AreEqual(a0 / b0, r0); + + double3 a1 = double3(-7.38850236283082, -308.20558681534862, -373.394808704683); + double3 b1 = double3(-450.60868117334724, -261.26215398556656, -122.44949847201326); + double3 r1 = double3(0.016396715535066435, 1.1796794220427942, 3.0493780159501847); + TestUtils.AreEqual(a1 / b1, r1); + + double3 a2 = double3(360.41863482092447, 25.80972458133931, -274.050461181463); + double3 b2 = double3(-93.210781379235357, -442.00522705633438, 484.36271380091216); + double3 r2 = double3(-3.8667054335113131, -0.05839235149599218, -0.56579594872388561); + TestUtils.AreEqual(a2 / b2, r2); + + double3 a3 = double3(127.53858977534742, -447.6717600522897, -137.4586017771897); + double3 b3 = double3(-390.78178686219348, 402.02531714086672, 316.65072193585831); + double3 r3 = double3(-0.32636779415802974, -1.1135412148569459, -0.43410165287743668); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double3_operator_div_wide_scalar() + { + double3 a0 = double3(-244.51745116175965, 69.112274917360537, -333.02311888943575); + double b0 = (-60.024377612408443); + double3 r0 = double3(4.0736357608014941, -1.1514034408425655, 5.5481311449798705); + TestUtils.AreEqual(a0 / b0, r0); + + double3 a1 = double3(257.39682519500923, 154.34436066185322, 131.52659160062979); + double b1 = (403.24561257066466); + double3 r1 = double3(0.63831277308665835, 0.38275521382097105, 0.32616992597180733); + TestUtils.AreEqual(a1 / b1, r1); + + double3 a2 = double3(-261.88639200007844, -275.53868187383688, 210.55792174607416); + double b2 = (-348.92380516087815); + double3 r2 = double3(0.75055467161184541, 0.78968152300985706, -0.60344957446796244); + TestUtils.AreEqual(a2 / b2, r2); + + double3 a3 = double3(287.64239968342815, 491.78708600056689, -26.63160015392657); + double b3 = (504.37224626185946); + double3 r3 = double3(0.57029783421923308, 0.97504787316398334, -0.052801478176695719); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double3_operator_div_scalar_wide() + { + double a0 = (41.737658758525527); + double3 b0 = double3(-422.676129776368, 248.12963235011773, 449.39137741988122); + double3 r0 = double3(-0.098746193168297289, 0.1682090863683405, 0.092875967042706856); + TestUtils.AreEqual(a0 / b0, r0); + + double a1 = (245.85813796047967); + double3 b1 = double3(-326.62061253498337, 163.71510489457989, 333.664472020075); + double3 r1 = double3(-0.75273307478151441, 1.5017437646867933, 0.73684242278478951); + TestUtils.AreEqual(a1 / b1, r1); + + double a2 = (38.291076916405473); + double3 b2 = double3(-472.97976062864984, 192.23013958345643, -200.29686960964318); + double3 r2 = double3(-0.080957115089896864, 0.19919392973119834, -0.19117161936195318); + TestUtils.AreEqual(a2 / b2, r2); + + double a3 = (-490.18150376257557); + double3 b3 = double3(-211.10257468517057, -322.85234108700058, -137.98529035317961); + double3 r3 = double3(2.3220062781972768, 1.5182838758802248, 3.5524185404685804); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double3_operator_mod_wide_wide() + { + double3 a0 = double3(-442.30985924336585, 368.50046246522129, -1.0938966279355213); + double3 b0 = double3(-43.245045443645211, -144.19587690392319, -62.640481739603217); + double3 r0 = double3(-9.8594048069137443, 80.1087086573749, -1.0938966279355213); + TestUtils.AreEqual(a0 % b0, r0); + + double3 a1 = double3(-364.67383473211612, -197.34394487987458, -34.034902350062); + double3 b1 = double3(-336.82826510855381, -154.6102545981343, -154.02935583611452); + double3 r1 = double3(-27.845569623562312, -42.73369028174028, -34.034902350062); + TestUtils.AreEqual(a1 % b1, r1); + + double3 a2 = double3(-101.34858350704826, 208.31857142612273, -140.77031404374645); + double3 b2 = double3(487.0462093237071, -469.82909105244516, -145.20377237405802); + double3 r2 = double3(-101.34858350704826, 208.31857142612273, -140.77031404374645); + TestUtils.AreEqual(a2 % b2, r2); + + double3 a3 = double3(183.446989383291, -463.36838100076113, 83.839106360375467); + double3 b3 = double3(-203.38401780062543, -22.520082245823062, 224.6900237652892); + double3 r3 = double3(183.446989383291, -12.966736084299896, 83.839106360375467); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double3_operator_mod_wide_scalar() + { + double3 a0 = double3(-433.41699548876704, -5.5141427542614565, 393.39439958771425); + double b0 = (-90.499235433758827); + double3 r0 = double3(-71.420053753731736, -5.5141427542614565, 31.39745785267894); + TestUtils.AreEqual(a0 % b0, r0); + + double3 a1 = double3(299.41153277988155, -502.939041133476, -450.80766245853511); + double b1 = (-120.80601626299602); + double3 r1 = double3(57.799500253889505, -19.714976081491898, -88.389613669547032); + TestUtils.AreEqual(a1 % b1, r1); + + double3 a2 = double3(186.09479698263794, -318.78148356023314, 433.45469041981482); + double b2 = (-84.473635951277629); + double3 r2 = double3(17.147525080082687, -65.360575706400255, 11.086510663426679); + TestUtils.AreEqual(a2 % b2, r2); + + double3 a3 = double3(-54.6001856581309, -429.71466728193434, 222.36186109406958); + double b3 = (-172.33886607565864); + double3 r3 = double3(-54.6001856581309, -85.036935130617053, 50.022995018410938); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double3_operator_mod_scalar_wide() + { + double a0 = (-396.4224028049141); + double3 b0 = double3(-159.14024384279747, 230.17333399046834, 14.779358632294134); + double3 r0 = double3(-78.141915119319151, -166.24906881444576, -12.159078365266623); + TestUtils.AreEqual(a0 % b0, r0); + + double a1 = (-303.15649738123477); + double3 b1 = double3(399.63502020371845, 206.69470534412881, 397.04482263934096); + double3 r1 = double3(-303.15649738123477, -96.461792037105965, -303.15649738123477); + TestUtils.AreEqual(a1 % b1, r1); + + double a2 = (-393.89064735634747); + double3 b2 = double3(-372.06709426085797, 201.01229796233224, -95.5668547598491); + double3 r2 = double3(-21.8235530954895, -192.87834939401523, -11.6232283169511); + TestUtils.AreEqual(a2 % b2, r2); + + double a3 = (-258.95146882671463); + double3 b3 = double3(106.98357563232241, 469.3235559264773, -34.808985011097491); + double3 r3 = double3(-44.984317562069805, -258.95146882671463, -15.288573749032196); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double3_operator_plus() + { + double3 a0 = double3(271.6708086802023, -79.080240524876956, -330.98506203805334); + double3 r0 = double3(271.6708086802023, -79.080240524876956, -330.98506203805334); + TestUtils.AreEqual(+a0, r0); + + double3 a1 = double3(31.824682965793045, 319.22218742930431, 190.32466015141677); + double3 r1 = double3(31.824682965793045, 319.22218742930431, 190.32466015141677); + TestUtils.AreEqual(+a1, r1); + + double3 a2 = double3(-350.30858270745193, 102.0544069288552, -107.00351267075331); + double3 r2 = double3(-350.30858270745193, 102.0544069288552, -107.00351267075331); + TestUtils.AreEqual(+a2, r2); + + double3 a3 = double3(-428.77622075973835, 234.77393042052813, 34.283600107898792); + double3 r3 = double3(-428.77622075973835, 234.77393042052813, 34.283600107898792); + TestUtils.AreEqual(+a3, r3); + } + + [TestCompiler] + public static void double3_operator_neg() + { + double3 a0 = double3(420.22718854445372, -196.25749811728366, -335.42683068636188); + double3 r0 = double3(-420.22718854445372, 196.25749811728366, 335.42683068636188); + TestUtils.AreEqual(-a0, r0); + + double3 a1 = double3(509.04366969924592, -498.57532071442125, -495.8379526063045); + double3 r1 = double3(-509.04366969924592, 498.57532071442125, 495.8379526063045); + TestUtils.AreEqual(-a1, r1); + + double3 a2 = double3(-270.85946787095605, 268.23670662019254, -180.60051473444349); + double3 r2 = double3(270.85946787095605, -268.23670662019254, 180.60051473444349); + TestUtils.AreEqual(-a2, r2); + + double3 a3 = double3(223.38126312167446, -395.68154186554324, -349.14948885010062); + double3 r3 = double3(-223.38126312167446, 395.68154186554324, 349.14948885010062); + TestUtils.AreEqual(-a3, r3); + } + + [TestCompiler] + public static void double3_operator_prefix_inc() + { + double3 a0 = double3(-99.79557113526181, 458.74185082816609, 96.179026886904126); + double3 r0 = double3(-98.79557113526181, 459.74185082816609, 97.179026886904126); + TestUtils.AreEqual(++a0, r0); + + double3 a1 = double3(-48.552469514567633, -299.23014583216525, -323.61485853959567); + double3 r1 = double3(-47.552469514567633, -298.23014583216525, -322.61485853959567); + TestUtils.AreEqual(++a1, r1); + + double3 a2 = double3(-456.89028832730384, -305.58477344437722, 64.0964734852763); + double3 r2 = double3(-455.89028832730384, -304.58477344437722, 65.0964734852763); + TestUtils.AreEqual(++a2, r2); + + double3 a3 = double3(148.67930967578627, -115.5592263283018, -326.87781992874937); + double3 r3 = double3(149.67930967578627, -114.5592263283018, -325.87781992874937); + TestUtils.AreEqual(++a3, r3); + } + + [TestCompiler] + public static void double3_operator_postfix_inc() + { + double3 a0 = double3(322.94356623429042, 472.05246542024076, 203.48761925636211); + double3 r0 = double3(322.94356623429042, 472.05246542024076, 203.48761925636211); + TestUtils.AreEqual(a0++, r0); + + double3 a1 = double3(-49.854570650427888, 455.33662459595905, 271.45466840986842); + double3 r1 = double3(-49.854570650427888, 455.33662459595905, 271.45466840986842); + TestUtils.AreEqual(a1++, r1); + + double3 a2 = double3(55.736877228942149, -174.17301925186672, -427.40105100506969); + double3 r2 = double3(55.736877228942149, -174.17301925186672, -427.40105100506969); + TestUtils.AreEqual(a2++, r2); + + double3 a3 = double3(215.11022744658874, -333.05045262586816, 241.46487509527469); + double3 r3 = double3(215.11022744658874, -333.05045262586816, 241.46487509527469); + TestUtils.AreEqual(a3++, r3); + } + + [TestCompiler] + public static void double3_operator_prefix_dec() + { + double3 a0 = double3(-416.20121712992022, -96.637880131899351, -50.145671629414721); + double3 r0 = double3(-417.20121712992022, -97.637880131899351, -51.145671629414721); + TestUtils.AreEqual(--a0, r0); + + double3 a1 = double3(-207.31644759295341, -304.40081920493435, 337.96895734312432); + double3 r1 = double3(-208.31644759295341, -305.40081920493435, 336.96895734312432); + TestUtils.AreEqual(--a1, r1); + + double3 a2 = double3(246.08898293510492, -227.44280134301761, 298.28480710568135); + double3 r2 = double3(245.08898293510492, -228.44280134301761, 297.28480710568135); + TestUtils.AreEqual(--a2, r2); + + double3 a3 = double3(326.50782338087811, -478.03137253133178, -326.45297852459038); + double3 r3 = double3(325.50782338087811, -479.03137253133178, -327.45297852459038); + TestUtils.AreEqual(--a3, r3); + } + + [TestCompiler] + public static void double3_operator_postfix_dec() + { + double3 a0 = double3(-376.59242719066907, 16.969734438215255, -0.25066399585949739); + double3 r0 = double3(-376.59242719066907, 16.969734438215255, -0.25066399585949739); + TestUtils.AreEqual(a0--, r0); + + double3 a1 = double3(-202.32328734282555, 47.856652520530247, -281.11170376516492); + double3 r1 = double3(-202.32328734282555, 47.856652520530247, -281.11170376516492); + TestUtils.AreEqual(a1--, r1); + + double3 a2 = double3(-262.062590959511, 450.12809559801974, -129.23265582380475); + double3 r2 = double3(-262.062590959511, 450.12809559801974, -129.23265582380475); + TestUtils.AreEqual(a2--, r2); + + double3 a3 = double3(-332.15495768755443, 205.46112570793423, -230.22777878038016); + double3 r3 = double3(-332.15495768755443, 205.46112570793423, -230.22777878038016); + TestUtils.AreEqual(a3--, r3); + } + + [TestCompiler] + public static void double3_shuffle_result_1() + { + double3 a = double3(0, 1, 2); + double3 b = double3(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 double3_shuffle_result_2() + { + double3 a = double3(0, 1, 2); + double3 b = double3(3, 4, 5); + + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY), double2(4, 4)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), double2(4, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightX), double2(1, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftZ), double2(5, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY), double2(5, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ), double2(1, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftZ), double2(3, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX), double2(5, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ), double2(5, 5)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY), double2(4, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightZ), double2(4, 5)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftX), double2(5, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX), double2(4, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightY), double2(5, 4)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX), double2(3, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ), double2(1, 2)); + } + + [TestCompiler] + public static void double3_shuffle_result_3() + { + double3 a = double3(0, 1, 2); + double3 b = double3(3, 4, 5); + + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightZ, ShuffleComponent.RightX), double3(1, 5, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftZ), double3(4, 0, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightX), double3(2, 5, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftY), double3(4, 0, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightY, ShuffleComponent.LeftZ), double3(5, 4, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.LeftX, ShuffleComponent.LeftY), double3(2, 0, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightY, ShuffleComponent.RightX), double3(2, 4, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.LeftY, ShuffleComponent.RightZ), double3(2, 1, 5)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightZ), double3(4, 4, 5)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY), double3(4, 3, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX), double3(5, 5, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.LeftY, ShuffleComponent.RightX), double3(5, 1, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.RightZ), double3(4, 1, 5)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.RightY), double3(2, 3, 4)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightY), double3(4, 0, 4)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.RightZ), double3(4, 0, 5)); + } + + [TestCompiler] + public static void double3_shuffle_result_4() + { + double3 a = double3(0, 1, 2); + double3 b = double3(3, 4, 5); + + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.LeftY), double4(1, 2, 3, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.RightY), double4(4, 2, 5, 4)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightY, ShuffleComponent.RightZ, ShuffleComponent.LeftY), double4(4, 4, 5, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.LeftY), double4(3, 3, 1, 1)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftY, ShuffleComponent.LeftY, ShuffleComponent.LeftX), double4(4, 1, 1, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.RightZ), double4(3, 4, 3, 5)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightZ), double4(1, 5, 0, 5)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.LeftX, ShuffleComponent.LeftX, ShuffleComponent.LeftX), double4(4, 0, 0, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.RightZ, ShuffleComponent.LeftZ, ShuffleComponent.LeftX), double4(3, 5, 2, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightY, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightX), double4(4, 3, 1, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftX, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX), double4(0, 2, 5, 0)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftY, ShuffleComponent.RightY, ShuffleComponent.RightZ, ShuffleComponent.RightZ), double4(1, 4, 5, 5)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightX, ShuffleComponent.LeftY, ShuffleComponent.RightX), double4(2, 3, 1, 3)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.LeftY, ShuffleComponent.LeftZ), double4(3, 0, 1, 2)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.RightZ, ShuffleComponent.RightX, ShuffleComponent.LeftX, ShuffleComponent.RightY), double4(5, 3, 0, 4)); + TestUtils.AreEqual(shuffle(a, b, ShuffleComponent.LeftZ, ShuffleComponent.RightZ, ShuffleComponent.LeftX, ShuffleComponent.RightY), double4(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/TestDouble3.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/TestDouble3.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..1d5e30653f8bc30e6e5dde2e4ef9b85f293a1dd5 --- /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/TestDouble3.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 617e00812628df941a5b85ca46e4ca9d +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/TestDouble3x2.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/TestDouble3x2.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..8022b755b26b731d8ea4d8867cd2cab6105419c9 --- /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/TestDouble3x2.gen.cs @@ -0,0 +1,943 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestDouble3x2 + { + [TestCompiler] + public static void double3x2_zero() + { + TestUtils.AreEqual(double3x2.zero.c0.x, 0.0); + TestUtils.AreEqual(double3x2.zero.c0.y, 0.0); + TestUtils.AreEqual(double3x2.zero.c0.z, 0.0); + TestUtils.AreEqual(double3x2.zero.c1.x, 0.0); + TestUtils.AreEqual(double3x2.zero.c1.y, 0.0); + TestUtils.AreEqual(double3x2.zero.c1.z, 0.0); + } + + [TestCompiler] + public static void double3x2_operator_equal_wide_wide() + { + double3x2 a0 = double3x2(-135.18925172425304, -49.094127439471947, 169.12980778940482, 240.80529772527757, 314.73919382446411, 442.39301916695808); + double3x2 b0 = double3x2(-220.01464591734793, 66.980020792679852, 499.20158576369363, -371.113114291389, 208.44865212610398, 390.80369133074009); + bool3x2 r0 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double3x2 a1 = double3x2(177.92444881141398, 335.53340283759564, 168.1544516869609, 350.72955982327903, 367.17843668869625, 46.941470406456574); + double3x2 b1 = double3x2(-72.443806920407269, 362.97643273089841, 194.6783255053117, 471.6448635867074, -404.04466719368691, -144.69675476136467); + bool3x2 r1 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double3x2 a2 = double3x2(188.76415094582558, -97.211392209497944, -293.3210057193977, -234.82292353120766, 417.03371329653714, 26.386443388828297); + double3x2 b2 = double3x2(-494.44664334433463, -252.97038209297244, 234.41711746641306, 398.72397465199413, 260.42872083393331, 370.14420502732708); + bool3x2 r2 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double3x2 a3 = double3x2(269.24572265764959, 29.474191440955792, 479.48521469509467, -237.23094355186026, -221.98371349181224, -506.67253255596034); + double3x2 b3 = double3x2(89.579862397899774, -434.81684347373289, -109.84533815730612, 336.9730161805511, -409.15498156526826, 500.38755273278218); + bool3x2 r3 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_equal_wide_scalar() + { + double3x2 a0 = double3x2(65.671194345537174, 404.41550440546848, -269.7301577393572, 83.630607882342588, 152.99450476141385, -155.86829836474186); + double b0 = (-155.8157547245807); + bool3x2 r0 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double3x2 a1 = double3x2(314.67125597348024, 290.04894007837811, -132.63519460178691, -65.667489797653388, -69.683271678948415, -191.19075521789063); + double b1 = (386.36515325417986); + bool3x2 r1 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double3x2 a2 = double3x2(186.84520086406042, -319.14406481345372, -49.701092981594172, -300.88189925853248, 333.39685193328046, 386.377503336583); + double b2 = (-232.89569221851218); + bool3x2 r2 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double3x2 a3 = double3x2(-296.70189084517858, 141.54237968360189, -227.32334314441465, 83.872881689981, -410.91687483848858, 110.50128345866744); + double b3 = (-309.11719741910565); + bool3x2 r3 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_equal_scalar_wide() + { + double a0 = (36.383921878591195); + double3x2 b0 = double3x2(-400.48919958644046, -71.286823544319191, 156.97811491646712, -225.23872791288363, 499.14180993435059, -211.97992358542047); + bool3x2 r0 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double a1 = (428.31192394174263); + double3x2 b1 = double3x2(-489.50133322621758, -5.6915457275190988, -30.865948453017495, -362.98307221149241, 184.50319322594589, -160.47062142215231); + bool3x2 r1 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double a2 = (316.66882315122928); + double3x2 b2 = double3x2(390.36923879681581, 505.10510301268891, -294.64870967280524, 443.19909283295226, 96.559236333034619, -257.01294601010761); + bool3x2 r2 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double a3 = (-245.05497538533757); + double3x2 b3 = double3x2(326.46485176983515, -23.959890138339176, -168.6948808025079, 386.24859279498855, -227.09065185631192, -336.61242524562982); + bool3x2 r3 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_not_equal_wide_wide() + { + double3x2 a0 = double3x2(279.99414576217259, -43.342018386042696, -465.72473523846116, 317.46655645848557, 85.714987079480238, 360.89050572034466); + double3x2 b0 = double3x2(-460.912120318465, -476.00904844515446, 468.13642070635058, -341.01254312182431, -62.658060341448561, -458.80166718866752); + bool3x2 r0 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double3x2 a1 = double3x2(366.08152668833804, 154.5428384070018, 332.426219856565, 397.11323160543725, -431.3749584776233, 489.01079319837072); + double3x2 b1 = double3x2(-457.73023316717251, -59.523265627922171, 3.024243117787023, 155.81276352508587, -19.839918384253963, -6.0169332055453992); + bool3x2 r1 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double3x2 a2 = double3x2(398.43358320669904, -489.81794594685454, 171.4049242340983, -67.829682620162941, -192.27871498478515, 227.84082494854965); + double3x2 b2 = double3x2(-406.20792145571107, -102.42070083619126, -40.362921018322425, 452.67542645552919, 93.257571979080126, -258.37806689849964); + bool3x2 r2 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double3x2 a3 = double3x2(62.138187675801191, 262.18648755838467, -404.05309052209049, 34.449567572423007, -204.79578719138902, -285.41180314003111); + double3x2 b3 = double3x2(-184.04980405794913, -379.23531192319251, -370.68729537105526, -255.94724023339677, 29.055771602809273, 322.40763226263584); + bool3x2 r3 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_not_equal_wide_scalar() + { + double3x2 a0 = double3x2(-155.44111282911206, -19.426602134214079, 174.63305409934048, 507.9207296352464, 59.177048472304364, 171.15146430356026); + double b0 = (-393.41354173860213); + bool3x2 r0 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double3x2 a1 = double3x2(-58.923273352404692, 492.20105361016522, -165.24150879925185, 270.34102333259818, -380.24326222960059, 501.8990516615562); + double b1 = (-398.17684835855704); + bool3x2 r1 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double3x2 a2 = double3x2(-134.34545642433011, 46.771004937016869, 161.45995123752391, 261.51423442620512, -145.61239559278471, -0.44992661497087738); + double b2 = (458.40042302496749); + bool3x2 r2 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double3x2 a3 = double3x2(350.46143047439932, 242.66402232025939, 382.67707675633812, -468.96794221781562, -497.45947789468778, -80.932258882062627); + double b3 = (202.22103724359579); + bool3x2 r3 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_not_equal_scalar_wide() + { + double a0 = (478.35313938481409); + double3x2 b0 = double3x2(459.55319592894671, 436.45324369727314, -488.71416806090349, 392.76794475725296, -266.73665369056937, 338.55788270503183); + bool3x2 r0 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double a1 = (-338.10012475498957); + double3x2 b1 = double3x2(-152.3145445102428, -452.82067868338, 209.43931422449612, 50.107968592135194, 372.4343656843688, -488.0213141329686); + bool3x2 r1 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double a2 = (489.74075697816011); + double3x2 b2 = double3x2(270.40006149485714, -472.8467831429312, -286.85046090132113, -384.69186681541237, 443.42352959300558, 358.74720900074919); + bool3x2 r2 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double a3 = (-15.414077527548216); + double3x2 b3 = double3x2(-342.17916194637269, 468.96750400446706, -130.56808501601597, 401.7858013593526, -268.35225761511936, -239.231014124691); + bool3x2 r3 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_less_wide_wide() + { + double3x2 a0 = double3x2(51.710243010758518, -313.85556450200062, 283.04767359562572, 235.02188621974642, 44.0783565249659, -207.25566659088042); + double3x2 b0 = double3x2(-261.83523881707117, -19.810742149041403, -149.25882084167506, 205.99822316225539, -306.02438535635565, 102.12168006884008); + bool3x2 r0 = bool3x2(false, true, false, false, false, true); + TestUtils.AreEqual(a0 < b0, r0); + + double3x2 a1 = double3x2(3.3829410091894943, -144.30134326978651, -69.369597705718888, -135.66796762108243, -194.78736576567746, -33.473868147225062); + double3x2 b1 = double3x2(231.90633760760829, 179.49885305180158, 473.22488496882136, 15.891647107848712, 270.04990614114786, 490.91400240869916); + bool3x2 r1 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double3x2 a2 = double3x2(-19.675088653189619, 423.23796697297973, -71.698315415390937, -501.88598870760109, 7.6438391244242894, 302.26289214857991); + double3x2 b2 = double3x2(-185.73412164753961, 76.433086669274189, 97.75231246731812, 419.30080600236579, 73.953208242521214, 481.03232382285978); + bool3x2 r2 = bool3x2(false, false, true, true, true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double3x2 a3 = double3x2(-140.55051786291904, -436.586703265359, -351.441728040316, 364.97084896870467, 301.894133946809, 407.55097336673691); + double3x2 b3 = double3x2(7.00747371046225, -7.3240954910051528, -413.07575793428146, -154.1188920261892, 449.20288989003882, 502.01430797111914); + bool3x2 r3 = bool3x2(true, true, false, false, true, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_less_wide_scalar() + { + double3x2 a0 = double3x2(-221.86977325280651, -121.54646807608498, -97.52392511140738, 479.88107775146193, 67.118990214131259, 137.32880574899207); + double b0 = (199.06751808853244); + bool3x2 r0 = bool3x2(true, true, true, false, true, true); + TestUtils.AreEqual(a0 < b0, r0); + + double3x2 a1 = double3x2(282.96659601990439, -111.41316061439608, -288.08113278452356, 82.665427008022334, -361.64292042406413, -68.088202269788951); + double b1 = (258.27909362422258); + bool3x2 r1 = bool3x2(false, true, true, true, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double3x2 a2 = double3x2(12.788020378345664, -78.762971199472872, 25.727694284975428, 101.37087182950734, -330.442660724019, -48.920521520506838); + double b2 = (-66.703050406045747); + bool3x2 r2 = bool3x2(false, true, false, false, true, false); + TestUtils.AreEqual(a2 < b2, r2); + + double3x2 a3 = double3x2(359.60440914686978, 241.27682101040932, -183.43778165776178, 423.02713580756779, -334.62272349680904, -98.315578744893685); + double b3 = (-8.15008759878117); + bool3x2 r3 = bool3x2(false, false, true, false, true, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_less_scalar_wide() + { + double a0 = (-250.4849370692321); + double3x2 b0 = double3x2(-377.19654887597846, -505.14754104295167, 375.92672198634909, 110.17393474940855, -118.09757452742082, -40.45089079833167); + bool3x2 r0 = bool3x2(false, false, true, true, true, true); + TestUtils.AreEqual(a0 < b0, r0); + + double a1 = (-299.74430932651478); + double3x2 b1 = double3x2(31.437125935888389, -458.904539560389, 13.684679276163024, -458.50690839183841, 248.27646624682302, 389.23142999654237); + bool3x2 r1 = bool3x2(true, false, true, false, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double a2 = (488.74553679337055); + double3x2 b2 = double3x2(-221.63786731550368, -424.26720329013989, 249.05904948388184, -22.136127720650336, -442.24773928255206, -340.85755721705851); + bool3x2 r2 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a2 < b2, r2); + + double a3 = (-95.1117256130612); + double3x2 b3 = double3x2(15.409410245441563, 87.292497437117845, 495.06764220402931, 316.01850309782594, -125.56811505442863, 122.16476803746298); + bool3x2 r3 = bool3x2(true, true, true, true, false, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_greater_wide_wide() + { + double3x2 a0 = double3x2(-229.29066501804192, 505.536608216137, -73.80706862071861, 100.29203777215071, -419.21478124112582, -159.55974753180504); + double3x2 b0 = double3x2(-445.84502407808088, -420.03529210576568, 299.02440108872224, -13.880978829171966, 151.56173593903043, -163.5094302461992); + bool3x2 r0 = bool3x2(true, true, false, true, false, true); + TestUtils.AreEqual(a0 > b0, r0); + + double3x2 a1 = double3x2(-396.7703608929973, 127.03739482119556, 489.13989733585151, 51.91890885863404, 155.38475544535777, -135.63165027258526); + double3x2 b1 = double3x2(-391.09603733154762, 479.2837710228207, -77.674873149802409, -46.5841996886694, -415.37701888353422, 71.466978344818131); + bool3x2 r1 = bool3x2(false, false, true, true, true, false); + TestUtils.AreEqual(a1 > b1, r1); + + double3x2 a2 = double3x2(-425.97813554572787, -228.430505143679, 383.03834909155887, 136.53358298937496, 8.602427725029429, -251.3243674018068); + double3x2 b2 = double3x2(-206.06102643071722, 360.83628218287424, 236.96878658838978, 14.550342328171382, 364.735178402036, -159.0612996365229); + bool3x2 r2 = bool3x2(false, false, true, true, false, false); + TestUtils.AreEqual(a2 > b2, r2); + + double3x2 a3 = double3x2(-345.954920691417, -170.565928777012, -293.25441588706076, 139.1249764613458, 214.3030732675935, 238.76991211565678); + double3x2 b3 = double3x2(226.63117490831348, 182.79602512288659, 341.83937398616195, -79.130463875425278, -247.29681956362765, 164.58913882290437); + bool3x2 r3 = bool3x2(false, false, false, true, true, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_greater_wide_scalar() + { + double3x2 a0 = double3x2(11.156317000815761, -411.02322382993214, 385.88556188432756, -485.10304831206008, -491.18003033622171, 405.17534632476759); + double b0 = (-302.81693877969724); + bool3x2 r0 = bool3x2(true, false, true, false, false, true); + TestUtils.AreEqual(a0 > b0, r0); + + double3x2 a1 = double3x2(173.57509740329124, 501.30683183172107, -367.027771405423, -86.124509613087639, -489.09058998948456, -172.51816066192379); + double b1 = (69.269281181166548); + bool3x2 r1 = bool3x2(true, true, false, false, false, false); + TestUtils.AreEqual(a1 > b1, r1); + + double3x2 a2 = double3x2(-18.149639853346002, -238.8945134798505, -27.239137900638923, 471.77934072528933, 240.16453253485474, -481.47807930478734); + double b2 = (-236.41493498367021); + bool3x2 r2 = bool3x2(true, false, true, true, true, false); + TestUtils.AreEqual(a2 > b2, r2); + + double3x2 a3 = double3x2(185.59438547193747, -510.22814702905163, -183.28619607877278, -386.12766260007754, -13.638212448748845, -7.3478887115362568); + double b3 = (33.294723764664809); + bool3x2 r3 = bool3x2(true, false, false, false, false, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_greater_scalar_wide() + { + double a0 = (453.54610201974685); + double3x2 b0 = double3x2(-226.20441423459187, -423.46500487973213, 409.40550227156166, 453.87706277048073, 87.475727837288673, 113.79560308987072); + bool3x2 r0 = bool3x2(true, true, true, false, true, true); + TestUtils.AreEqual(a0 > b0, r0); + + double a1 = (176.40926154721956); + double3x2 b1 = double3x2(-140.44002944810319, -182.48286804113673, -158.29329188088576, -162.68531830733889, -193.328676075362, 230.18129955519987); + bool3x2 r1 = bool3x2(true, true, true, true, true, false); + TestUtils.AreEqual(a1 > b1, r1); + + double a2 = (-102.58784227379965); + double3x2 b2 = double3x2(392.5205878655056, -177.47865947404813, -10.295010809924008, -24.048938524000789, 172.44867499752377, 374.04800503982608); + bool3x2 r2 = bool3x2(false, true, false, false, false, false); + TestUtils.AreEqual(a2 > b2, r2); + + double a3 = (-368.99763958947619); + double3x2 b3 = double3x2(-210.19528804076617, 149.47022325800276, -281.34327019441093, -100.46916608720511, 304.86444320569956, -361.52483360912879); + bool3x2 r3 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_less_equal_wide_wide() + { + double3x2 a0 = double3x2(240.09053169940159, 462.2131528622532, 293.08251561461134, -427.87067361728782, -405.5227226715175, 204.59190211286386); + double3x2 b0 = double3x2(-81.203838624620744, 493.63743876555816, -411.47211451617636, 99.164449499530974, -295.66769875943089, -480.46254824123463); + bool3x2 r0 = bool3x2(false, true, false, true, true, false); + TestUtils.AreEqual(a0 <= b0, r0); + + double3x2 a1 = double3x2(294.670105832941, -327.56444445604666, -456.12326667091031, 282.3012408140587, 421.8811549720732, -311.71284809322697); + double3x2 b1 = double3x2(74.414040361723892, 260.916124226952, 306.17329730939741, 139.56480438055689, -505.75247955031341, -489.62680958659706); + bool3x2 r1 = bool3x2(false, true, true, false, false, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double3x2 a2 = double3x2(84.5674827492644, 447.24461647832982, -154.49435217422172, -424.36474986763892, 36.684489505684269, 267.07029283562224); + double3x2 b2 = double3x2(-280.03260267899958, 303.15991058161478, 511.19015788994272, -104.65973358259527, 95.1465771641333, -125.6363432992419); + bool3x2 r2 = bool3x2(false, false, true, true, true, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double3x2 a3 = double3x2(307.89391937288167, -351.76015369582927, -157.36036570247279, 152.70902712303632, 372.26716750313858, 202.36828837281485); + double3x2 b3 = double3x2(376.239777024947, -415.7747320680761, -47.481050275024529, 117.72210293529656, 469.37837264937275, -263.04235780567041); + bool3x2 r3 = bool3x2(true, false, true, false, true, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_less_equal_wide_scalar() + { + double3x2 a0 = double3x2(309.1924356469849, 69.673792633076118, -101.72418622939114, -315.97240629604664, -346.01106731314724, 424.15386577330241); + double b0 = (292.92427148154206); + bool3x2 r0 = bool3x2(false, true, true, true, true, false); + TestUtils.AreEqual(a0 <= b0, r0); + + double3x2 a1 = double3x2(-410.87006945669191, 183.82114538169515, 320.44249287268258, -257.87003791419329, -386.801748694294, -182.9388249772316); + double b1 = (-483.90265320423185); + bool3x2 r1 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double3x2 a2 = double3x2(349.25012962392077, 373.56911652794531, 259.15151822713744, 450.13007828692446, -128.5255282523695, -43.874866744445114); + double b2 = (485.31159304329731); + bool3x2 r2 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double3x2 a3 = double3x2(457.38574549992836, 479.45184038553941, -499.51644372358754, -398.13294643821797, 402.48485893871862, 87.9161055497434); + double b3 = (-77.638293064030961); + bool3x2 r3 = bool3x2(false, false, true, true, false, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_less_equal_scalar_wide() + { + double a0 = (-511.15238141974078); + double3x2 b0 = double3x2(51.159012579898786, 340.44369022010062, 312.81429519914752, 354.19252626699983, 136.39671165142056, -94.767871185563422); + bool3x2 r0 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double a1 = (288.544332877055); + double3x2 b1 = double3x2(304.04282369466625, -148.61806089646092, -506.30010127755816, 27.581254256694251, 48.471146844546865, 104.88351326104419); + bool3x2 r1 = bool3x2(true, false, false, false, false, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double a2 = (-488.6858386884843); + double3x2 b2 = double3x2(-480.43516968210935, 421.9366516647566, 239.72105299668431, -101.01844673092404, -283.95147551407638, -55.2435333986038); + bool3x2 r2 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double a3 = (-455.80483147865385); + double3x2 b3 = double3x2(131.10721618081777, -461.69878099006542, -388.48285001725094, -258.93605125087129, -225.2235287284588, -116.01998215355911); + bool3x2 r3 = bool3x2(true, false, true, true, true, true); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_greater_equal_wide_wide() + { + double3x2 a0 = double3x2(-386.59181302906563, -157.12078221008215, 391.01526445477054, -511.88687133783793, -5.4220387960886569, 287.64527501149348); + double3x2 b0 = double3x2(153.44301350109424, 49.892483019219981, 78.025787628267835, 138.81373292711271, -225.51057802211056, -339.35611335344436); + bool3x2 r0 = bool3x2(false, false, true, false, true, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double3x2 a1 = double3x2(-122.53520184500849, 7.4814426933794493, 152.94642765491574, 48.986223482054811, 57.338148859021317, 300.46493138953338); + double3x2 b1 = double3x2(-373.302078182484, 364.9358934671319, -322.71539870030961, 125.47818165900105, -25.776589167200314, 297.51890792395864); + bool3x2 r1 = bool3x2(true, false, true, false, true, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double3x2 a2 = double3x2(349.25705139211243, 85.749700824613569, -230.95330654408468, 418.7112159294594, -131.03991824530061, -126.51221257378916); + double3x2 b2 = double3x2(73.222349439385539, 462.78374288174496, 393.19134515951919, -95.001432224643168, 381.35702556248611, 93.031928344178937); + bool3x2 r2 = bool3x2(true, false, false, true, false, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double3x2 a3 = double3x2(-156.81847841889527, 422.37748761772059, -413.08933348818186, 219.44273553576443, 35.591133372667741, 447.18153521380464); + double3x2 b3 = double3x2(254.25326287665087, 90.672789377473691, 348.93816892660141, 161.33763106229605, 79.435611046587837, 420.24346824187944); + bool3x2 r3 = bool3x2(false, true, false, true, false, true); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_greater_equal_wide_scalar() + { + double3x2 a0 = double3x2(495.457423679278, -14.345115906719627, -463.47478053694346, 217.51749215718246, -246.86571776441565, -377.65869706573835); + double b0 = (189.20512804258851); + bool3x2 r0 = bool3x2(true, false, false, true, false, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double3x2 a1 = double3x2(53.815095211293169, -221.50546441856096, 252.99433410027734, -116.44038277326172, -395.36331028275345, 164.77259667439978); + double b1 = (-123.33294373533357); + bool3x2 r1 = bool3x2(true, false, true, true, false, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double3x2 a2 = double3x2(-287.00733889593153, 184.19556316369938, 273.01225555735277, -418.14240308205706, 249.38409697701411, 396.39213938098032); + double b2 = (355.83704559683667); + bool3x2 r2 = bool3x2(false, false, false, false, false, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double3x2 a3 = double3x2(332.66542044871744, -335.121477998384, -302.08690442800844, 254.44223344253476, 179.00504287472234, 71.176674637560154); + double b3 = (243.76141392614761); + bool3x2 r3 = bool3x2(true, false, false, true, false, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_greater_equal_scalar_wide() + { + double a0 = (215.43534169692327); + double3x2 b0 = double3x2(204.80295310020585, -101.10404853760451, -122.05503827056617, -70.456147941973143, -239.62025677395064, -185.99272426683115); + bool3x2 r0 = bool3x2(true, true, true, true, true, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double a1 = (-455.61258027312); + double3x2 b1 = double3x2(276.66581476697036, 79.39918831707871, 416.42054791768112, 379.27350801009379, -439.51472612820322, 67.141009600433108); + bool3x2 r1 = bool3x2(false, false, false, false, false, false); + TestUtils.AreEqual(a1 >= b1, r1); + + double a2 = (-74.560638224035813); + double3x2 b2 = double3x2(-367.25635474140586, 494.950765601802, -61.235545425319856, -429.17024846988278, -213.82468924942646, -264.31016242891093); + bool3x2 r2 = bool3x2(true, false, false, true, true, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double a3 = (243.11378275748052); + double3x2 b3 = double3x2(-22.383876095704693, 304.86197175870745, -323.68615332417477, 67.938025267765852, 125.30356818312009, -400.47050280145857); + bool3x2 r3 = bool3x2(true, false, true, true, true, true); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_add_wide_wide() + { + double3x2 a0 = double3x2(465.14837644302679, 278.91072548502621, -277.52992237616792, -65.197214395365336, -473.32437561141529, -4.6955420992782138); + double3x2 b0 = double3x2(483.99436186440028, -204.07667193379098, -365.67356007437854, -509.92086076639634, -270.69751108377125, 486.76397846954126); + double3x2 r0 = double3x2(949.14273830742707, 74.834053551235229, -643.20348245054652, -575.11807516176168, -744.02188669518659, 482.06843637026304); + TestUtils.AreEqual(a0 + b0, r0); + + double3x2 a1 = double3x2(-470.53676698661258, -109.95011453980118, -178.70145782209067, -420.03378339299644, 290.71109236903078, -446.5296368294068); + double3x2 b1 = double3x2(267.49177587567442, 251.6425212601398, 244.4951094335388, -78.675763882079991, 352.20551340291536, 82.779185095233515); + double3x2 r1 = double3x2(-203.04499111093816, 141.69240672033862, 65.793651611448126, -498.70954727507643, 642.91660577194614, -363.75045173417328); + TestUtils.AreEqual(a1 + b1, r1); + + double3x2 a2 = double3x2(491.066454400805, -261.11730039358014, -298.40688409395835, 502.42861890347149, 284.59432925125316, 401.12844366632794); + double3x2 b2 = double3x2(462.54732606492348, -405.492017696375, -428.4983238785054, -41.872599859662614, -269.9274958436971, 75.204465662690041); + double3x2 r2 = double3x2(953.6137804657285, -666.6093180899552, -726.90520797246381, 460.55601904380887, 14.666833407556055, 476.332909329018); + TestUtils.AreEqual(a2 + b2, r2); + + double3x2 a3 = double3x2(-36.263498084742366, -102.94915657069026, 503.19817161150195, -384.42911857386542, -45.22821452339565, -198.67394337368847); + double3x2 b3 = double3x2(-141.91339380196922, -222.1867559990784, 41.305726308983594, 148.33947117083676, -177.23311217931712, -176.51887830370987); + double3x2 r3 = double3x2(-178.17689188671159, -325.13591256976866, 544.50389792048554, -236.08964740302866, -222.46132670271277, -375.19282167739834); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_add_wide_scalar() + { + double3x2 a0 = double3x2(459.89829728561369, -447.66336104258119, -94.438627525436971, 126.42986279652916, -36.254356162741033, -349.64130060264904); + double b0 = (500.99725913489112); + double3x2 r0 = double3x2(960.89555642050482, 53.333898092309937, 406.55863160945415, 627.42712193142029, 464.74290297215009, 151.35595853224208); + TestUtils.AreEqual(a0 + b0, r0); + + double3x2 a1 = double3x2(-2.7912590516690443, 443.11525246273504, 268.092225914864, 41.32102133767728, -471.25607584009697, -2.6649749291431704); + double b1 = (-478.41478489265535); + double3x2 r1 = double3x2(-481.20604394432439, -35.299532429920305, -210.32255897779135, -437.09376355497807, -949.67086073275232, -481.07975982179852); + TestUtils.AreEqual(a1 + b1, r1); + + double3x2 a2 = double3x2(78.985822952811532, 311.7254551908585, 10.345855002452595, -151.24445898423181, 355.23276703210206, -197.80076584490052); + double b2 = (202.14799151297098); + double3x2 r2 = double3x2(281.13381446578251, 513.87344670382947, 212.49384651542357, 50.903532528739163, 557.380758545073, 4.34722566807045); + TestUtils.AreEqual(a2 + b2, r2); + + double3x2 a3 = double3x2(255.95526587961024, -181.6265695940827, -2.4549267303454485, 300.90065469448484, -236.49194895312746, -160.5840962680914); + double b3 = (244.14709793969394); + double3x2 r3 = double3x2(500.10236381930417, 62.52052834561124, 241.69217120934849, 545.04775263417878, 7.6551489865664735, 83.563001671602535); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_add_scalar_wide() + { + double a0 = (-325.51276484388518); + double3x2 b0 = double3x2(-264.08813178915909, -106.00925998855814, -355.44729320865463, -447.33029362528134, -158.70021040677102, -199.48369154682553); + double3x2 r0 = double3x2(-589.60089663304427, -431.52202483244332, -680.96005805253981, -772.84305846916652, -484.2129752506562, -524.9964563907107); + TestUtils.AreEqual(a0 + b0, r0); + + double a1 = (180.31809123806568); + double3x2 b1 = double3x2(337.57936898692481, -37.05501486596421, 230.80498014707348, -140.17433339924287, 18.02419591789328, -138.61435825126915); + double3x2 r1 = double3x2(517.89746022499048, 143.26307637210147, 411.12307138513916, 40.143757838822808, 198.34228715595896, 41.703732986796524); + TestUtils.AreEqual(a1 + b1, r1); + + double a2 = (26.904163611542458); + double3x2 b2 = double3x2(-374.53758233345, 154.4676006559597, 268.3838204203098, -190.96302255939833, 188.61725362977813, -504.91612386373623); + double3x2 r2 = double3x2(-347.63341872190756, 181.37176426750216, 295.28798403185226, -164.05885894785587, 215.52141724132059, -478.01196025219377); + TestUtils.AreEqual(a2 + b2, r2); + + double a3 = (20.454013595568995); + double3x2 b3 = double3x2(197.94534525552081, 251.41194474483461, -421.09037538109828, 111.44540052835146, -73.268883024001923, 480.88455770950975); + double3x2 r3 = double3x2(218.3993588510898, 271.86595834040361, -400.63636178552929, 131.89941412392045, -52.814869428432928, 501.33857130507874); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_sub_wide_wide() + { + double3x2 a0 = double3x2(133.37101680290471, -131.8321183341705, -197.29314407952739, -485.286571013409, -337.55033103448818, 471.66710470228782); + double3x2 b0 = double3x2(123.46028739002543, 359.56010048443454, -48.24847819667707, 478.97904680621764, 207.15832886805686, 142.36730462981723); + double3x2 r0 = double3x2(9.9107294128792773, -491.39221881860504, -149.04466588285032, -964.26561781962664, -544.708659902545, 329.29980007247059); + TestUtils.AreEqual(a0 - b0, r0); + + double3x2 a1 = double3x2(146.5066197600712, -130.58504372955537, 110.77707367333448, -235.54160486699158, 78.879356659427, -347.68616811730254); + double3x2 b1 = double3x2(-125.60551005490379, -65.299004823574307, -477.876434787119, 164.50000031501986, 428.00958915614035, 72.6278169493321); + double3x2 r1 = double3x2(272.112129814975, -65.286038905981059, 588.65350846045351, -400.04160518201144, -349.13023249671335, -420.31398506663464); + TestUtils.AreEqual(a1 - b1, r1); + + double3x2 a2 = double3x2(-470.82054565419469, -11.459293609233271, -167.94791730118351, 330.67676917215658, -508.35086822339838, -252.03190457636111); + double3x2 b2 = double3x2(-446.880505531505, 432.09146114443035, -225.55465637219822, -112.45196705332586, -210.61278853687122, -172.92506011432272); + double3x2 r2 = double3x2(-23.940040122689709, -443.55075475366363, 57.606739071014715, 443.12873622548244, -297.73807968652716, -79.1068444620384); + TestUtils.AreEqual(a2 - b2, r2); + + double3x2 a3 = double3x2(-427.93418737311578, 192.6576150360786, 168.42931016182024, 457.3087858899072, 470.05851457550125, -299.71188058504458); + double3x2 b3 = double3x2(-80.60749415336528, 270.04610861001822, -154.25558550388348, 148.47577745675846, 13.661130673094249, 70.671096596248049); + double3x2 r3 = double3x2(-347.3266932197505, -77.388493573939627, 322.68489566570372, 308.83300843314873, 456.397383902407, -370.38297718129263); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_sub_wide_scalar() + { + double3x2 a0 = double3x2(48.936717294592768, 410.45158953706346, -364.44171612544062, 163.98060353285666, -460.06732318367222, 110.91942339340198); + double b0 = (-291.59041442144212); + double3x2 r0 = double3x2(340.52713171603489, 702.04200395850557, -72.8513017039985, 455.57101795429878, -168.4769087622301, 402.5098378148441); + TestUtils.AreEqual(a0 - b0, r0); + + double3x2 a1 = double3x2(204.35834441164434, -377.92569344952972, -470.26204297983185, 400.53491968686455, 461.50756499800252, -246.28726660753006); + double b1 = (180.26971420099483); + double3x2 r1 = double3x2(24.088630210649512, -558.19540765052454, -650.53175718082662, 220.26520548586973, 281.2378507970077, -426.55698080852488); + TestUtils.AreEqual(a1 - b1, r1); + + double3x2 a2 = double3x2(21.605312595891405, -121.42736178330489, -122.71842413894757, -122.93872099879138, 360.15095417581074, 342.87457887403411); + double b2 = (246.35072171238755); + double3x2 r2 = double3x2(-224.74540911649615, -367.77808349569244, -369.06914585133512, -369.28944271117894, 113.80023246342319, 96.523857161646561); + TestUtils.AreEqual(a2 - b2, r2); + + double3x2 a3 = double3x2(18.929827460520869, 97.0436885808798, 485.9149813530571, -205.75765690848124, 253.44322717070725, -121.16305619159857); + double b3 = (164.60235245740148); + double3x2 r3 = double3x2(-145.67252499688061, -67.558663876521678, 321.31262889565562, -370.36000936588272, 88.840874713305766, -285.76540864900005); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_sub_scalar_wide() + { + double a0 = (294.58645905861); + double3x2 b0 = double3x2(452.35251757705237, 256.98980891750648, -275.159888634067, -89.027518075437968, 488.22838829840919, -333.21728030462623); + double3x2 r0 = double3x2(-157.76605851844238, 37.59665014110351, 569.746347692677, 383.61397713404796, -193.6419292397992, 627.80373936323622); + TestUtils.AreEqual(a0 - b0, r0); + + double a1 = (-64.232989102710519); + double3x2 b1 = double3x2(-66.041730196234653, 341.20492831859963, -385.775056303374, 75.394746577085357, 354.94371645289641, 169.13141520746581); + double3x2 r1 = double3x2(1.8087410935241337, -405.43791742131015, 321.5420672006635, -139.62773567979588, -419.17670555560693, -233.36440431017633); + TestUtils.AreEqual(a1 - b1, r1); + + double a2 = (88.216608326982964); + double3x2 b2 = double3x2(1.7350065716240124, 122.53803997977548, -264.94502771317264, -50.837180399725753, -347.65032283759228, 4.0655586738445209); + double3x2 r2 = double3x2(86.481601755358952, -34.321431652792512, 353.1616360401556, 139.05378872670872, 435.86693116457525, 84.151049653138443); + TestUtils.AreEqual(a2 - b2, r2); + + double a3 = (-79.095424450512724); + double3x2 b3 = double3x2(354.35833923628479, -292.4925116470514, -53.208983207684469, -246.34760033634848, 299.20334138497867, 432.18467422583353); + double3x2 r3 = double3x2(-433.45376368679752, 213.39708719653868, -25.886441242828255, 167.25217588583575, -378.29876583549139, -511.28009867634626); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_mul_wide_wide() + { + double3x2 a0 = double3x2(-394.78053898121254, -412.37219519744264, -25.874570143350638, -241.04595886964626, -93.675987525692221, 244.15999257013198); + double3x2 b0 = double3x2(-149.76397831261346, -345.04538671348496, -284.33404721148963, 267.97923648915219, -326.64849558782225, -150.68967754705329); + double3x2 r0 = double3x2(59123.904078224172, 142287.1235617903, 7357.0212487164608, -64595.312016683383, 30599.120397970968, -36792.390550284115); + TestUtils.AreEqual(a0 * b0, r0); + + double3x2 a1 = double3x2(494.68846606402121, 53.537962700025105, -239.49641167349017, 236.67584644848284, -211.85620818466703, -216.65482030466887); + double3x2 b1 = double3x2(207.73243794577775, 366.19289248352538, 358.88076202891807, 214.85359368792433, 253.42280900358355, -307.71382751488773); + double3x2 r1 = double3x2(102762.84107913627, 19605.221418797286, -85950.654724573629, 50850.6561485879, -53689.195383006307, 66667.684005499876); + TestUtils.AreEqual(a1 * b1, r1); + + double3x2 a2 = double3x2(467.95832870339893, -178.02191146557311, -386.3942503344241, -422.43540521265726, 464.58952758488692, -251.3156646468284); + double3x2 b2 = double3x2(184.4711149597872, 426.43644185850235, -144.28142625851621, 459.47961518703016, -358.31334917541284, -201.36521563370025); + double3x2 r2 = double3x2(86324.794650634591, -75915.030498228327, 55749.513536340863, -194100.45742848891, -166468.62962076368, 50606.233003735295); + TestUtils.AreEqual(a2 * b2, r2); + + double3x2 a3 = double3x2(-104.97877912641445, -66.934159071619717, -39.829896707008572, 401.56559080703448, 434.14618250082538, -336.45419589451245); + double3x2 b3 = double3x2(254.90996539541982, 168.52096303204121, 8.7945530455533572, -194.84647974504458, -405.36266178887462, -180.7321890242082); + double3x2 r3 = double3x2(-26760.136954367728, -11279.808946489193, -350.28613938869785, -78243.6417554897, -175986.65214401312, 60808.103330394995); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_mul_wide_scalar() + { + double3x2 a0 = double3x2(328.20302191758674, -290.10672272839895, 236.99572454998065, 120.48136692889102, 357.90315811610924, 134.86723214707672); + double b0 = (192.21119055161773); + double3x2 r0 = double3x2(63084.293585418032, -55761.758562653624, 45553.230371395039, 23157.866976688449, 68792.992123681237, 25922.99125739103); + TestUtils.AreEqual(a0 * b0, r0); + + double3x2 a1 = double3x2(-477.31047104173825, -46.729179165665585, -238.40500103608008, 422.08249374017237, -48.83483722099794, 355.30832998608628); + double b1 = (-438.272912467957); + double3x2 r1 = double3x2(209192.25029491508, 20480.133450173231, 104486.45415100912, -184987.32383324357, 21402.986338745359, -155722.01660712797); + TestUtils.AreEqual(a1 * b1, r1); + + double3x2 a2 = double3x2(119.35660391643489, 98.2360046367329, -325.55215683837991, 53.937323833786536, -87.4509838034636, -130.47412949915702); + double b2 = (-196.995807977857); + double3x2 r2 = double3x2(-23512.750626011144, -19352.081105929705, 64132.410175310673, -10625.426688800102, 17227.4772128218, 25702.856560893983); + TestUtils.AreEqual(a2 * b2, r2); + + double3x2 a3 = double3x2(-222.59457145565869, 293.36108769726059, 174.38195737375963, -327.12007704708731, 56.629123475695565, 257.54154241156834); + double b3 = (126.01503211167415); + double3x2 r3 = double3x2(-28050.262069869175, 36967.906886485951, 21974.747958150911, -41222.047013462026, 7136.1208132457368, 32454.105737083875); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_mul_scalar_wide() + { + double a0 = (-464.534700371574); + double3x2 b0 = double3x2(329.36093846399376, -198.68342671109525, 184.07942518223047, 256.01618754864489, 266.22629297255833, -97.894749448585685); + double3x2 r0 = double3x2(-152999.58486347177, 92295.346096036214, -85511.280621599, -118928.40297318244, -123671.35123704225, 45475.508103049062); + TestUtils.AreEqual(a0 * b0, r0); + + double a1 = (159.74810583877752); + double3x2 b1 = double3x2(-351.82222263506719, 491.80157660497423, 49.902031206480274, 424.46256871915546, 160.11807616060514, -395.99208492599058); + double3x2 r1 = double3x2(-56202.933657940659, 78564.37031116907, 7971.75496274279, 67807.091352347023, 25578.559377205791, -63258.985494075321); + TestUtils.AreEqual(a1 * b1, r1); + + double a2 = (125.20168858636248); + double3x2 b2 = double3x2(-265.01581991138676, 314.65609779705107, -292.71202029507236, -37.729878681586058, 165.3622206027444, 356.51773302467438); + double3x2 r2 = double3x2(-33180.428155004964, 39395.4747681864, -36648.039210468662, -4723.8445210931741, 20703.629247854176, 44636.6221856712); + TestUtils.AreEqual(a2 * b2, r2); + + double a3 = (-188.81332906932261); + double3x2 b3 = double3x2(504.91572475103465, 40.572113771257932, -206.77510581108515, -61.602680473403382, 118.97158938225903, 53.7483275186961); + double3x2 r3 = double3x2(-95334.818889692615, -7660.55586853052, 39041.896096852419, 11631.407179777047, -22463.4218559328, -10148.400650713294); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_div_wide_wide() + { + double3x2 a0 = double3x2(246.26574933075619, -269.85612953354428, -451.61952588130697, -7.38850236283082, -308.20558681534862, -373.394808704683); + double3x2 b0 = double3x2(172.11981423763552, -77.141104972521362, -325.8353723612779, -450.60868117334724, -261.26215398556656, -122.44949847201326); + double3x2 r0 = double3x2(1.4307809383918566, 3.4982144685336105, 1.3860359070548143, 0.016396715535066435, 1.1796794220427942, 3.0493780159501847); + TestUtils.AreEqual(a0 / b0, r0); + + double3x2 a1 = double3x2(360.41863482092447, 25.80972458133931, -274.050461181463, 127.53858977534742, -447.6717600522897, -137.4586017771897); + double3x2 b1 = double3x2(-93.210781379235357, -442.00522705633438, 484.36271380091216, -390.78178686219348, 402.02531714086672, 316.65072193585831); + double3x2 r1 = double3x2(-3.8667054335113131, -0.05839235149599218, -0.56579594872388561, -0.32636779415802974, -1.1135412148569459, -0.43410165287743668); + TestUtils.AreEqual(a1 / b1, r1); + + double3x2 a2 = double3x2(-136.13317424437645, 12.43763423545181, 228.51298319013461, 356.9723681681661, -24.762040865031111, 411.66839356518744); + double3x2 b2 = double3x2(397.15440744774151, -303.26218643005109, -118.59124451437555, -81.650312223308845, -84.346871176896116, -488.41943549011808); + double3x2 r2 = double3x2(-0.3427714050039572, -0.041012809351094658, -1.9268959030313104, -4.37196574572633, 0.29357391115432163, -0.84285833783843456); + TestUtils.AreEqual(a2 / b2, r2); + + double3x2 a3 = double3x2(-204.07890067066944, 11.365393882321882, 82.152295389283609, 37.389483230835481, 394.26582903147948, -429.91279645912016); + double3x2 b3 = double3x2(404.16049999937434, -136.72883731533256, -19.832707652744261, -102.6072290421497, 166.11604960547572, -112.84016590604568); + double3x2 r3 = double3x2(-0.50494519051462317, -0.083123605125890912, -4.1422632162843458, -0.36439423985883462, 2.3734361006528726, 3.8099270149698223); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_div_wide_scalar() + { + double3x2 a0 = double3x2(-244.51745116175965, 69.112274917360537, -333.02311888943575, 257.39682519500923, 403.24561257066466, 154.34436066185322); + double b0 = (-60.024377612408443); + double3x2 r0 = double3x2(4.0736357608014941, -1.1514034408425655, 5.5481311449798705, -4.2882048166676752, -6.7180307170282818, -2.5713612835520117); + TestUtils.AreEqual(a0 / b0, r0); + + double3x2 a1 = double3x2(131.52659160062979, -348.92380516087815, -275.53868187383688, 210.55792174607416, 287.64239968342815, 504.37224626185946); + double b1 = (-261.88639200007844); + double3x2 r1 = double3x2(-0.50222766672271535, 1.332347979198452, 1.0521305813925388, -0.80400482109055549, -1.0983480183397309, -1.9259200236020984); + TestUtils.AreEqual(a1 / b1, r1); + + double3x2 a2 = double3x2(491.78708600056689, -253.23667275776933, 272.89512098622276, 178.09617313095191, -460.87559030059521, -502.64601611655485); + double b2 = (-26.63160015392657); + double3x2 r2 = double3x2(-18.466298801353012, 9.50887934987384, -10.247041837851679, -6.6874003853160646, 17.305591389056794, 18.874044864421883); + TestUtils.AreEqual(a2 / b2, r2); + + double3x2 a3 = double3x2(-84.324793139623864, 83.796309271732525, 197.04206690427009, 317.16826525198678, 403.38711781212464, 81.646461763254592); + double b3 = (-174.69034036187935); + double3x2 r3 = double3x2(0.48271010844069023, -0.47968484747436224, -1.1279505580908942, -1.815602766558, -2.309155257105167, -0.4673782282072384); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_div_scalar_wide() + { + double a0 = (41.737658758525527); + double3x2 b0 = double3x2(-422.676129776368, 248.12963235011773, 449.39137741988122, 245.85813796047967, -326.62061253498337, 163.71510489457989); + double3x2 r0 = double3x2(-0.098746193168297289, 0.1682090863683405, 0.092875967042706856, 0.16976317767945767, -0.12778635871933872, 0.25494079355354177); + TestUtils.AreEqual(a0 / b0, r0); + + double a1 = (333.664472020075); + double3x2 b1 = double3x2(38.291076916405473, -472.97976062864984, 192.23013958345643, -200.29686960964318, -490.18150376257557, -211.10257468517057); + double3x2 r1 = double3x2(8.7138962622678129, -0.70545190258583745, 1.7357552397511267, -1.6658496594098089, -0.68069576158811729, -1.5805798319498852); + TestUtils.AreEqual(a1 / b1, r1); + + double a2 = (-322.85234108700058); + double3x2 b2 = double3x2(-137.98529035317961, 84.32973555677097, 355.06345550858578, 276.42724455354141, -382.9880213136729, -488.647160996053); + double3x2 r2 = double3x2(2.3397591167916914, -3.8284519565421338, -0.909280682306641, -1.1679468918067049, 0.8429828692281206, 0.660706470552089); + TestUtils.AreEqual(a2 / b2, r2); + + double a3 = (344.84603826368505); + double3x2 b3 = double3x2(168.85499938244698, -44.19558837087618, 420.550703959796, -175.6152060849663, -9.2205684227964753, -344.19428865248074); + double3x2 r3 = double3x2(2.0422613456805525, -7.8027253618582941, 0.81998682921394372, -1.9636456657223711, -37.399650699527896, -1.0018935514989395); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_mod_wide_wide() + { + double3x2 a0 = double3x2(-442.30985924336585, 368.50046246522129, -1.0938966279355213, -364.67383473211612, -197.34394487987458, -34.034902350062); + double3x2 b0 = double3x2(-43.245045443645211, -144.19587690392319, -62.640481739603217, -336.82826510855381, -154.6102545981343, -154.02935583611452); + double3x2 r0 = double3x2(-9.8594048069137443, 80.1087086573749, -1.0938966279355213, -27.845569623562312, -42.73369028174028, -34.034902350062); + TestUtils.AreEqual(a0 % b0, r0); + + double3x2 a1 = double3x2(-101.34858350704826, 208.31857142612273, -140.77031404374645, 183.446989383291, -463.36838100076113, 83.839106360375467); + double3x2 b1 = double3x2(487.0462093237071, -469.82909105244516, -145.20377237405802, -203.38401780062543, -22.520082245823062, 224.6900237652892); + double3x2 r1 = double3x2(-101.34858350704826, 208.31857142612273, -140.77031404374645, 183.446989383291, -12.966736084299896, 83.839106360375467); + TestUtils.AreEqual(a1 % b1, r1); + + double3x2 a2 = double3x2(-64.714058190916717, 295.06681050689281, 212.257051805154, 349.62829916068745, 119.87592106679267, -37.805828350505692); + double3x2 b2 = double3x2(-435.62674614210925, 12.095571285158144, 40.378765363422531, 345.78484813579587, -433.47126146474443, -355.64996712079733); + double3x2 r2 = double3x2(-64.714058190916717, 4.773099663097355, 10.363224988041338, 3.8434510248915785, 119.87592106679267, -37.805828350505692); + TestUtils.AreEqual(a2 % b2, r2); + + double3x2 a3 = double3x2(142.41158515886013, 332.24425593588694, -464.19427249589671, -296.14783801517814, 225.17535863871467, -212.06027732233531); + double3x2 b3 = double3x2(4.0154273528677322, 66.659781725453058, -221.85363088448236, -355.05676405274158, 357.93597118832918, 71.375334057666009); + double3x2 r3 = double3x2(1.8716278084895066, 65.605129034074707, -20.487010726932, -296.14783801517814, 225.17535863871467, -69.309609207003291); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_mod_wide_scalar() + { + double3x2 a0 = double3x2(-433.41699548876704, -5.5141427542614565, 393.39439958771425, 299.41153277988155, -120.80601626299602, -502.939041133476); + double b0 = (-90.499235433758827); + double3x2 r0 = double3x2(-71.420053753731736, -5.5141427542614565, 31.39745785267894, 27.913826478605074, -30.306780829237198, -50.442863964681862); + TestUtils.AreEqual(a0 % b0, r0); + + double3x2 a1 = double3x2(-450.80766245853511, -84.473635951277629, -318.78148356023314, 433.45469041981482, -54.6001856581309, -172.33886607565864); + double b1 = (186.09479698263794); + double3x2 r1 = double3x2(-78.618068493259216, -84.473635951277629, -132.6866865775952, 61.265096454538934, -54.6001856581309, -172.33886607565864); + TestUtils.AreEqual(a1 % b1, r1); + + double3x2 a2 = double3x2(-429.71466728193434, 5.796394112425105, 254.51082885196, -433.09369703433185, -203.08261284748215, -75.356399809641971); + double b2 = (222.36186109406958); + double3x2 r2 = double3x2(-207.35280618786476, 5.796394112425105, 32.148967757890432, -210.73183594026227, -203.08261284748215, -75.356399809641971); + TestUtils.AreEqual(a2 % b2, r2); + + double3x2 a3 = double3x2(252.28909385031511, 5.3372299696026175, -279.06042803407666, 483.55059097872606, -331.99334660730949, 335.99997655302286); + double b3 = (-69.403906139267576); + double3x2 r3 = double3x2(44.077375432512383, 5.3372299696026175, -1.44480347700636, 67.1271541431206, -54.377722050239186, 58.384351995952557); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_mod_scalar_wide() + { + double a0 = (-396.4224028049141); + double3x2 b0 = double3x2(-159.14024384279747, 230.17333399046834, 14.779358632294134, -303.15649738123477, 399.63502020371845, 206.69470534412881); + double3x2 r0 = double3x2(-78.141915119319151, -166.24906881444576, -12.159078365266623, -93.265905423679328, -396.4224028049141, -189.72769746078529); + TestUtils.AreEqual(a0 % b0, r0); + + double a1 = (397.04482263934096); + double3x2 b1 = double3x2(-393.89064735634747, -372.06709426085797, 201.01229796233224, -95.5668547598491, -258.95146882671463, 106.98357563232241); + double3x2 r1 = double3x2(3.1541752829934921, 24.977728378482993, 196.03252467700872, 14.777403599944591, 138.09335381262633, 76.094095742373725); + TestUtils.AreEqual(a1 % b1, r1); + + double a2 = (469.3235559264773); + double3x2 b2 = double3x2(-34.808985011097491, 184.83653434777466, 374.79425376224992, -131.87271911086174, -120.09286003936683, 4.506670715523228); + double3x2 r2 = double3x2(16.806750782209917, 99.650487230927979, 94.529302164227374, 73.705398593892085, 109.04497580837682, 0.62980151206159007); + TestUtils.AreEqual(a2 % b2, r2); + + double a3 = (-111.40195732535886); + double3x2 b3 = double3x2(391.54249710195813, -218.66887078931035, 196.37741980160467, -511.03262233689082, 499.95350598727987, -433.52306505363578); + double3x2 r3 = double3x2(-111.40195732535886, -111.40195732535886, -111.40195732535886, -111.40195732535886, -111.40195732535886, -111.40195732535886); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double3x2_operator_plus() + { + double3x2 a0 = double3x2(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045, 315.44952860262686, 319.22218742930431); + double3x2 r0 = double3x2(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045, 315.44952860262686, 319.22218742930431); + TestUtils.AreEqual(+a0, r0); + + double3x2 a1 = double3x2(190.32466015141677, -320.51845875406565, 102.0544069288552, -107.00351267075331, -428.77622075973835, 377.23016208095021); + double3x2 r1 = double3x2(190.32466015141677, -320.51845875406565, 102.0544069288552, -107.00351267075331, -428.77622075973835, 377.23016208095021); + TestUtils.AreEqual(+a1, r1); + + double3x2 a2 = double3x2(234.77393042052813, 258.33039414991174, 465.35593555185756, 309.59316530339106, -316.93713655925222, -230.05266557915724); + double3x2 r2 = double3x2(234.77393042052813, 258.33039414991174, 465.35593555185756, 309.59316530339106, -316.93713655925222, -230.05266557915724); + TestUtils.AreEqual(+a2, r2); + + double3x2 a3 = double3x2(301.78512229667285, 350.24640981771347, 60.819777278611355, -472.44209526127304, -364.80255644619581, 239.15236937215195); + double3x2 r3 = double3x2(301.78512229667285, 350.24640981771347, 60.819777278611355, -472.44209526127304, -364.80255644619581, 239.15236937215195); + TestUtils.AreEqual(+a3, r3); + } + + [TestCompiler] + public static void double3x2_operator_neg() + { + double3x2 a0 = double3x2(420.22718854445372, -196.25749811728366, -335.42683068636188, 509.04366969924592, -33.014395013923945, -498.57532071442125); + double3x2 r0 = double3x2(-420.22718854445372, 196.25749811728366, 335.42683068636188, -509.04366969924592, 33.014395013923945, 498.57532071442125); + TestUtils.AreEqual(-a0, r0); + + double3x2 a1 = double3x2(-495.8379526063045, 19.686896571743773, 268.23670662019254, -180.60051473444349, 223.38126312167446, -410.39206070936848); + double3x2 r1 = double3x2(495.8379526063045, -19.686896571743773, -268.23670662019254, 180.60051473444349, -223.38126312167446, 410.39206070936848); + TestUtils.AreEqual(-a1, r1); + + double3x2 a2 = double3x2(-395.68154186554324, -110.9393032113739, -238.21960913307015, 292.54351224216794, 469.29257867731735, 48.290685914592245); + double3x2 r2 = double3x2(395.68154186554324, 110.9393032113739, 238.21960913307015, -292.54351224216794, -469.29257867731735, -48.290685914592245); + TestUtils.AreEqual(-a2, r2); + + double3x2 a3 = double3x2(88.7237785275671, 55.707977559281517, 464.54141090090457, 499.24280213715645, 175.01502259774838, 196.38759169186824); + double3x2 r3 = double3x2(-88.7237785275671, -55.707977559281517, -464.54141090090457, -499.24280213715645, -175.01502259774838, -196.38759169186824); + TestUtils.AreEqual(-a3, r3); + } + + [TestCompiler] + public static void double3x2_operator_prefix_inc() + { + double3x2 a0 = double3x2(-99.79557113526181, 458.74185082816609, 96.179026886904126, -48.552469514567633, -315.728967098393, -299.23014583216525); + double3x2 r0 = double3x2(-98.79557113526181, 459.74185082816609, 97.179026886904126, -47.552469514567633, -314.728967098393, -298.23014583216525); + TestUtils.AreEqual(++a0, r0); + + double3x2 a1 = double3x2(-323.61485853959567, -76.507656371457358, -305.58477344437722, 64.0964734852763, 148.67930967578627, 363.2849182390072); + double3x2 r1 = double3x2(-322.61485853959567, -75.507656371457358, -304.58477344437722, 65.0964734852763, 149.67930967578627, 364.2849182390072); + TestUtils.AreEqual(++a1, r1); + + double3x2 a2 = double3x2(-115.5592263283018, -179.89464839729231, 339.8765849265626, -38.410431164507941, -153.3736775635619, 261.62557304167444); + double3x2 r2 = double3x2(-114.5592263283018, -178.89464839729231, 340.8765849265626, -37.410431164507941, -152.3736775635619, 262.62557304167444); + TestUtils.AreEqual(++a2, r2); + + double3x2 a3 = double3x2(155.03081877298223, 301.30576791488829, -221.35540328796736, -429.69815011960367, -271.28932893988178, -264.38006246480165); + double3x2 r3 = double3x2(156.03081877298223, 302.30576791488829, -220.35540328796736, -428.69815011960367, -270.28932893988178, -263.38006246480165); + TestUtils.AreEqual(++a3, r3); + } + + [TestCompiler] + public static void double3x2_operator_postfix_inc() + { + double3x2 a0 = double3x2(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888, -31.420532002775246, 455.33662459595905); + double3x2 r0 = double3x2(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888, -31.420532002775246, 455.33662459595905); + TestUtils.AreEqual(a0++, r0); + + double3x2 a1 = double3x2(271.45466840986842, 153.75031645305, -174.17301925186672, -427.40105100506969, 215.11022744658874, 159.86103184514729); + double3x2 r1 = double3x2(271.45466840986842, 153.75031645305, -174.17301925186672, -427.40105100506969, 215.11022744658874, 159.86103184514729); + TestUtils.AreEqual(a1++, r1); + + double3x2 a2 = double3x2(-333.05045262586816, 287.22045649551808, -170.10464366250886, -270.65246380057766, -162.86024792625579, 454.48881003562769); + double3x2 r2 = double3x2(-333.05045262586816, 287.22045649551808, -170.10464366250886, -270.65246380057766, -162.86024792625579, 454.48881003562769); + TestUtils.AreEqual(a2++, r2); + + double3x2 a3 = double3x2(-449.92732045144186, -311.43587103087259, 69.731466087387616, -232.29964433996923, -341.49855271982892, 188.00656685047159); + double3x2 r3 = double3x2(-449.92732045144186, -311.43587103087259, 69.731466087387616, -232.29964433996923, -341.49855271982892, 188.00656685047159); + TestUtils.AreEqual(a3++, r3); + } + + [TestCompiler] + public static void double3x2_operator_prefix_dec() + { + double3x2 a0 = double3x2(-416.20121712992022, -96.637880131899351, -50.145671629414721, -207.31644759295341, 439.47906156977592, -304.40081920493435); + double3x2 r0 = double3x2(-417.20121712992022, -97.637880131899351, -51.145671629414721, -208.31644759295341, 438.47906156977592, -305.40081920493435); + TestUtils.AreEqual(--a0, r0); + + double3x2 a1 = double3x2(337.96895734312432, 171.96452935597142, -227.44280134301761, 298.28480710568135, 326.50782338087811, 400.720900006928); + double3x2 r1 = double3x2(336.96895734312432, 170.96452935597142, -228.44280134301761, 297.28480710568135, 325.50782338087811, 399.720900006928); + TestUtils.AreEqual(--a1, r1); + + double3x2 a2 = double3x2(-478.03137253133178, -24.584499132160317, 112.79684668071422, -341.97629300783217, -503.27416181158003, -79.635249413380052); + double3x2 r2 = double3x2(-479.03137253133178, -25.584499132160317, 111.79684668071422, -342.97629300783217, -504.27416181158003, -80.635249413380052); + TestUtils.AreEqual(--a2, r2); + + double3x2 a3 = double3x2(-131.0041454448384, -15.70865417258284, 188.75845274178243, 307.79193582562357, -406.667706917351, 181.47510703908051); + double3x2 r3 = double3x2(-132.0041454448384, -16.70865417258284, 187.75845274178243, 306.79193582562357, -407.667706917351, 180.47510703908051); + TestUtils.AreEqual(--a3, r3); + } + + [TestCompiler] + public static void double3x2_operator_postfix_dec() + { + double3x2 a0 = double3x2(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555, 409.55752940175944, 47.856652520530247); + double3x2 r0 = double3x2(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555, 409.55752940175944, 47.856652520530247); + TestUtils.AreEqual(a0--, r0); + + double3x2 a1 = double3x2(-281.11170376516492, -182.40572866350681, 450.12809559801974, -129.23265582380475, -332.15495768755443, -261.00890052551819); + double3x2 r1 = double3x2(-281.11170376516492, -182.40572866350681, 450.12809559801974, -129.23265582380475, -332.15495768755443, -261.00890052551819); + TestUtils.AreEqual(a1--, r1); + + double3x2 a2 = double3x2(205.46112570793423, -483.06653784358247, 378.64123433578811, 487.34482287212495, -192.17785772689518, -357.05418960985457); + double3x2 r2 = double3x2(205.46112570793423, -483.06653784358247, 378.64123433578811, 487.34482287212495, -192.17785772689518, -357.05418960985457); + TestUtils.AreEqual(a2--, r2); + + double3x2 a3 = double3x2(-396.30206627226528, 115.86774092347719, -20.823201427619551, 323.40538063803933, 379.15614026559342, 311.29903068733358); + double3x2 r3 = double3x2(-396.30206627226528, 115.86774092347719, -20.823201427619551, 323.40538063803933, 379.15614026559342, 311.29903068733358); + 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/TestDouble3x2.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/TestDouble3x2.gen.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..26df49cc6d06b024f48af93d6736bfec472edfb4 --- /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/TestDouble3x2.gen.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: f95b40a83bedc474aa2badff08c0b04b +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/TestDouble3x3.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/TestDouble3x3.gen.cs new file mode 100644 index 0000000000000000000000000000000000000000..6c21c777b55667a2ad0a0cc1523cd6ce3053b9dd --- /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/TestDouble3x3.gen.cs @@ -0,0 +1,960 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public class TestDouble3x3 + { + [TestCompiler] + public static void double3x3_zero() + { + TestUtils.AreEqual(double3x3.zero.c0.x, 0.0); + TestUtils.AreEqual(double3x3.zero.c0.y, 0.0); + TestUtils.AreEqual(double3x3.zero.c0.z, 0.0); + TestUtils.AreEqual(double3x3.zero.c1.x, 0.0); + TestUtils.AreEqual(double3x3.zero.c1.y, 0.0); + TestUtils.AreEqual(double3x3.zero.c1.z, 0.0); + TestUtils.AreEqual(double3x3.zero.c2.x, 0.0); + TestUtils.AreEqual(double3x3.zero.c2.y, 0.0); + TestUtils.AreEqual(double3x3.zero.c2.z, 0.0); + } + + [TestCompiler] + public static void double3x3_identity() + { + TestUtils.AreEqual(double3x3.identity.c0.x, 1.0); + TestUtils.AreEqual(double3x3.identity.c0.y, 0.0); + TestUtils.AreEqual(double3x3.identity.c0.z, 0.0); + TestUtils.AreEqual(double3x3.identity.c1.x, 0.0); + TestUtils.AreEqual(double3x3.identity.c1.y, 1.0); + TestUtils.AreEqual(double3x3.identity.c1.z, 0.0); + TestUtils.AreEqual(double3x3.identity.c2.x, 0.0); + TestUtils.AreEqual(double3x3.identity.c2.y, 0.0); + TestUtils.AreEqual(double3x3.identity.c2.z, 1.0); + } + + [TestCompiler] + public static void double3x3_operator_equal_wide_wide() + { + double3x3 a0 = double3x3(-135.18925172425304, -49.094127439471947, 169.12980778940482, 240.80529772527757, 314.73919382446411, 442.39301916695808, 177.92444881141398, 335.53340283759564, 168.1544516869609); + double3x3 b0 = double3x3(-220.01464591734793, 66.980020792679852, 499.20158576369363, -371.113114291389, 208.44865212610398, 390.80369133074009, -72.443806920407269, 362.97643273089841, 194.6783255053117); + bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double3x3 a1 = double3x3(350.72955982327903, 367.17843668869625, 46.941470406456574, 188.76415094582558, -97.211392209497944, -293.3210057193977, -234.82292353120766, 417.03371329653714, 26.386443388828297); + double3x3 b1 = double3x3(471.6448635867074, -404.04466719368691, -144.69675476136467, -494.44664334433463, -252.97038209297244, 234.41711746641306, 398.72397465199413, 260.42872083393331, 370.14420502732708); + bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double3x3 a2 = double3x3(269.24572265764959, 29.474191440955792, 479.48521469509467, -237.23094355186026, -221.98371349181224, -506.67253255596034, -22.98943401453522, 487.26083802024868, -419.73195596213077); + double3x3 b2 = double3x3(89.579862397899774, -434.81684347373289, -109.84533815730612, 336.9730161805511, -409.15498156526826, 500.38755273278218, -174.08180888652885, 395.10115379612012, 350.33930723291792); + bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double3x3 a3 = double3x3(337.20329324212082, 245.04388367619549, 390.21586984685428, 84.412977973191573, 434.20789142800868, -68.728424342688356, 485.76997803420295, 413.16974969076443, -418.26928992675118); + double3x3 b3 = double3x3(-243.14458453056614, -416.39737267810727, 151.5764511337394, -18.224320181749931, -431.67792364194895, -468.3309554850361, 429.49572797748056, 477.38919781026857, -433.42541071093893); + bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_equal_wide_scalar() + { + double3x3 a0 = double3x3(65.671194345537174, 404.41550440546848, -269.7301577393572, 83.630607882342588, 152.99450476141385, -155.86829836474186, 314.67125597348024, 386.36515325417986, 290.04894007837811); + double b0 = (-155.8157547245807); + bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double3x3 a1 = double3x3(-132.63519460178691, -69.683271678948415, -191.19075521789063, 186.84520086406042, -232.89569221851218, -319.14406481345372, -49.701092981594172, -300.88189925853248, 333.39685193328046); + double b1 = (-65.667489797653388); + bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double3x3 a2 = double3x3(386.377503336583, -309.11719741910565, 141.54237968360189, -227.32334314441465, 83.872881689981, -410.91687483848858, 110.50128345866744, -390.10359329269437, 36.574313896044259); + double b2 = (-296.70189084517858); + bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double3x3 a3 = double3x3(-427.54144235492754, 175.81170590958175, -193.47994694182648, 291.05195368968509, 423.97165723516218, -429.87391849508225, -275.15694750247383, -56.332365300661138, -95.835959717554942); + double b3 = (-268.17085111707956); + bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_equal_scalar_wide() + { + double a0 = (36.383921878591195); + double3x3 b0 = double3x3(-400.48919958644046, -71.286823544319191, 156.97811491646712, -225.23872791288363, 499.14180993435059, -211.97992358542047, 428.31192394174263, -489.50133322621758, -5.6915457275190988); + bool3x3 r0 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a0 == b0, r0); + + double a1 = (-30.865948453017495); + double3x3 b1 = double3x3(-362.98307221149241, 184.50319322594589, -160.47062142215231, 316.66882315122928, 390.36923879681581, 505.10510301268891, -294.64870967280524, 443.19909283295226, 96.559236333034619); + bool3x3 r1 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 == b1, r1); + + double a2 = (-257.01294601010761); + double3x3 b2 = double3x3(-245.05497538533757, 326.46485176983515, -23.959890138339176, -168.6948808025079, 386.24859279498855, -227.09065185631192, -336.61242524562982, 365.10812752559229, -405.39083952707745); + bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 == b2, r2); + + double a3 = (-473.99549959320365); + double3x3 b3 = double3x3(298.43535174915348, -149.86322386090796, 450.06639191604518, 153.47643358701669, 56.287803437694834, 39.342111844263059, -350.40371744260369, -482.71723221368961, 239.96540772168214); + bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 == b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_not_equal_wide_wide() + { + double3x3 a0 = double3x3(279.99414576217259, -43.342018386042696, -465.72473523846116, 317.46655645848557, 85.714987079480238, 360.89050572034466, 366.08152668833804, 154.5428384070018, 332.426219856565); + double3x3 b0 = double3x3(-460.912120318465, -476.00904844515446, 468.13642070635058, -341.01254312182431, -62.658060341448561, -458.80166718866752, -457.73023316717251, -59.523265627922171, 3.024243117787023); + bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double3x3 a1 = double3x3(397.11323160543725, -431.3749584776233, 489.01079319837072, 398.43358320669904, -489.81794594685454, 171.4049242340983, -67.829682620162941, -192.27871498478515, 227.84082494854965); + double3x3 b1 = double3x3(155.81276352508587, -19.839918384253963, -6.0169332055453992, -406.20792145571107, -102.42070083619126, -40.362921018322425, 452.67542645552919, 93.257571979080126, -258.37806689849964); + bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double3x3 a2 = double3x3(62.138187675801191, 262.18648755838467, -404.05309052209049, 34.449567572423007, -204.79578719138902, -285.41180314003111, -72.206820760018559, 444.74925228801987, 238.81779991780309); + double3x3 b2 = double3x3(-184.04980405794913, -379.23531192319251, -370.68729537105526, -255.94724023339677, 29.055771602809273, 322.40763226263584, 415.07170005099465, -467.72613189542949, -433.78467508488552); + bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double3x3 a3 = double3x3(365.18011563139976, -437.92291351683571, -362.4426316518535, 445.95436665320506, -0.41746735592255391, -506.82837772128562, 245.47704779611763, -173.57105811572217, 390.33854669627669); + double3x3 b3 = double3x3(-212.16593585357344, 474.67491481950265, 452.48318621724991, -92.112742705323171, -385.92209190219739, 420.21507926481547, -239.17604529074208, -99.079094694498508, 4.4760239145141441); + bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_not_equal_wide_scalar() + { + double3x3 a0 = double3x3(-155.44111282911206, -19.426602134214079, 174.63305409934048, 507.9207296352464, 59.177048472304364, 171.15146430356026, -58.923273352404692, -398.17684835855704, 492.20105361016522); + double b0 = (-393.41354173860213); + bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double3x3 a1 = double3x3(-165.24150879925185, -380.24326222960059, 501.8990516615562, -134.34545642433011, 458.40042302496749, 46.771004937016869, 161.45995123752391, 261.51423442620512, -145.61239559278471); + double b1 = (270.34102333259818); + bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double3x3 a2 = double3x3(-0.44992661497087738, 202.22103724359579, 242.66402232025939, 382.67707675633812, -468.96794221781562, -497.45947789468778, -80.932258882062627, -328.58774844211888, -506.49033260088896); + double b2 = (350.46143047439932); + bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double3x3 a3 = double3x3(449.34814640942409, 249.18179690520367, -338.46854058768065, 229.67068420614612, -76.543291365980792, 317.28609314434516, 401.93959612489664, 210.98484502126689, -147.09631616766393); + double b3 = (210.77098784724762); + bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_not_equal_scalar_wide() + { + double a0 = (478.35313938481409); + double3x3 b0 = double3x3(459.55319592894671, 436.45324369727314, -488.71416806090349, 392.76794475725296, -266.73665369056937, 338.55788270503183, -338.10012475498957, -152.3145445102428, -452.82067868338); + bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 != b0, r0); + + double a1 = (209.43931422449612); + double3x3 b1 = double3x3(50.107968592135194, 372.4343656843688, -488.0213141329686, 489.74075697816011, 270.40006149485714, -472.8467831429312, -286.85046090132113, -384.69186681541237, 443.42352959300558); + bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 != b1, r1); + + double a2 = (358.74720900074919); + double3x3 b2 = double3x3(-15.414077527548216, -342.17916194637269, 468.96750400446706, -130.56808501601597, 401.7858013593526, -268.35225761511936, -239.231014124691, 411.38655800902586, 139.76932460617707); + bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 != b2, r2); + + double a3 = (334.52206031164246); + double3x3 b3 = double3x3(-223.62923036498449, -12.488468414400018, 113.46889238872984, -189.65225204716074, -212.84655127900027, 306.1256321902041, -178.33037885386977, 382.14199203166277, -340.86559478420094); + bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a3 != b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_less_wide_wide() + { + double3x3 a0 = double3x3(51.710243010758518, -313.85556450200062, 283.04767359562572, 235.02188621974642, 44.0783565249659, -207.25566659088042, 3.3829410091894943, -144.30134326978651, -69.369597705718888); + double3x3 b0 = double3x3(-261.83523881707117, -19.810742149041403, -149.25882084167506, 205.99822316225539, -306.02438535635565, 102.12168006884008, 231.90633760760829, 179.49885305180158, 473.22488496882136); + bool3x3 r0 = bool3x3(false, true, false, false, false, true, true, true, true); + TestUtils.AreEqual(a0 < b0, r0); + + double3x3 a1 = double3x3(-135.66796762108243, -194.78736576567746, -33.473868147225062, -19.675088653189619, 423.23796697297973, -71.698315415390937, -501.88598870760109, 7.6438391244242894, 302.26289214857991); + double3x3 b1 = double3x3(15.891647107848712, 270.04990614114786, 490.91400240869916, -185.73412164753961, 76.433086669274189, 97.75231246731812, 419.30080600236579, 73.953208242521214, 481.03232382285978); + bool3x3 r1 = bool3x3(true, true, true, false, false, true, true, true, true); + TestUtils.AreEqual(a1 < b1, r1); + + double3x3 a2 = double3x3(-140.55051786291904, -436.586703265359, -351.441728040316, 364.97084896870467, 301.894133946809, 407.55097336673691, 269.10777128353141, 462.98824737173891, 223.8841808884797); + double3x3 b2 = double3x3(7.00747371046225, -7.3240954910051528, -413.07575793428146, -154.1188920261892, 449.20288989003882, 502.01430797111914, -382.31586259525079, 251.53517758638372, 143.17396957388803); + bool3x3 r2 = bool3x3(true, true, false, false, true, true, false, false, false); + TestUtils.AreEqual(a2 < b2, r2); + + double3x3 a3 = double3x3(-287.18923319838439, 283.63862933015389, 511.86434650414822, -60.496787814654795, -234.30346142235373, -316.13839664875456, -417.52215905558421, 441.6434454590285, -191.95062908527939); + double3x3 b3 = double3x3(293.66033686961066, -292.76956691069972, -43.218204756834666, -353.41120044952777, 458.32604405764766, -114.55647259324627, 441.42973276666817, -113.33366709264629, 435.622928583819); + bool3x3 r3 = bool3x3(true, false, false, false, true, true, true, false, true); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_less_wide_scalar() + { + double3x3 a0 = double3x3(-221.86977325280651, -121.54646807608498, -97.52392511140738, 479.88107775146193, 67.118990214131259, 137.32880574899207, 282.96659601990439, 258.27909362422258, -111.41316061439608); + double b0 = (199.06751808853244); + bool3x3 r0 = bool3x3(true, true, true, false, true, true, false, false, true); + TestUtils.AreEqual(a0 < b0, r0); + + double3x3 a1 = double3x3(-288.08113278452356, -361.64292042406413, -68.088202269788951, 12.788020378345664, -66.703050406045747, -78.762971199472872, 25.727694284975428, 101.37087182950734, -330.442660724019); + double b1 = (82.665427008022334); + bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, false, true); + TestUtils.AreEqual(a1 < b1, r1); + + double3x3 a2 = double3x3(-48.920521520506838, -8.15008759878117, 241.27682101040932, -183.43778165776178, 423.02713580756779, -334.62272349680904, -98.315578744893685, 300.41017617863145, 297.92523850962766); + double b2 = (359.60440914686978); + bool3x3 r2 = bool3x3(true, true, true, true, false, true, true, true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double3x3 a3 = double3x3(-492.108162870681, 95.788790032169231, -220.62145791790516, -455.37556740985048, 360.29156344025, -296.37211884948056, 272.4883617239484, 360.20793097103387, 389.7274403002707); + double b3 = (-395.80724806143309); + bool3x3 r3 = bool3x3(true, false, false, true, false, false, false, false, false); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_less_scalar_wide() + { + double a0 = (-250.4849370692321); + double3x3 b0 = double3x3(-377.19654887597846, -505.14754104295167, 375.92672198634909, 110.17393474940855, -118.09757452742082, -40.45089079833167, -299.74430932651478, 31.437125935888389, -458.904539560389); + bool3x3 r0 = bool3x3(false, false, true, true, true, true, false, true, false); + TestUtils.AreEqual(a0 < b0, r0); + + double a1 = (13.684679276163024); + double3x3 b1 = double3x3(-458.50690839183841, 248.27646624682302, 389.23142999654237, 488.74553679337055, -221.63786731550368, -424.26720329013989, 249.05904948388184, -22.136127720650336, -442.24773928255206); + bool3x3 r1 = bool3x3(false, true, true, true, false, false, true, false, false); + TestUtils.AreEqual(a1 < b1, r1); + + double a2 = (-340.85755721705851); + double3x3 b2 = double3x3(-95.1117256130612, 15.409410245441563, 87.292497437117845, 495.06764220402931, 316.01850309782594, -125.56811505442863, 122.16476803746298, 96.75540046429046, -228.90633808304852); + bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 < b2, r2); + + double a3 = (-143.95269662884652); + double3x3 b3 = double3x3(-230.238279688283, -327.61262885090548, 103.39802770661095, 434.488835775521, -157.45019228637693, 190.57215914063727, 108.25831871305513, 132.55076056930739, -431.51522155828553); + bool3x3 r3 = bool3x3(false, false, true, true, false, true, true, true, false); + TestUtils.AreEqual(a3 < b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_greater_wide_wide() + { + double3x3 a0 = double3x3(-229.29066501804192, 505.536608216137, -73.80706862071861, 100.29203777215071, -419.21478124112582, -159.55974753180504, -396.7703608929973, 127.03739482119556, 489.13989733585151); + double3x3 b0 = double3x3(-445.84502407808088, -420.03529210576568, 299.02440108872224, -13.880978829171966, 151.56173593903043, -163.5094302461992, -391.09603733154762, 479.2837710228207, -77.674873149802409); + bool3x3 r0 = bool3x3(true, true, false, true, false, true, false, false, true); + TestUtils.AreEqual(a0 > b0, r0); + + double3x3 a1 = double3x3(51.91890885863404, 155.38475544535777, -135.63165027258526, -425.97813554572787, -228.430505143679, 383.03834909155887, 136.53358298937496, 8.602427725029429, -251.3243674018068); + double3x3 b1 = double3x3(-46.5841996886694, -415.37701888353422, 71.466978344818131, -206.06102643071722, 360.83628218287424, 236.96878658838978, 14.550342328171382, 364.735178402036, -159.0612996365229); + bool3x3 r1 = bool3x3(true, true, false, false, false, true, true, false, false); + TestUtils.AreEqual(a1 > b1, r1); + + double3x3 a2 = double3x3(-345.954920691417, -170.565928777012, -293.25441588706076, 139.1249764613458, 214.3030732675935, 238.76991211565678, 105.53519086983761, -170.92529280992471, 26.98023964230913); + double3x3 b2 = double3x3(226.63117490831348, 182.79602512288659, 341.83937398616195, -79.130463875425278, -247.29681956362765, 164.58913882290437, -352.15977327533056, 9.8226540134394327, 186.72162613026876); + bool3x3 r2 = bool3x3(false, false, false, true, true, true, true, false, false); + TestUtils.AreEqual(a2 > b2, r2); + + double3x3 a3 = double3x3(-188.92831405854241, 201.78662619450438, -506.05715656003781, 15.454906232401186, 115.08067207926911, -496.97184705034448, 339.88814202877143, 372.22833007025918, 313.2386917142378); + double3x3 b3 = double3x3(-325.91364613450764, -77.930370128681147, -379.74604219000139, 251.45575558927646, -144.1835678295156, 337.88991014002352, -249.50553929503332, -225.90130554228148, -249.49127757246202); + bool3x3 r3 = bool3x3(true, true, false, false, true, false, true, true, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_greater_wide_scalar() + { + double3x3 a0 = double3x3(11.156317000815761, -411.02322382993214, 385.88556188432756, -485.10304831206008, -491.18003033622171, 405.17534632476759, 173.57509740329124, 69.269281181166548, 501.30683183172107); + double b0 = (-302.81693877969724); + bool3x3 r0 = bool3x3(true, false, true, false, false, true, true, true, true); + TestUtils.AreEqual(a0 > b0, r0); + + double3x3 a1 = double3x3(-367.027771405423, -489.09058998948456, -172.51816066192379, -18.149639853346002, -236.41493498367021, -238.8945134798505, -27.239137900638923, 471.77934072528933, 240.16453253485474); + double b1 = (-86.124509613087639); + bool3x3 r1 = bool3x3(false, false, false, true, false, false, true, true, true); + TestUtils.AreEqual(a1 > b1, r1); + + double3x3 a2 = double3x3(-481.47807930478734, 33.294723764664809, -510.22814702905163, -183.28619607877278, -386.12766260007754, -13.638212448748845, -7.3478887115362568, -261.86596477304863, 52.24950768996473); + double b2 = (185.59438547193747); + bool3x3 r2 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 > b2, r2); + + double3x3 a3 = double3x3(16.323217637987455, -262.26747978025463, -458.25599000335484, -218.86613069235631, -34.692342535915031, 290.57303752124915, 180.263321722049, -482.86394690110529, 100.70627574841785); + double b3 = (-410.51010985416832); + bool3x3 r3 = bool3x3(true, true, false, true, true, true, true, false, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_greater_scalar_wide() + { + double a0 = (453.54610201974685); + double3x3 b0 = double3x3(-226.20441423459187, -423.46500487973213, 409.40550227156166, 453.87706277048073, 87.475727837288673, 113.79560308987072, 176.40926154721956, -140.44002944810319, -182.48286804113673); + bool3x3 r0 = bool3x3(true, true, true, false, true, true, true, true, true); + TestUtils.AreEqual(a0 > b0, r0); + + double a1 = (-158.29329188088576); + double3x3 b1 = double3x3(-162.68531830733889, -193.328676075362, 230.18129955519987, -102.58784227379965, 392.5205878655056, -177.47865947404813, -10.295010809924008, -24.048938524000789, 172.44867499752377); + bool3x3 r1 = bool3x3(true, true, false, false, false, true, false, false, false); + TestUtils.AreEqual(a1 > b1, r1); + + double a2 = (374.04800503982608); + double3x3 b2 = double3x3(-368.99763958947619, -210.19528804076617, 149.47022325800276, -281.34327019441093, -100.46916608720511, 304.86444320569956, -361.52483360912879, -372.45236056505348, -33.909547583157917); + bool3x3 r2 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a2 > b2, r2); + + double a3 = (-69.595290454847429); + double3x3 b3 = double3x3(-460.43241498453187, -309.34166278938841, 486.13155602204222, 471.92098138850224, 479.36154411703421, -107.00416784500896, 331.63653746789157, -340.84013120310385, -384.21461147079924); + bool3x3 r3 = bool3x3(true, true, false, false, false, true, false, true, true); + TestUtils.AreEqual(a3 > b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_less_equal_wide_wide() + { + double3x3 a0 = double3x3(240.09053169940159, 462.2131528622532, 293.08251561461134, -427.87067361728782, -405.5227226715175, 204.59190211286386, 294.670105832941, -327.56444445604666, -456.12326667091031); + double3x3 b0 = double3x3(-81.203838624620744, 493.63743876555816, -411.47211451617636, 99.164449499530974, -295.66769875943089, -480.46254824123463, 74.414040361723892, 260.916124226952, 306.17329730939741); + bool3x3 r0 = bool3x3(false, true, false, true, true, false, false, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double3x3 a1 = double3x3(282.3012408140587, 421.8811549720732, -311.71284809322697, 84.5674827492644, 447.24461647832982, -154.49435217422172, -424.36474986763892, 36.684489505684269, 267.07029283562224); + double3x3 b1 = double3x3(139.56480438055689, -505.75247955031341, -489.62680958659706, -280.03260267899958, 303.15991058161478, 511.19015788994272, -104.65973358259527, 95.1465771641333, -125.6363432992419); + bool3x3 r1 = bool3x3(false, false, false, false, false, true, true, true, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double3x3 a2 = double3x3(307.89391937288167, -351.76015369582927, -157.36036570247279, 152.70902712303632, 372.26716750313858, 202.36828837281485, -77.043453014010311, 438.18483253856414, 260.28234088620275); + double3x3 b2 = double3x3(376.239777024947, -415.7747320680761, -47.481050275024529, 117.72210293529656, 469.37837264937275, -263.04235780567041, -216.00231109187115, 66.734246046624207, 99.218598173567329); + bool3x3 r2 = bool3x3(true, false, true, false, true, false, false, false, false); + TestUtils.AreEqual(a2 <= b2, r2); + + double3x3 a3 = double3x3(386.03408759927106, -281.49099053139378, -102.9300439837063, -346.71673099450618, -258.34119832624737, -383.30294889179197, -5.1470377469188975, 319.34374752610165, 465.02220485407031); + double3x3 b3 = double3x3(233.843011249715, 439.8399624488502, 61.115118293610976, -219.03058419890266, -404.71288056146022, -202.74836430454087, -312.47647133119244, 310.07189884319519, -320.3630436958573); + bool3x3 r3 = bool3x3(false, true, true, true, false, true, false, false, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_less_equal_wide_scalar() + { + double3x3 a0 = double3x3(309.1924356469849, 69.673792633076118, -101.72418622939114, -315.97240629604664, -346.01106731314724, 424.15386577330241, -410.87006945669191, -483.90265320423185, 183.82114538169515); + double b0 = (292.92427148154206); + bool3x3 r0 = bool3x3(false, true, true, true, true, false, true, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double3x3 a1 = double3x3(320.44249287268258, -386.801748694294, -182.9388249772316, 349.25012962392077, 485.31159304329731, 373.56911652794531, 259.15151822713744, 450.13007828692446, -128.5255282523695); + double b1 = (-257.87003791419329); + bool3x3 r1 = bool3x3(false, true, false, false, false, false, false, false, false); + TestUtils.AreEqual(a1 <= b1, r1); + + double3x3 a2 = double3x3(-43.874866744445114, -77.638293064030961, 479.45184038553941, -499.51644372358754, -398.13294643821797, 402.48485893871862, 87.9161055497434, -502.17362308044619, 125.95081263685177); + double b2 = (457.38574549992836); + bool3x3 r2 = bool3x3(true, true, false, true, true, true, true, true, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double3x3 a3 = double3x3(-54.493607308014134, 97.942930982421558, 228.02151809820043, -213.37865243357544, 42.260789175639275, -24.82758070194518, -451.04158684752957, 429.57755132651778, -308.43429031429548); + double b3 = (250.66739737739204); + bool3x3 r3 = bool3x3(true, true, true, true, true, true, true, false, true); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_less_equal_scalar_wide() + { + double a0 = (-511.15238141974078); + double3x3 b0 = double3x3(51.159012579898786, 340.44369022010062, 312.81429519914752, 354.19252626699983, 136.39671165142056, -94.767871185563422, 288.544332877055, 304.04282369466625, -148.61806089646092); + bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a0 <= b0, r0); + + double a1 = (-506.30010127755816); + double3x3 b1 = double3x3(27.581254256694251, 48.471146844546865, 104.88351326104419, -488.6858386884843, -480.43516968210935, 421.9366516647566, 239.72105299668431, -101.01844673092404, -283.95147551407638); + bool3x3 r1 = bool3x3(true, true, true, true, true, true, true, true, true); + TestUtils.AreEqual(a1 <= b1, r1); + + double a2 = (-55.2435333986038); + double3x3 b2 = double3x3(-455.80483147865385, 131.10721618081777, -461.69878099006542, -388.48285001725094, -258.93605125087129, -225.2235287284588, -116.01998215355911, -442.59525629626364, 297.33334579008317); + bool3x3 r2 = bool3x3(false, true, false, false, false, false, false, false, true); + TestUtils.AreEqual(a2 <= b2, r2); + + double a3 = (36.687250392831515); + double3x3 b3 = double3x3(485.09780930220052, 344.44564859217292, 237.59216724969087, 230.39086471795611, -413.98479266370873, -215.90167794744565, 39.5603883450666, 22.947996388630941, -162.0605676928817); + bool3x3 r3 = bool3x3(true, true, true, true, false, false, true, false, false); + TestUtils.AreEqual(a3 <= b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_greater_equal_wide_wide() + { + double3x3 a0 = double3x3(-386.59181302906563, -157.12078221008215, 391.01526445477054, -511.88687133783793, -5.4220387960886569, 287.64527501149348, -122.53520184500849, 7.4814426933794493, 152.94642765491574); + double3x3 b0 = double3x3(153.44301350109424, 49.892483019219981, 78.025787628267835, 138.81373292711271, -225.51057802211056, -339.35611335344436, -373.302078182484, 364.9358934671319, -322.71539870030961); + bool3x3 r0 = bool3x3(false, false, true, false, true, true, true, false, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double3x3 a1 = double3x3(48.986223482054811, 57.338148859021317, 300.46493138953338, 349.25705139211243, 85.749700824613569, -230.95330654408468, 418.7112159294594, -131.03991824530061, -126.51221257378916); + double3x3 b1 = double3x3(125.47818165900105, -25.776589167200314, 297.51890792395864, 73.222349439385539, 462.78374288174496, 393.19134515951919, -95.001432224643168, 381.35702556248611, 93.031928344178937); + bool3x3 r1 = bool3x3(false, true, true, true, false, false, true, false, false); + TestUtils.AreEqual(a1 >= b1, r1); + + double3x3 a2 = double3x3(-156.81847841889527, 422.37748761772059, -413.08933348818186, 219.44273553576443, 35.591133372667741, 447.18153521380464, -223.49299560463663, 302.12299194099523, 459.85272834256887); + double3x3 b2 = double3x3(254.25326287665087, 90.672789377473691, 348.93816892660141, 161.33763106229605, 79.435611046587837, 420.24346824187944, 453.68485209610537, -154.0116427661905, -97.290078923706915); + bool3x3 r2 = bool3x3(false, true, false, true, false, true, false, true, true); + TestUtils.AreEqual(a2 >= b2, r2); + + double3x3 a3 = double3x3(-347.12802879285442, 364.97808211156075, 212.63543162710755, 504.27608680365427, -142.23296052880255, -132.22179395156996, 303.68380489185631, 265.21013439130513, 9.75437188602723); + double3x3 b3 = double3x3(151.18477613813468, 57.360309865959152, -194.207084984615, -462.67061421958294, 113.38661604439221, -129.35329276386335, 8.1077725925052846, 426.44951434920051, 410.69316477826476); + bool3x3 r3 = bool3x3(false, true, true, true, false, false, true, false, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_greater_equal_wide_scalar() + { + double3x3 a0 = double3x3(495.457423679278, -14.345115906719627, -463.47478053694346, 217.51749215718246, -246.86571776441565, -377.65869706573835, 53.815095211293169, -123.33294373533357, -221.50546441856096); + double b0 = (189.20512804258851); + bool3x3 r0 = bool3x3(true, false, false, true, false, false, false, false, false); + TestUtils.AreEqual(a0 >= b0, r0); + + double3x3 a1 = double3x3(252.99433410027734, -395.36331028275345, 164.77259667439978, -287.00733889593153, 355.83704559683667, 184.19556316369938, 273.01225555735277, -418.14240308205706, 249.38409697701411); + double b1 = (-116.44038277326172); + bool3x3 r1 = bool3x3(true, false, true, false, true, true, true, false, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double3x3 a2 = double3x3(396.39213938098032, 243.76141392614761, -335.121477998384, -302.08690442800844, 254.44223344253476, 179.00504287472234, 71.176674637560154, -331.27167788672807, 307.89058008226129); + double b2 = (332.66542044871744); + bool3x3 r2 = bool3x3(true, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double3x3 a3 = double3x3(-388.57851737950858, -219.89257989632551, -491.68100213058341, 30.997067704329766, 199.23222861030706, -74.50001743924804, -343.38647357718389, 216.0315855555383, -420.40314813163275); + double b3 = (150.60576422075076); + bool3x3 r3 = bool3x3(false, false, false, false, true, false, false, true, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_greater_equal_scalar_wide() + { + double a0 = (215.43534169692327); + double3x3 b0 = double3x3(204.80295310020585, -101.10404853760451, -122.05503827056617, -70.456147941973143, -239.62025677395064, -185.99272426683115, -455.61258027312, 276.66581476697036, 79.39918831707871); + bool3x3 r0 = bool3x3(true, true, true, true, true, true, true, false, true); + TestUtils.AreEqual(a0 >= b0, r0); + + double a1 = (416.42054791768112); + double3x3 b1 = double3x3(379.27350801009379, -439.51472612820322, 67.141009600433108, -74.560638224035813, -367.25635474140586, 494.950765601802, -61.235545425319856, -429.17024846988278, -213.82468924942646); + bool3x3 r1 = bool3x3(true, true, true, true, true, false, true, true, true); + TestUtils.AreEqual(a1 >= b1, r1); + + double a2 = (-264.31016242891093); + double3x3 b2 = double3x3(243.11378275748052, -22.383876095704693, 304.86197175870745, -323.68615332417477, 67.938025267765852, 125.30356818312009, -400.47050280145857, -283.15963162256389, -42.319595595039232); + bool3x3 r2 = bool3x3(false, false, false, true, false, false, true, true, false); + TestUtils.AreEqual(a2 >= b2, r2); + + double a3 = (-429.51037355396448); + double3x3 b3 = double3x3(499.3958854616601, -289.96307887228352, -136.00878554955534, -351.12526123184955, -381.81828921931719, 393.30091089443351, 18.023639925766588, -169.92393048569744, -285.88492669066648); + bool3x3 r3 = bool3x3(false, false, false, false, false, false, false, false, false); + TestUtils.AreEqual(a3 >= b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_add_wide_wide() + { + double3x3 a0 = double3x3(465.14837644302679, 278.91072548502621, -277.52992237616792, -65.197214395365336, -473.32437561141529, -4.6955420992782138, -470.53676698661258, -109.95011453980118, -178.70145782209067); + double3x3 b0 = double3x3(483.99436186440028, -204.07667193379098, -365.67356007437854, -509.92086076639634, -270.69751108377125, 486.76397846954126, 267.49177587567442, 251.6425212601398, 244.4951094335388); + double3x3 r0 = double3x3(949.14273830742707, 74.834053551235229, -643.20348245054652, -575.11807516176168, -744.02188669518659, 482.06843637026304, -203.04499111093816, 141.69240672033862, 65.793651611448126); + TestUtils.AreEqual(a0 + b0, r0); + + double3x3 a1 = double3x3(-420.03378339299644, 290.71109236903078, -446.5296368294068, 491.066454400805, -261.11730039358014, -298.40688409395835, 502.42861890347149, 284.59432925125316, 401.12844366632794); + double3x3 b1 = double3x3(-78.675763882079991, 352.20551340291536, 82.779185095233515, 462.54732606492348, -405.492017696375, -428.4983238785054, -41.872599859662614, -269.9274958436971, 75.204465662690041); + double3x3 r1 = double3x3(-498.70954727507643, 642.91660577194614, -363.75045173417328, 953.6137804657285, -666.6093180899552, -726.90520797246381, 460.55601904380887, 14.666833407556055, 476.332909329018); + TestUtils.AreEqual(a1 + b1, r1); + + double3x3 a2 = double3x3(-36.263498084742366, -102.94915657069026, 503.19817161150195, -384.42911857386542, -45.22821452339565, -198.67394337368847, -62.8800013358146, -79.55225447544467, 413.0982751385767); + double3x3 b2 = double3x3(-141.91339380196922, -222.1867559990784, 41.305726308983594, 148.33947117083676, -177.23311217931712, -176.51887830370987, 492.69246768052335, 439.04383942067807, -511.74275922763292); + double3x3 r2 = double3x3(-178.17689188671159, -325.13591256976866, 544.50389792048554, -236.08964740302866, -222.46132670271277, -375.19282167739834, 429.81246634470875, 359.4915849452334, -98.64448408905622); + TestUtils.AreEqual(a2 + b2, r2); + + double3x3 a3 = double3x3(-100.87757997441923, 418.523998693807, -183.143126334596, 407.44374031920165, 300.48602332756207, -261.12612998724273, -309.8303507817119, 378.36333220934648, -224.09398065511789); + double3x3 b3 = double3x3(-399.05713695988857, -315.8684596102072, -228.0772484410914, -171.70519669899028, 467.17394826709005, -474.8229422396156, 311.39072885708447, 326.84541979750873, 475.21193597987849); + double3x3 r3 = double3x3(-499.9347169343078, 102.65553908359982, -411.22037477568739, 235.73854362021137, 767.65997159465212, -735.94907222685833, 1.5603780753725687, 705.20875200685521, 251.1179553247606); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_add_wide_scalar() + { + double3x3 a0 = double3x3(459.89829728561369, -447.66336104258119, -94.438627525436971, 126.42986279652916, -36.254356162741033, -349.64130060264904, -2.7912590516690443, -478.41478489265535, 443.11525246273504); + double b0 = (500.99725913489112); + double3x3 r0 = double3x3(960.89555642050482, 53.333898092309937, 406.55863160945415, 627.42712193142029, 464.74290297215009, 151.35595853224208, 498.20600008322208, 22.582474242235776, 944.11251159762617); + TestUtils.AreEqual(a0 + b0, r0); + + double3x3 a1 = double3x3(268.092225914864, -471.25607584009697, -2.6649749291431704, 78.985822952811532, 202.14799151297098, 311.7254551908585, 10.345855002452595, -151.24445898423181, 355.23276703210206); + double b1 = (41.32102133767728); + double3x3 r1 = double3x3(309.41324725254128, -429.93505450241969, 38.65604640853411, 120.30684429048881, 243.46901285064826, 353.04647652853578, 51.666876340129875, -109.92343764655453, 396.55378836977934); + TestUtils.AreEqual(a1 + b1, r1); + + double3x3 a2 = double3x3(-197.80076584490052, 244.14709793969394, -181.6265695940827, -2.4549267303454485, 300.90065469448484, -236.49194895312746, -160.5840962680914, -172.54221566605486, -242.9410861669765); + double b2 = (255.95526587961024); + double3x3 r2 = double3x3(58.154500034709713, 500.10236381930417, 74.328696285527542, 253.50033914926479, 556.85592057409508, 19.463316926482776, 95.371169611518837, 83.41305021355538, 13.014179712633734); + TestUtils.AreEqual(a2 + b2, r2); + + double3x3 a3 = double3x3(466.34409902353957, 264.294014815378, 372.86684029775995, -198.83777699192882, -381.930974899759, 402.16034693371523, -117.02482729639149, 497.37375592504338, 485.90928124166521); + double b3 = (237.98745810146795); + double3x3 r3 = double3x3(704.33155712500752, 502.28147291684593, 610.8542983992279, 39.149681109539131, -143.94351679829106, 640.14780503518318, 120.96263080507646, 735.36121402651133, 723.89673934313316); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_add_scalar_wide() + { + double a0 = (-325.51276484388518); + double3x3 b0 = double3x3(-264.08813178915909, -106.00925998855814, -355.44729320865463, -447.33029362528134, -158.70021040677102, -199.48369154682553, 180.31809123806568, 337.57936898692481, -37.05501486596421); + double3x3 r0 = double3x3(-589.60089663304427, -431.52202483244332, -680.96005805253981, -772.84305846916652, -484.2129752506562, -524.9964563907107, -145.1946736058195, 12.066604143039626, -362.56777970984939); + TestUtils.AreEqual(a0 + b0, r0); + + double a1 = (230.80498014707348); + double3x3 b1 = double3x3(-140.17433339924287, 18.02419591789328, -138.61435825126915, 26.904163611542458, -374.53758233345, 154.4676006559597, 268.3838204203098, -190.96302255939833, 188.61725362977813); + double3x3 r1 = double3x3(90.63064674783061, 248.82917606496676, 92.190621895804327, 257.70914375861594, -143.73260218637654, 385.27258080303318, 499.18880056738328, 39.841957587675154, 419.42223377685161); + TestUtils.AreEqual(a1 + b1, r1); + + double a2 = (-504.91612386373623); + double3x3 b2 = double3x3(20.454013595568995, 197.94534525552081, 251.41194474483461, -421.09037538109828, 111.44540052835146, -73.268883024001923, 480.88455770950975, 438.05301233662897, 66.844289095534123); + double3x3 r2 = double3x3(-484.46211026816724, -306.97077860821543, -253.50417911890162, -926.00649924483446, -393.47072333538478, -578.18500688773815, -24.031566154226482, -66.863111527107264, -438.07183476820211); + TestUtils.AreEqual(a2 + b2, r2); + + double a3 = (-270.79599941465818); + double3x3 b3 = double3x3(-44.02192189359198, 197.69471916821544, 19.113929995854392, 349.23776857426287, 366.23449271090067, -413.48026890935387, -260.720191361718, 77.542334831106587, 183.95489009840173); + double3x3 r3 = double3x3(-314.81792130825016, -73.101280246442741, -251.68206941880379, 78.441769159604689, 95.438493296242484, -684.27626832401211, -531.51619077637611, -193.2536645835516, -86.84110931625645); + TestUtils.AreEqual(a3 + b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_sub_wide_wide() + { + double3x3 a0 = double3x3(133.37101680290471, -131.8321183341705, -197.29314407952739, -485.286571013409, -337.55033103448818, 471.66710470228782, 146.5066197600712, -130.58504372955537, 110.77707367333448); + double3x3 b0 = double3x3(123.46028739002543, 359.56010048443454, -48.24847819667707, 478.97904680621764, 207.15832886805686, 142.36730462981723, -125.60551005490379, -65.299004823574307, -477.876434787119); + double3x3 r0 = double3x3(9.9107294128792773, -491.39221881860504, -149.04466588285032, -964.26561781962664, -544.708659902545, 329.29980007247059, 272.112129814975, -65.286038905981059, 588.65350846045351); + TestUtils.AreEqual(a0 - b0, r0); + + double3x3 a1 = double3x3(-235.54160486699158, 78.879356659427, -347.68616811730254, -470.82054565419469, -11.459293609233271, -167.94791730118351, 330.67676917215658, -508.35086822339838, -252.03190457636111); + double3x3 b1 = double3x3(164.50000031501986, 428.00958915614035, 72.6278169493321, -446.880505531505, 432.09146114443035, -225.55465637219822, -112.45196705332586, -210.61278853687122, -172.92506011432272); + double3x3 r1 = double3x3(-400.04160518201144, -349.13023249671335, -420.31398506663464, -23.940040122689709, -443.55075475366363, 57.606739071014715, 443.12873622548244, -297.73807968652716, -79.1068444620384); + TestUtils.AreEqual(a1 - b1, r1); + + double3x3 a2 = double3x3(-427.93418737311578, 192.6576150360786, 168.42931016182024, 457.3087858899072, 470.05851457550125, -299.71188058504458, -308.93956937870922, 454.53341052240387, 26.106923830745245); + double3x3 b2 = double3x3(-80.60749415336528, 270.04610861001822, -154.25558550388348, 148.47577745675846, 13.661130673094249, 70.671096596248049, -221.32544551665217, -9.2588145775994235, 288.1738385111903); + double3x3 r2 = double3x3(-347.3266932197505, -77.388493573939627, 322.68489566570372, 308.83300843314873, 456.397383902407, -370.38297718129263, -87.614123862057056, 463.79222510000329, -262.06691468044505); + TestUtils.AreEqual(a2 - b2, r2); + + double3x3 a3 = double3x3(-482.71181105203544, -40.853544492671972, 318.38064613862923, 475.21081541255614, 134.9269641074012, 388.48155969590016, 138.71817285321572, -385.57360547854267, -149.36481745045859); + double3x3 b3 = double3x3(217.36142764676424, 307.54006471649745, -262.41263854802241, -405.3780321578393, 400.00432533771004, 72.119071755613732, -154.88059170305758, -469.65998361523265, -320.61543217330029); + double3x3 r3 = double3x3(-700.07323869879974, -348.39360920916943, 580.79328468665165, 880.5888475703955, -265.07736123030884, 316.36248794028643, 293.5987645562733, 84.086378136689973, 171.2506147228417); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_sub_wide_scalar() + { + double3x3 a0 = double3x3(48.936717294592768, 410.45158953706346, -364.44171612544062, 163.98060353285666, -460.06732318367222, 110.91942339340198, 204.35834441164434, 180.26971420099483, -377.92569344952972); + double b0 = (-291.59041442144212); + double3x3 r0 = double3x3(340.52713171603489, 702.04200395850557, -72.8513017039985, 455.57101795429878, -168.4769087622301, 402.5098378148441, 495.94875883308646, 471.86012862243695, -86.3352790280876); + TestUtils.AreEqual(a0 - b0, r0); + + double3x3 a1 = double3x3(-470.26204297983185, 461.50756499800252, -246.28726660753006, 21.605312595891405, 246.35072171238755, -121.42736178330489, -122.71842413894757, -122.93872099879138, 360.15095417581074); + double b1 = (400.53491968686455); + double3x3 r1 = double3x3(-870.79696266669634, 60.972645311137967, -646.82218629439467, -378.92960709097315, -154.184197974477, -521.9622814701695, -523.25334382581218, -523.47364068565594, -40.383965511053816); + TestUtils.AreEqual(a1 - b1, r1); + + double3x3 a2 = double3x3(342.87457887403411, 164.60235245740148, 97.0436885808798, 485.9149813530571, -205.75765690848124, 253.44322717070725, -121.16305619159857, 187.99838813953022, -450.820273370864); + double b2 = (18.929827460520869); + double3x3 r2 = double3x3(323.94475141351325, 145.67252499688061, 78.113861120358933, 466.98515389253623, -224.68748436900211, 234.51339971018638, -140.09288365211944, 169.06856067900935, -469.75010083138488); + TestUtils.AreEqual(a2 - b2, r2); + + double3x3 a3 = double3x3(-248.07337128746946, 441.55261942444031, 449.91060969322484, 354.88602678612153, 98.821485803845121, -189.19323381650878, 269.07481659067548, -59.118566302172155, 363.45839207407948); + double b3 = (-26.996065390760123); + double3x3 r3 = double3x3(-221.07730589670933, 468.54868481520043, 476.90667508398496, 381.88209217688166, 125.81755119460524, -162.19716842574866, 296.0708819814356, -32.122500911412033, 390.45445746483961); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_sub_scalar_wide() + { + double a0 = (294.58645905861); + double3x3 b0 = double3x3(452.35251757705237, 256.98980891750648, -275.159888634067, -89.027518075437968, 488.22838829840919, -333.21728030462623, -64.232989102710519, -66.041730196234653, 341.20492831859963); + double3x3 r0 = double3x3(-157.76605851844238, 37.59665014110351, 569.746347692677, 383.61397713404796, -193.6419292397992, 627.80373936323622, 358.81944816132051, 360.62818925484464, -46.618469259989638); + TestUtils.AreEqual(a0 - b0, r0); + + double a1 = (-385.775056303374); + double3x3 b1 = double3x3(75.394746577085357, 354.94371645289641, 169.13141520746581, 88.216608326982964, 1.7350065716240124, 122.53803997977548, -264.94502771317264, -50.837180399725753, -347.65032283759228); + double3x3 r1 = double3x3(-461.16980288045937, -740.71877275627048, -554.90647151083976, -473.991664630357, -387.510062874998, -508.31309628314949, -120.83002859020138, -334.93787590364826, -38.124733465781731); + TestUtils.AreEqual(a1 - b1, r1); + + double a2 = (4.0655586738445209); + double3x3 b2 = double3x3(-79.095424450512724, 354.35833923628479, -292.4925116470514, -53.208983207684469, -246.34760033634848, 299.20334138497867, 432.18467422583353, -163.88000090600923, 176.74255546216978); + double3x3 r2 = double3x3(83.160983124357244, -350.29278056244027, 296.55807032089592, 57.27454188152899, 250.413159010193, -295.13778271113415, -428.119115551989, 167.94555957985375, -172.67699678832525); + TestUtils.AreEqual(a2 - b2, r2); + + double a3 = (-104.9858415615679); + double3x3 b3 = double3x3(-445.7976302792307, -28.873155368898608, -169.58822901993443, -270.35924614144454, 68.0476272423042, -65.531290323255234, 440.38039776328037, 427.36063142649857, -81.472953595906915); + double3x3 r3 = double3x3(340.81178871766281, -76.112686192669287, 64.602387458366536, 165.37340457987665, -173.0334688038721, -39.454551238312661, -545.36623932484827, -532.34647298806647, -23.51288796566098); + TestUtils.AreEqual(a3 - b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_mul_wide_wide() + { + double3x3 a0 = double3x3(-394.78053898121254, -412.37219519744264, -25.874570143350638, -241.04595886964626, -93.675987525692221, 244.15999257013198, 494.68846606402121, 53.537962700025105, -239.49641167349017); + double3x3 b0 = double3x3(-149.76397831261346, -345.04538671348496, -284.33404721148963, 267.97923648915219, -326.64849558782225, -150.68967754705329, 207.73243794577775, 366.19289248352538, 358.88076202891807); + double3x3 r0 = double3x3(59123.904078224172, 142287.1235617903, 7357.0212487164608, -64595.312016683383, 30599.120397970968, -36792.390550284115, 102762.84107913627, 19605.221418797286, -85950.654724573629); + TestUtils.AreEqual(a0 * b0, r0); + + double3x3 a1 = double3x3(236.67584644848284, -211.85620818466703, -216.65482030466887, 467.95832870339893, -178.02191146557311, -386.3942503344241, -422.43540521265726, 464.58952758488692, -251.3156646468284); + double3x3 b1 = double3x3(214.85359368792433, 253.42280900358355, -307.71382751488773, 184.4711149597872, 426.43644185850235, -144.28142625851621, 459.47961518703016, -358.31334917541284, -201.36521563370025); + double3x3 r1 = double3x3(50850.6561485879, -53689.195383006307, 66667.684005499876, 86324.794650634591, -75915.030498228327, 55749.513536340863, -194100.45742848891, -166468.62962076368, 50606.233003735295); + TestUtils.AreEqual(a1 * b1, r1); + + double3x3 a2 = double3x3(-104.97877912641445, -66.934159071619717, -39.829896707008572, 401.56559080703448, 434.14618250082538, -336.45419589451245, -83.11415318544681, 329.96027842627848, -316.97214594342381); + double3x3 b2 = double3x3(254.90996539541982, 168.52096303204121, 8.7945530455533572, -194.84647974504458, -405.36266178887462, -180.7321890242082, -189.74690946831691, -35.518455760329232, 120.31664210200154); + double3x3 r2 = double3x3(-26760.136954367728, -11279.808946489193, -350.28613938869785, -78243.6417554897, -175986.65214401312, 60808.103330394995, 15770.6537000148, -11719.679551949688, -38137.024239778322); + TestUtils.AreEqual(a2 * b2, r2); + + double3x3 a3 = double3x3(474.9379296130212, -445.10915800794453, -301.00371541688389, 405.68786425408337, 142.37348682357629, -416.21309037516505, -103.27920513194016, -52.951897407393858, -40.828328390060165); + double3x3 b3 = double3x3(-136.2033479847961, 407.34163231744503, 301.65431489686216, -155.4824007281486, -461.39456126717596, 296.68037738310193, 341.001815239434, -257.09682166627459, 17.593622931089953); + double3x3 r3 = double3x3(-64688.136098260919, -181311.49098239967, -90799.069555490176, -63077.323080500144, -65690.352489042038, -123482.25672429107, -35218.396426477462, 13613.764524639606, -718.31821460143351); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_mul_wide_scalar() + { + double3x3 a0 = double3x3(328.20302191758674, -290.10672272839895, 236.99572454998065, 120.48136692889102, 357.90315811610924, 134.86723214707672, -477.31047104173825, -438.272912467957, -46.729179165665585); + double b0 = (192.21119055161773); + double3x3 r0 = double3x3(63084.293585418032, -55761.758562653624, 45553.230371395039, 23157.866976688449, 68792.992123681237, 25922.99125739103, -91744.41390168597, -84240.958291990959, -8981.8711609324328); + TestUtils.AreEqual(a0 * b0, r0); + + double3x3 a1 = double3x3(-238.40500103608008, -48.83483722099794, 355.30832998608628, 119.35660391643489, -196.995807977857, 98.2360046367329, -325.55215683837991, 53.937323833786536, -87.4509838034636); + double b1 = (422.08249374017237); + double3x3 r1 = double3x3(-100626.57735743705, -20612.3298756342, 149969.42596718337, 50378.333025406864, -83148.481887654023, 41463.697812143357, -137409.86620083509, 22766.000149435855, -36911.529323797338); + TestUtils.AreEqual(a1 * b1, r1); + + double3x3 a2 = double3x3(-130.47412949915702, 126.01503211167415, 293.36108769726059, 174.38195737375963, -327.12007704708731, 56.629123475695565, 257.54154241156834, -475.60871551726422, -452.69189450363251); + double b2 = (-222.59457145565869); + double3x3 r2 = double3x3(29042.832941914974, -28050.262069869175, -65300.585597737627, -38816.477071210968, 72815.15336483845, -12605.335471982036, -57327.349265132405, 105867.91821114172, 100766.75825848634); + TestUtils.AreEqual(a2 * b2, r2); + + double3x3 a3 = double3x3(-49.220605157884108, 431.58568330834885, 180.35518583113105, -40.92345454214302, 279.54350842141707, 120.01444226131514, -59.508660105759589, 319.48987236595246, -403.52316040709763); + double b3 = (141.60094959177115); + double3x3 r3 = double3x3(-6969.6844298380192, 61112.942586675614, 25538.465577488507, -5794.8000237431324, 39583.626244687934, 16994.158988929015, -8426.4827799095074, 45240.069311972635, -57139.26269591762); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_mul_scalar_wide() + { + double a0 = (-464.534700371574); + double3x3 b0 = double3x3(329.36093846399376, -198.68342671109525, 184.07942518223047, 256.01618754864489, 266.22629297255833, -97.894749448585685, 159.74810583877752, -351.82222263506719, 491.80157660497423); + double3x3 r0 = double3x3(-152999.58486347177, 92295.346096036214, -85511.280621599, -118928.40297318244, -123671.35123704225, 45475.508103049062, -74208.538480743009, 163433.63077584215, -228458.89803045939); + TestUtils.AreEqual(a0 * b0, r0); + + double a1 = (49.902031206480274); + double3x3 b1 = double3x3(424.46256871915546, 160.11807616060514, -395.99208492599058, 125.20168858636248, -265.01581991138676, 314.65609779705107, -292.71202029507236, -37.729878681586058, 165.3622206027444); + double3x3 r1 = double3x3(21181.544350206073, 7990.2172332881028, -19760.809379495968, 6247.8185709406853, -13224.827715428979, 15701.978411577751, -14606.924371276589, -1882.7975833852222, 8251.910692891026); + TestUtils.AreEqual(a1 * b1, r1); + + double a2 = (356.51773302467438); + double3x3 b2 = double3x3(-188.81332906932261, 504.91572475103465, 40.572113771257932, -206.77510581108515, -61.602680473403382, 118.97158938225903, 53.7483275186961, -198.66941771221786, 96.23611287783649); + double3x3 r2 = double3x3(-67315.300044636751, 180011.40955674934, 14464.67802574805, -73718.991969705254, -21962.447990621149, 42415.481340905411, 19162.231880833257, -70829.170424092008, 34309.880798312937); + TestUtils.AreEqual(a2 * b2, r2); + + double a3 = (-20.241880664714529); + double3x3 b3 = double3x3(-31.123976006696012, 38.890465516080326, -13.133307701504464, 507.87128209875493, 95.017933651347562, 340.74862186086762, 438.98690172610191, -227.16596637813655, 452.57297894571582); + double3x3 r3 = double3x3(630.00780813897893, -787.21616197169351, 265.84284722682963, -10280.269885278565, -1923.3416739783402, -6897.3929403736183, -8885.920478112519, 4598.2663825107929, -9160.92823189354); + TestUtils.AreEqual(a3 * b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_div_wide_wide() + { + double3x3 a0 = double3x3(246.26574933075619, -269.85612953354428, -451.61952588130697, -7.38850236283082, -308.20558681534862, -373.394808704683, 360.41863482092447, 25.80972458133931, -274.050461181463); + double3x3 b0 = double3x3(172.11981423763552, -77.141104972521362, -325.8353723612779, -450.60868117334724, -261.26215398556656, -122.44949847201326, -93.210781379235357, -442.00522705633438, 484.36271380091216); + double3x3 r0 = double3x3(1.4307809383918566, 3.4982144685336105, 1.3860359070548143, 0.016396715535066435, 1.1796794220427942, 3.0493780159501847, -3.8667054335113131, -0.05839235149599218, -0.56579594872388561); + TestUtils.AreEqual(a0 / b0, r0); + + double3x3 a1 = double3x3(127.53858977534742, -447.6717600522897, -137.4586017771897, -136.13317424437645, 12.43763423545181, 228.51298319013461, 356.9723681681661, -24.762040865031111, 411.66839356518744); + double3x3 b1 = double3x3(-390.78178686219348, 402.02531714086672, 316.65072193585831, 397.15440744774151, -303.26218643005109, -118.59124451437555, -81.650312223308845, -84.346871176896116, -488.41943549011808); + double3x3 r1 = double3x3(-0.32636779415802974, -1.1135412148569459, -0.43410165287743668, -0.3427714050039572, -0.041012809351094658, -1.9268959030313104, -4.37196574572633, 0.29357391115432163, -0.84285833783843456); + TestUtils.AreEqual(a1 / b1, r1); + + double3x3 a2 = double3x3(-204.07890067066944, 11.365393882321882, 82.152295389283609, 37.389483230835481, 394.26582903147948, -429.91279645912016, 315.37384071730719, -122.66599255551864, 447.52615067340719); + double3x3 b2 = double3x3(404.16049999937434, -136.72883731533256, -19.832707652744261, -102.6072290421497, 166.11604960547572, -112.84016590604568, -218.2096851888158, 458.51754042995981, 119.5872405132219); + double3x3 r2 = double3x3(-0.50494519051462317, -0.083123605125890912, -4.1422632162843458, -0.36439423985883462, 2.3734361006528726, 3.8099270149698223, -1.4452788401413792, -0.26752737188743669, 3.7422566885296384); + TestUtils.AreEqual(a2 / b2, r2); + + double3x3 a3 = double3x3(-210.48151574399395, -202.42158398517483, -453.00793072814491, 173.7269934032704, -167.1216643634819, -106.2345221537326, 414.31254239301779, 7.1208250555772565, 274.07367361433512); + double3x3 b3 = double3x3(356.24043218988948, -74.506851469402591, -336.77393332904853, -216.12631593277973, 322.385657699027, 220.25550351862591, -67.234494002179474, 2.229160071457386, -166.21096118083733); + double3x3 r3 = double3x3(-0.59084117557941718, 2.7168183864044027, 1.3451395309907455, -0.80382156450260089, -0.51839050643966134, -0.48232403030396409, -6.1622021336189041, 3.1943982609206638, -1.6489506568471335); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_div_wide_scalar() + { + double3x3 a0 = double3x3(-244.51745116175965, 69.112274917360537, -333.02311888943575, 257.39682519500923, 403.24561257066466, 154.34436066185322, 131.52659160062979, -261.88639200007844, -348.92380516087815); + double b0 = (-60.024377612408443); + double3x3 r0 = double3x3(4.0736357608014941, -1.1514034408425655, 5.5481311449798705, -4.2882048166676752, -6.7180307170282818, -2.5713612835520117, -2.1912195816494422, 4.3630005410658415, 5.8130349541308268); + TestUtils.AreEqual(a0 / b0, r0); + + double3x3 a1 = double3x3(-275.53868187383688, 287.64239968342815, 504.37224626185946, 491.78708600056689, -26.63160015392657, -253.23667275776933, 272.89512098622276, 178.09617313095191, -460.87559030059521); + double b1 = (210.55792174607416); + double3x3 r1 = double3x3(-1.308612279171939, 1.3660963087882074, 2.39540855114497, 2.3356380131527215, -0.12648111233755144, -1.2026936372556161, 1.2960572498209078, 0.84582983938134593, -2.1888304485470549); + TestUtils.AreEqual(a1 / b1, r1); + + double3x3 a2 = double3x3(-502.64601611655485, -174.69034036187935, 83.796309271732525, 197.04206690427009, 317.16826525198678, 403.38711781212464, 81.646461763254592, 60.606869964211683, -413.56048102563273); + double b2 = (-84.324793139623864); + double3x3 r2 = double3x3(5.9608330765102533, 2.07163674949821, -0.99373275820533258, -2.3367038277581123, -3.7612694136921725, -4.7837308909160514, -0.968237913469476, -0.71873132097531078, 4.9043758736634526); + TestUtils.AreEqual(a2 / b2, r2); + + double3x3 a3 = double3x3(207.34099803089214, 20.749072799807891, -68.577131064877449, 310.70246257945075, 417.40490193730443, 147.86623079509764, 506.6588964437409, -435.77857300070048, 210.67294011389504); + double b3 = (358.5621036768714); + double3x3 r3 = double3x3(0.57825686514195451, 0.057867444961519181, -0.19125593687022127, 0.8665234261885334, 1.1641076891758224, 0.41238666685298, 1.4130296850900095, -1.2153503354984077, 0.58754937555740427); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_div_scalar_wide() + { + double a0 = (41.737658758525527); + double3x3 b0 = double3x3(-422.676129776368, 248.12963235011773, 449.39137741988122, 245.85813796047967, -326.62061253498337, 163.71510489457989, 333.664472020075, 38.291076916405473, -472.97976062864984); + double3x3 r0 = double3x3(-0.098746193168297289, 0.1682090863683405, 0.092875967042706856, 0.16976317767945767, -0.12778635871933872, 0.25494079355354177, 0.12508871114097631, 1.0900100524632514, -0.088244069266411956); + TestUtils.AreEqual(a0 / b0, r0); + + double a1 = (192.23013958345643); + double3x3 b1 = double3x3(-200.29686960964318, -490.18150376257557, -211.10257468517057, -322.85234108700058, -137.98529035317961, 84.32973555677097, 355.06345550858578, 276.42724455354141, -382.9880213136729); + double3x3 r1 = double3x3(-0.95972613030893628, -0.3921611446125986, -0.91060063985548412, -0.59541194261204144, -1.3931205209731754, 2.2795060166416232, 0.5413965774317997, 0.695409527718326, -0.50192206775578785); + TestUtils.AreEqual(a1 / b1, r1); + + double a2 = (-488.647160996053); + double3x3 b2 = double3x3(344.84603826368505, 168.85499938244698, -44.19558837087618, 420.550703959796, -175.6152060849663, -9.2205684227964753, -344.19428865248074, -449.07149216582604, 117.70491724726969); + double3x3 r2 = double3x3(-1.417000941801196, -2.8938862502335212, 11.056469186369281, -1.1619221092607348, 2.7824877576924365, 52.995340264266794, 1.4196841060585423, 1.0881277692319269, -4.1514591949418982); + TestUtils.AreEqual(a2 / b2, r2); + + double a3 = (-337.02741710144437); + double3x3 b3 = double3x3(239.39341389359595, -389.35516304027067, 242.71606718875285, 496.27646445495839, 91.745798392102984, -490.49213360738577, 485.75540922850155, -317.57225504404505, -451.62477871944418); + double3x3 r3 = double3x3(-1.4078391365070895, 0.86560407847111542, -1.3885665708292334, -0.67911223126728126, -3.6734915713639262, 0.68712094243537414, -0.69382123327607692, 1.0612621592358598, 0.74625537167616451); + TestUtils.AreEqual(a3 / b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_mod_wide_wide() + { + double3x3 a0 = double3x3(-442.30985924336585, 368.50046246522129, -1.0938966279355213, -364.67383473211612, -197.34394487987458, -34.034902350062, -101.34858350704826, 208.31857142612273, -140.77031404374645); + double3x3 b0 = double3x3(-43.245045443645211, -144.19587690392319, -62.640481739603217, -336.82826510855381, -154.6102545981343, -154.02935583611452, 487.0462093237071, -469.82909105244516, -145.20377237405802); + double3x3 r0 = double3x3(-9.8594048069137443, 80.1087086573749, -1.0938966279355213, -27.845569623562312, -42.73369028174028, -34.034902350062, -101.34858350704826, 208.31857142612273, -140.77031404374645); + TestUtils.AreEqual(a0 % b0, r0); + + double3x3 a1 = double3x3(183.446989383291, -463.36838100076113, 83.839106360375467, -64.714058190916717, 295.06681050689281, 212.257051805154, 349.62829916068745, 119.87592106679267, -37.805828350505692); + double3x3 b1 = double3x3(-203.38401780062543, -22.520082245823062, 224.6900237652892, -435.62674614210925, 12.095571285158144, 40.378765363422531, 345.78484813579587, -433.47126146474443, -355.64996712079733); + double3x3 r1 = double3x3(183.446989383291, -12.966736084299896, 83.839106360375467, -64.714058190916717, 4.773099663097355, 10.363224988041338, 3.8434510248915785, 119.87592106679267, -37.805828350505692); + TestUtils.AreEqual(a1 % b1, r1); + + double3x3 a2 = double3x3(142.41158515886013, 332.24425593588694, -464.19427249589671, -296.14783801517814, 225.17535863871467, -212.06027732233531, 156.98570425668061, 507.61831092630439, 270.83043897842538); + double3x3 b2 = double3x3(4.0154273528677322, 66.659781725453058, -221.85363088448236, -355.05676405274158, 357.93597118832918, 71.375334057666009, -131.41830188195144, -473.98760078567432, 76.2178585884244); + double3x3 r2 = double3x3(1.8716278084895066, 65.605129034074707, -20.487010726932, -296.14783801517814, 225.17535863871467, -69.309609207003291, 25.56740237472917, 33.630710140630072, 42.17686321315216); + TestUtils.AreEqual(a2 % b2, r2); + + double3x3 a3 = double3x3(337.734341063413, 384.91584819597927, 432.51818128699347, 154.29270775350403, -37.0853169137078, 7.7614462411783052, 238.09472309709281, 12.852037674212852, -100.2406762113053); + double3x3 b3 = double3x3(92.210223002457155, -368.18956130006796, -77.467150485826267, 135.23059398272574, 274.27728975670288, 132.18024951414213, -179.87732204230377, 51.968538546920058, 367.21425860338582); + double3x3 r3 = double3x3(61.103672056041546, 16.7262868959113, 45.182428857862135, 19.062113770778296, -37.0853169137078, 7.7614462411783052, 58.217401054789036, 12.852037674212852, -100.2406762113053); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_mod_wide_scalar() + { + double3x3 a0 = double3x3(-433.41699548876704, -5.5141427542614565, 393.39439958771425, 299.41153277988155, -120.80601626299602, -502.939041133476, -450.80766245853511, 186.09479698263794, -84.473635951277629); + double b0 = (-90.499235433758827); + double3x3 r0 = double3x3(-71.420053753731736, -5.5141427542614565, 31.39745785267894, 27.913826478605074, -30.306780829237198, -50.442863964681862, -88.8107207234998, 5.0963261151202914, -84.473635951277629); + TestUtils.AreEqual(a0 % b0, r0); + + double3x3 a1 = double3x3(-318.78148356023314, -54.6001856581309, -172.33886607565864, -429.71466728193434, 222.36186109406958, 5.796394112425105, 254.51082885196, -433.09369703433185, -203.08261284748215); + double b1 = (433.45469041981482); + double3x3 r1 = double3x3(-318.78148356023314, -54.6001856581309, -172.33886607565864, -429.71466728193434, 222.36186109406958, 5.796394112425105, 254.51082885196, -433.09369703433185, -203.08261284748215); + TestUtils.AreEqual(a1 % b1, r1); + + double3x3 a2 = double3x3(-75.356399809641971, -69.403906139267576, 5.3372299696026175, -279.06042803407666, 483.55059097872606, -331.99334660730949, 335.99997655302286, 67.839589388966374, -124.72076731767544); + double b2 = (252.28909385031511); + double3x3 r2 = double3x3(-75.356399809641971, -69.403906139267576, 5.3372299696026175, -26.771334183761553, 231.26149712841095, -79.704252756994379, 83.71088270270775, 67.839589388966374, -124.72076731767544); + TestUtils.AreEqual(a2 % b2, r2); + + double3x3 a3 = double3x3(38.175906437531125, 405.77360100567978, -194.76144489774549, 235.72397314557986, 465.98487804177444, -304.153164289963, -295.52024735860539, 313.72239532774427, -232.20264135683078); + double b3 = (271.28698671575955); + double3x3 r3 = double3x3(38.175906437531125, 134.48661428992023, -194.76144489774549, 235.72397314557986, 194.69789132601488, -32.866177574203448, -24.233260642845835, 42.435408611984712, -232.20264135683078); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_mod_scalar_wide() + { + double a0 = (-396.4224028049141); + double3x3 b0 = double3x3(-159.14024384279747, 230.17333399046834, 14.779358632294134, -303.15649738123477, 399.63502020371845, 206.69470534412881, 397.04482263934096, -393.89064735634747, -372.06709426085797); + double3x3 r0 = double3x3(-78.141915119319151, -166.24906881444576, -12.159078365266623, -93.265905423679328, -396.4224028049141, -189.72769746078529, -396.4224028049141, -2.5317554485666278, -24.355308544056129); + TestUtils.AreEqual(a0 % b0, r0); + + double a1 = (201.01229796233224); + double3x3 b1 = double3x3(-95.5668547598491, -258.95146882671463, 106.98357563232241, 469.3235559264773, -34.808985011097491, 184.83653434777466, 374.79425376224992, -131.87271911086174, -120.09286003936683); + double3x3 r1 = double3x3(9.8785884426340544, 201.01229796233224, 94.028722330009828, 201.01229796233224, 26.967372906844787, 16.175763614557582, 201.01229796233224, 69.1395788514705, 80.919437922965415); + TestUtils.AreEqual(a1 % b1, r1); + + double a2 = (4.506670715523228); + double3x3 b2 = double3x3(-111.40195732535886, 391.54249710195813, -218.66887078931035, 196.37741980160467, -511.03262233689082, 499.95350598727987, -433.52306505363578, -163.8668559360629, 177.00401099818009); + double3x3 r2 = double3x3(4.506670715523228, 4.506670715523228, 4.506670715523228, 4.506670715523228, 4.506670715523228, 4.506670715523228, 4.506670715523228, 4.506670715523228, 4.506670715523228); + TestUtils.AreEqual(a2 % b2, r2); + + double a3 = (110.65016441729392); + double3x3 b3 = double3x3(17.68454910148148, -95.85296754532169, -432.44096561541824, 192.69208654793545, -268.13177621929526, 271.07511461483091, 423.70268912972074, -413.23324675729185, 127.95621091125361); + double3x3 r3 = double3x3(4.5428698084050438, 14.797196871972233, 110.65016441729392, 110.65016441729392, 110.65016441729392, 110.65016441729392, 110.65016441729392, 110.65016441729392, 110.65016441729392); + TestUtils.AreEqual(a3 % b3, r3); + } + + [TestCompiler] + public static void double3x3_operator_plus() + { + double3x3 a0 = double3x3(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045, 315.44952860262686, 319.22218742930431, 190.32466015141677, -350.30858270745193, -320.51845875406565); + double3x3 r0 = double3x3(271.6708086802023, -79.080240524876956, -330.98506203805334, 31.824682965793045, 315.44952860262686, 319.22218742930431, 190.32466015141677, -350.30858270745193, -320.51845875406565); + TestUtils.AreEqual(+a0, r0); + + double3x3 a1 = double3x3(102.0544069288552, -428.77622075973835, 377.23016208095021, 234.77393042052813, 34.283600107898792, 258.33039414991174, 465.35593555185756, 309.59316530339106, -316.93713655925222); + double3x3 r1 = double3x3(102.0544069288552, -428.77622075973835, 377.23016208095021, 234.77393042052813, 34.283600107898792, 258.33039414991174, 465.35593555185756, 309.59316530339106, -316.93713655925222); + TestUtils.AreEqual(+a1, r1); + + double3x3 a2 = double3x3(-230.05266557915724, 2.585727931273027, 350.24640981771347, 60.819777278611355, -472.44209526127304, -364.80255644619581, 239.15236937215195, 473.8031363309376, 285.80893935161123); + double3x3 r2 = double3x3(-230.05266557915724, 2.585727931273027, 350.24640981771347, 60.819777278611355, -472.44209526127304, -364.80255644619581, 239.15236937215195, 473.8031363309376, 285.80893935161123); + TestUtils.AreEqual(+a2, r2); + + double3x3 a3 = double3x3(-273.26378191321334, -113.36231785331029, -351.7548708169511, -116.53621798219916, -496.05329274388652, -330.00534716714424, -379.67424100436006, -339.673203864914, -29.083537353707243); + double3x3 r3 = double3x3(-273.26378191321334, -113.36231785331029, -351.7548708169511, -116.53621798219916, -496.05329274388652, -330.00534716714424, -379.67424100436006, -339.673203864914, -29.083537353707243); + TestUtils.AreEqual(+a3, r3); + } + + [TestCompiler] + public static void double3x3_operator_neg() + { + double3x3 a0 = double3x3(420.22718854445372, -196.25749811728366, -335.42683068636188, 509.04366969924592, -33.014395013923945, -498.57532071442125, -495.8379526063045, -270.85946787095605, 19.686896571743773); + double3x3 r0 = double3x3(-420.22718854445372, 196.25749811728366, 335.42683068636188, -509.04366969924592, 33.014395013923945, 498.57532071442125, 495.8379526063045, 270.85946787095605, -19.686896571743773); + TestUtils.AreEqual(-a0, r0); + + double3x3 a1 = double3x3(268.23670662019254, 223.38126312167446, -410.39206070936848, -395.68154186554324, -349.14948885010062, -110.9393032113739, -238.21960913307015, 292.54351224216794, 469.29257867731735); + double3x3 r1 = double3x3(-268.23670662019254, -223.38126312167446, 410.39206070936848, 395.68154186554324, 349.14948885010062, 110.9393032113739, 238.21960913307015, -292.54351224216794, -469.29257867731735); + TestUtils.AreEqual(-a1, r1); + + double3x3 a2 = double3x3(48.290685914592245, 66.148520738886873, 55.707977559281517, 464.54141090090457, 499.24280213715645, 175.01502259774838, 196.38759169186824, -306.1655677790593, 149.66006023700356); + double3x3 r2 = double3x3(-48.290685914592245, -66.148520738886873, -55.707977559281517, -464.54141090090457, -499.24280213715645, -175.01502259774838, -196.38759169186824, 306.1655677790593, -149.66006023700356); + TestUtils.AreEqual(-a2, r2); + + double3x3 a3 = double3x3(320.3917383255399, 22.03845144344416, -159.55426199713457, 419.82245011805674, 303.32339992342679, 363.71671049842462, 280.88790405955535, -270.65131939139746, -201.61574015469091); + double3x3 r3 = double3x3(-320.3917383255399, -22.03845144344416, 159.55426199713457, -419.82245011805674, -303.32339992342679, -363.71671049842462, -280.88790405955535, 270.65131939139746, 201.61574015469091); + TestUtils.AreEqual(-a3, r3); + } + + [TestCompiler] + public static void double3x3_operator_prefix_inc() + { + double3x3 a0 = double3x3(-99.79557113526181, 458.74185082816609, 96.179026886904126, -48.552469514567633, -315.728967098393, -299.23014583216525, -323.61485853959567, -456.89028832730384, -76.507656371457358); + double3x3 r0 = double3x3(-98.79557113526181, 459.74185082816609, 97.179026886904126, -47.552469514567633, -314.728967098393, -298.23014583216525, -322.61485853959567, -455.89028832730384, -75.507656371457358); + TestUtils.AreEqual(++a0, r0); + + double3x3 a1 = double3x3(-305.58477344437722, 148.67930967578627, 363.2849182390072, -115.5592263283018, -326.87781992874937, -179.89464839729231, 339.8765849265626, -38.410431164507941, -153.3736775635619); + double3x3 r1 = double3x3(-304.58477344437722, 149.67930967578627, 364.2849182390072, -114.5592263283018, -325.87781992874937, -178.89464839729231, 340.8765849265626, -37.410431164507941, -152.3736775635619); + TestUtils.AreEqual(++a1, r1); + + double3x3 a2 = double3x3(261.62557304167444, -396.65022892348946, 301.30576791488829, -221.35540328796736, -429.69815011960367, -271.28932893988178, -264.38006246480165, -377.55920785365589, 223.23241792583485); + double3x3 r2 = double3x3(262.62557304167444, -395.65022892348946, 302.30576791488829, -220.35540328796736, -428.69815011960367, -270.28932893988178, -263.38006246480165, -376.55920785365589, 224.23241792583485); + TestUtils.AreEqual(++a2, r2); + + double3x3 a3 = double3x3(-71.076339993195745, 131.28316909227669, 22.304934273615913, -480.76047228312143, 200.95175967037289, 117.95409851798513, 139.52581245243823, 335.68968192473505, 162.6615141195532); + double3x3 r3 = double3x3(-70.076339993195745, 132.28316909227669, 23.304934273615913, -479.76047228312143, 201.95175967037289, 118.95409851798513, 140.52581245243823, 336.68968192473505, 163.6615141195532); + TestUtils.AreEqual(++a3, r3); + } + + [TestCompiler] + public static void double3x3_operator_postfix_inc() + { + double3x3 a0 = double3x3(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888, -31.420532002775246, 455.33662459595905, 271.45466840986842, 55.736877228942149, 153.75031645305); + double3x3 r0 = double3x3(322.94356623429042, 472.05246542024076, 203.48761925636211, -49.854570650427888, -31.420532002775246, 455.33662459595905, 271.45466840986842, 55.736877228942149, 153.75031645305); + TestUtils.AreEqual(a0++, r0); + + double3x3 a1 = double3x3(-174.17301925186672, 215.11022744658874, 159.86103184514729, -333.05045262586816, 241.46487509527469, 287.22045649551808, -170.10464366250886, -270.65246380057766, -162.86024792625579); + double3x3 r1 = double3x3(-174.17301925186672, 215.11022744658874, 159.86103184514729, -333.05045262586816, 241.46487509527469, 287.22045649551808, -170.10464366250886, -270.65246380057766, -162.86024792625579); + TestUtils.AreEqual(a1++, r1); + + double3x3 a2 = double3x3(454.48881003562769, 209.52264294844247, -311.43587103087259, 69.731466087387616, -232.29964433996923, -341.49855271982892, 188.00656685047159, 417.72977919957123, 25.565661203845252); + double3x3 r2 = double3x3(454.48881003562769, 209.52264294844247, -311.43587103087259, 69.731466087387616, -232.29964433996923, -341.49855271982892, 188.00656685047159, 417.72977919957123, 25.565661203845252); + TestUtils.AreEqual(a2++, r2); + + double3x3 a3 = double3x3(-463.72565982478005, -310.1449584020977, -117.39846258861871, 403.50871271803453, -111.27954178269931, 446.60767313773169, -12.352577930480493, -232.15012251220185, 64.577020436793987); + double3x3 r3 = double3x3(-463.72565982478005, -310.1449584020977, -117.39846258861871, 403.50871271803453, -111.27954178269931, 446.60767313773169, -12.352577930480493, -232.15012251220185, 64.577020436793987); + TestUtils.AreEqual(a3++, r3); + } + + [TestCompiler] + public static void double3x3_operator_prefix_dec() + { + double3x3 a0 = double3x3(-416.20121712992022, -96.637880131899351, -50.145671629414721, -207.31644759295341, 439.47906156977592, -304.40081920493435, 337.96895734312432, 246.08898293510492, 171.96452935597142); + double3x3 r0 = double3x3(-417.20121712992022, -97.637880131899351, -51.145671629414721, -208.31644759295341, 438.47906156977592, -305.40081920493435, 336.96895734312432, 245.08898293510492, 170.96452935597142); + TestUtils.AreEqual(--a0, r0); + + double3x3 a1 = double3x3(-227.44280134301761, 326.50782338087811, 400.720900006928, -478.03137253133178, -326.45297852459038, -24.584499132160317, 112.79684668071422, -341.97629300783217, -503.27416181158003); + double3x3 r1 = double3x3(-228.44280134301761, 325.50782338087811, 399.720900006928, -479.03137253133178, -327.45297852459038, -25.584499132160317, 111.79684668071422, -342.97629300783217, -504.27416181158003); + TestUtils.AreEqual(--a1, r1); + + double3x3 a2 = double3x3(-79.635249413380052, 147.89369566174867, -15.70865417258284, 188.75845274178243, 307.79193582562357, -406.667706917351, 181.47510703908051, -188.69222578252305, -505.2156915633081); + double3x3 r2 = double3x3(-80.635249413380052, 146.89369566174867, -16.70865417258284, 187.75845274178243, 306.79193582562357, -407.667706917351, 180.47510703908051, -189.69222578252305, -506.2156915633081); + TestUtils.AreEqual(--a2, r2); + + double3x3 a3 = double3x3(-372.24192898918034, 83.767736235525376, -30.631410374600193, -436.90656181653333, -51.668396258572329, 345.02153913351776, 4.7353689692613443, -68.653318198701982, 481.496122346025); + double3x3 r3 = double3x3(-373.24192898918034, 82.767736235525376, -31.631410374600193, -437.90656181653333, -52.668396258572329, 344.02153913351776, 3.7353689692613443, -69.653318198701982, 480.496122346025); + TestUtils.AreEqual(--a3, r3); + } + + [TestCompiler] + public static void double3x3_operator_postfix_dec() + { + double3x3 a0 = double3x3(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555, 409.55752940175944, 47.856652520530247, -281.11170376516492, -262.062590959511, -182.40572866350681); + double3x3 r0 = double3x3(-376.59242719066907, 16.969734438215255, -0.25066399585949739, -202.32328734282555, 409.55752940175944, 47.856652520530247, -281.11170376516492, -262.062590959511, -182.40572866350681); + TestUtils.AreEqual(a0--, r0); + + double3x3 a1 = double3x3(450.12809559801974, -332.15495768755443, -261.00890052551819, 205.46112570793423, -230.22777878038016, -483.06653784358247, 378.64123433578811, 487.34482287212495, -192.17785772689518); + double3x3 r1 = double3x3(450.12809559801974, -332.15495768755443, -261.00890052551819, 205.46112570793423, -230.22777878038016, -483.06653784358247, 378.64123433578811, 487.34482287212495, -192.17785772689518); + TestUtils.AreEqual(a1--, r1); + + double3x3 a2 = double3x3(-357.05418960985457, 279.42425287860647, 115.86774092347719, -20.823201427619551, 323.40538063803933, 379.15614026559342, 311.29903068733358, 409.22248644811214, -428.25672479544613); + double3x3 r2 = double3x3(-357.05418960985457, 279.42425287860647, 115.86774092347719, -20.823201427619551, 323.40538063803933, 379.15614026559342, 311.29903068733358, 409.22248644811214, -428.25672479544613); + TestUtils.AreEqual(a2--, r2); + + double3x3 a3 = double3x3(-425.2883748604396, -258.84836089743692, -208.98576388553982, -313.42591657928466, 178.31252797800698, 176.78949864990523, -370.78628438095853, 64.903882295314133, 449.63778540568319); + double3x3 r3 = double3x3(-425.2883748604396, -258.84836089743692, -208.98576388553982, -313.42591657928466, 178.31252797800698, 176.78949864990523, -370.78628438095853, 64.903882295314133, 449.63778540568319); + 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/TestMath2.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/TestMath2.cs new file mode 100644 index 0000000000000000000000000000000000000000..e5867b6c5bc53503fb6d336b64265321d9f2f3a8 --- /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/TestMath2.cs @@ -0,0 +1,63 @@ +using NUnit.Framework; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + public partial class TestMath + { + [TestCompiler] + public unsafe void hash_blob() + { + byte[] testData = { + 0x0d, 0x26, 0x1c, 0xeb, 0x56, 0x3a, 0x9c, 0x18, 0x93, 0xb6, + 0xc1, 0x99, 0x5e, 0x04, 0x92, 0x4f, 0x6e, 0xb7, 0x42, 0x53, + 0x23, 0xcf, 0xe3, 0xbf, 0x16, 0x64, 0x79, 0x08, 0xc1, 0x01, + 0x43, 0x89, 0x73, 0x8f, 0x76, 0x22, 0x0c, 0xee, 0x9b, 0x80, + 0x31, 0x83, 0xce, 0x33, 0x8b, 0xc7, 0x3f, 0x94, 0x33 + }; + + uint[] resultsWithZeroSeed = + { + 0x02cc5d05, 0x376a5b3f, 0x8ae13198, 0xf5b14d72, 0xcc7ddc84, + 0x763e5905, 0x58759392, 0x6bccbd00, 0x7d0f80c8, 0xef01ae48, + 0xe40aa3ad, 0x805e04ad, 0xf98a471c, 0xdd960ac1, 0x76a71750, + 0xd35e2baa, 0x0219f7da, 0xd5bd1fbd, 0x5f28c87e, 0xfe6f7995, + 0x69a43ac5, 0xec1a1a15, 0x7ae9f103, 0x8d04a688, 0xce3b35be, + 0x6b3f040c, 0xd5ea2e8c, 0x6989e79c, 0x8772f1fb, 0x0d7b7bf6, + 0x0796214b, 0x98ea65c4, 0x3884dd82, 0x59632484, 0x91c92822, + 0x72d28404, 0x167061b0, 0x32adc2ef, 0xbac3e672, 0xd39936b7, + 0x94e2c154, 0x8b4ff46c, 0x68976fd4, 0x04bee59a, 0x2ed62c69, + 0xabee69fd, 0xda11e266, 0xcebd9d38, 0x28eea5fd, 0x0210d6ee + }; + + + uint[] resultsWith_0xeb69cf40_seed = + { + 0x12c3b280, 0x9bc1f68d, 0x2f900b51, 0xdb77e20e, 0xf6e8f561, + 0x3f3f72f6, 0x15f9700f, 0x28beb671, 0xceece5e1, 0x7a9b5c81, + 0x62a84642, 0xf75666af, 0x8939f8ca, 0x6b84792b, 0x527ee836, + 0xa0782090, 0xce6b9926, 0xa608c73b, 0xa08ee6a3, 0xab77a6b2, + 0x4e174e68, 0x596f10d5, 0xa14c4d85, 0x509ab88d, 0xd14698a4, + 0xbaad2308, 0xbd04c3df, 0x5715fed1, 0x5cf23a74, 0xd4e844f9, + 0x166dcfba, 0xe3495e37, 0x1b18b2b3, 0x2e8c2aab, 0x40993321, + 0x4b84998a, 0xd062937d, 0x1b2c9f7b, 0x8a613ed3, 0x70d71291, + 0x1af38ea4, 0x460cb7e9, 0xf806e3a9, 0xec9b6b2e, 0x9972a843, + 0x1ff06d2a, 0xe8c5007b, 0x37d8fc40, 0x0dc4f639, 0x36edff4f + }; + fixed (byte* p = testData) + { + for (int i = 0; i < 50; ++i) + { + TestUtils.AreEqual(resultsWithZeroSeed[i], hash(p, i, 0)); + } + + for (int i = 0; i < 50; ++i) + { + TestUtils.AreEqual(resultsWith_0xeb69cf40_seed[i], hash(p, i, 0xeb69cf40)); + } + } + } + } +} 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/TestMath2.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/TestMath2.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..d2cf65d604bc949685157863aaf9cab373887958 --- /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/TestMath2.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: b0783b280ba38504faba05db473c408b +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/TestRandom.cs b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Tests/Tests/TestRandom.cs new file mode 100644 index 0000000000000000000000000000000000000000..0a8acd0e78f4e131f30f1931b915ba3cb9d6b7dd --- /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/TestRandom.cs @@ -0,0 +1,1186 @@ +using NUnit.Framework; +using System; +using static Unity.Mathematics.math; +using Burst.Compiler.IL.Tests; + +namespace Unity.Mathematics.Tests +{ + [TestFixture] + class TestRandom + { + // Kolmogorov–Smirnov test on lambda assuming the ideal distribution is uniform [0, 1] + private static void ks_test(Func func, int num_buckets = 256) + { + const int N = 8192; + var histogram = new int[num_buckets]; + + for (int i = 0; i < N; i++) + { + double x = func(); + Assert.GreaterOrEqual(x, 0.0); + Assert.LessOrEqual(x, 1.0); + int bucket = min((int)(x * num_buckets), num_buckets - 1); + + histogram[bucket]++; + } + + double largest_delta = 0.0f; + int accum = 0; + for (int i = 0; i < histogram.Length; i++) + { + accum += histogram[i]; + double current = accum / (double)N; + double target = (double)(i + 1) / histogram.Length; + largest_delta = math.max(largest_delta, math.abs(current - target)); + } + double d = 1.62762 / math.sqrt((double)N); // significance: 0.01 + Assert.Less(largest_delta, d); + } + + private static void ks_test(Func func) + { + ks_test(() => func().x); + ks_test(() => func().y); + } + + // Pearson's product-moment coefficient + private static void r_test(Func func) + { + const int N = 4096; + + double2 sum = 0.0; + var values = new double2[N]; + for(int i = 0; i < N; i++) + { + values[i] = func(); + sum += values[i]; + } + + double2 avg = sum / N; + double var_a = 0.0; + double var_b = 0.0; + double cov = 0.0; + for (int i = 0; i < N; i++) + { + double2 delta = values[i] - avg; + var_a += delta.x * delta.x; + var_b += delta.y * delta.y; + cov += delta.x * delta.y; + } + + double r = cov / sqrt(var_a * var_b); + Assert.Less(abs(r), 0.05); + } + + private static float range_check01(float x) + { + Assert.GreaterOrEqual(x, 0.0f); + Assert.Less(x, 1.0f); + return x; + } + + private static double range_check01(double x) + { + Assert.GreaterOrEqual(x, 0.0); + Assert.Less(x, 1.0); + return x; + } + + private static int range_check(int x, int min, int max) + { + Assert.GreaterOrEqual(x, min); + Assert.Less(x, max); + return x; + } + + private static uint range_check(uint x, uint min, uint max) + { + Assert.GreaterOrEqual(x, min); + Assert.Less(x, max); + return x; + } + + private static float range_check(float x, float min, float max) + { + Assert.GreaterOrEqual(x, min); + Assert.Less(x, max); + return x; + } + + private static double range_check(double x, double min, double max) + { + Assert.GreaterOrEqual(x, min); + Assert.Less(x, max); + return x; + } + + + [TestCompiler] + public static void bool_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => rnd.NextBool() ? 0.75 : 0.25), 2); + } + + [TestCompiler] + public static void bool2_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => rnd.NextBool2().x ? 0.75 : 0.25), 2); + ks_test((() => rnd.NextBool2().y ? 0.75 : 0.25), 2); + } + + [TestCompiler] + public static void bool2_independent() + { + var rnd = new Random(0x6E624EB7u); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool2().xy))); + } + + [TestCompiler] + public static void bool3_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => rnd.NextBool3().x ? 0.75 : 0.25), 2); + ks_test((() => rnd.NextBool3().y ? 0.75 : 0.25), 2); + ks_test((() => rnd.NextBool3().z ? 0.75 : 0.25), 2); + } + + [TestCompiler] + public static void bool3_independent() + { + var rnd = new Random(0x6E624EB7u); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool3().xy))); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool3().xz))); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool3().yz))); + } + + [TestCompiler] + public static void bool4_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => rnd.NextBool4().x ? 0.75 : 0.25), 2); + ks_test((() => rnd.NextBool4().y ? 0.75 : 0.25), 2); + ks_test((() => rnd.NextBool4().z ? 0.75 : 0.25), 2); + ks_test((() => rnd.NextBool4().w ? 0.75 : 0.25), 2); + } + + [TestCompiler] + public static void bool4_independent() + { + var rnd = new Random(0x6E624EB7u); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().xy))); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().xz))); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().xw))); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().yz))); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().yw))); + r_test((() => select(double2(0.25), double2(0.75), rnd.NextBool4().zw))); + } + + [TestCompiler] + public static void int_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextInt() & 255u) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void int_uniform_high_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => (((uint)rnd.NextInt() >> 24) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void int_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + int max = 17; + ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), max); + } + + [TestCompiler] + public static void int_uniform_max_limit() + { + var rnd = new Random(0x6E624EB7u); + int max = 2147483647; + ks_test((() => (range_check(rnd.NextInt(max), 0, max) + 0.5) / max), 256); + } + + [TestCompiler] + public static void int_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + int min = -7; + int max = 17; + int range = max - min; + ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), range); + } + + [TestCompiler] + public static void int_uniform_min_max_limit() + { + var rnd = new Random(0x6E624EB7u); + int min = -2147483648; + int max = 2147483647; + long range = (long)max - (long)min; + ks_test((() => (range_check(rnd.NextInt(min, max), min, max) + 0.5 - min) / range), 256); + } + + [TestCompiler] + public static void int2_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextInt2().x & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextInt2().y & 255u) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void int2_uniform_high_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => (((uint)rnd.NextInt2().x >> 24) + 0.5) / 256.0), 256); + ks_test((() => (((uint)rnd.NextInt2().y >> 24) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void int2_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + int max = 2147483647; + ks_test((() => (range_check(rnd.NextInt2(max).x, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextInt2(max).y, 0, max) + 0.5) / max), 256); + } + + [TestCompiler] + public static void int2_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + int2 min = int2(-7, 3); + int2 max = int2(17, 14); + int2 range = max - min; + ks_test((() => (range_check(rnd.NextInt2(min, max).x, min.x, max.x) + 0.5 - min.x) / range.x), range.x); + ks_test((() => (range_check(rnd.NextInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), range.y); + } + + [TestCompiler] + public static void int2_uniform_min_max_limit() + { + var rnd = new Random(0x6E624EB7u); + int min = -2147483648; + int max = 2147483647; + long range = (long)max - (long)min; + ks_test((() => (range_check(rnd.NextInt2(min, max).x, min, max) + 0.5 - min) / range), 256); + ks_test((() => (range_check(rnd.NextInt2(min, max).y, min, max) + 0.5 - min) / range), 256); + } + + [TestCompiler] + public static void int2_independent_low_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => (rnd.NextInt2().xy & 255)); + } + + [TestCompiler] + public static void int2_independent_high_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => ((uint2)rnd.NextInt2().xy >> 24)); + } + + [TestCompiler] + public static void int3_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextInt3().x & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextInt3().y & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextInt3().z & 255u) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void int3_uniform_high_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => (((uint)rnd.NextInt3().x >> 24) + 0.5) / 256.0), 256); + ks_test((() => (((uint)rnd.NextInt3().y >> 24) + 0.5) / 256.0), 256); + ks_test((() => (((uint)rnd.NextInt3().z >> 24) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void int3_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + int3 max = int3(13, 17, 19); + ks_test((() => ((uint)range_check(rnd.NextInt3(max).x, 0, max.x) + 0.5) / max.x), max.x); + ks_test((() => ((uint)range_check(rnd.NextInt3(max).y, 0, max.y) + 0.5) / max.y), max.y); + ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max.z) + 0.5) / max.z), max.z); + } + + [TestCompiler] + public static void int3_uniform_max_limit() + { + var rnd = new Random(0x6E624EB7u); + int max = 2147483647; + ks_test((() => ((uint)range_check(rnd.NextInt3(max).x, 0, max) + 0.5) / max), 256); + ks_test((() => ((uint)range_check(rnd.NextInt3(max).y, 0, max) + 0.5) / max), 256); + ks_test((() => ((uint)range_check(rnd.NextInt3(max).z, 0, max) + 0.5) / max), 256); + } + + [TestCompiler] + public static void int3_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + int3 min = int3(-7, 3, -10); + int3 max = int3(17, 14, -3); + int3 range = max - min; + ks_test((() => (range_check(rnd.NextInt3(min, max).x, min.x, max.x) + 0.5 - min.x) / range.x), range.x); + ks_test((() => (range_check(rnd.NextInt3(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), range.y); + ks_test((() => (range_check(rnd.NextInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), range.z); + } + + [TestCompiler] + public static void int3_uniform_min_max_limit() + { + var rnd = new Random(0x6E624EB7u); + int min = -2147483648; + int max = 2147483647; + long range = (long)max - (long)min; + ks_test((() => (range_check(rnd.NextInt3(min, max).x, min, max) + 0.5 - min) / range), 256); + ks_test((() => (range_check(rnd.NextInt3(min, max).y, min, max) + 0.5 - min) / range), 256); + ks_test((() => (range_check(rnd.NextInt3(min, max).z, min, max) + 0.5 - min) / range), 256); + } + + [TestCompiler] + public static void int3_independent_low_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => (rnd.NextInt3().xy & 255)); + r_test(() => (rnd.NextInt3().xz & 255)); + r_test(() => (rnd.NextInt3().yz & 255)); + } + + [TestCompiler] + public static void int3_independent_high_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => ((uint2)rnd.NextInt3().xy >> 24)); + r_test(() => ((uint2)rnd.NextInt3().xz >> 24)); + r_test(() => ((uint2)rnd.NextInt3().yz >> 24)); + } + + [TestCompiler] + public static void int4_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextInt4().x & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextInt4().y & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextInt4().z & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextInt4().w & 255u) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void int4_uniform_high_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => (((uint)rnd.NextInt4().x >> 24) + 0.5) / 256.0), 256); + ks_test((() => (((uint)rnd.NextInt4().y >> 24) + 0.5) / 256.0), 256); + ks_test((() => (((uint)rnd.NextInt4().z >> 24) + 0.5) / 256.0), 256); + ks_test((() => (((uint)rnd.NextInt4().w >> 24) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void int4_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + int4 max = int4(13, 17, 19, 23); + ks_test((() => (range_check(rnd.NextInt4(max).x, 0, max.x) + 0.5) / max.x), max.x); + ks_test((() => (range_check(rnd.NextInt4(max).y, 0, max.y) + 0.5) / max.y), max.y); + ks_test((() => (range_check(rnd.NextInt4(max).z, 0, max.z) + 0.5) / max.z), max.z); + ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max.w) + 0.5) / max.w), max.w); + } + + [TestCompiler] + public static void int4_uniform_max_limit() + { + var rnd = new Random(0x6E624EB7u); + int max = 2147483647; + ks_test((() => (range_check(rnd.NextInt4(max).x, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextInt4(max).y, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextInt4(max).z, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextInt4(max).w, 0, max) + 0.5) / max), 256); + } + + [TestCompiler] + public static void int4_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + int4 min = int4(-7, 3, -10, 1); + int4 max = int4(17, 14, -3, 111); + int4 range = max - min; + ks_test((() => (range_check(rnd.NextInt4(min, max).x, min.x, max.x) + 0.5 - min.x) / range.x), range.x); + ks_test((() => (range_check(rnd.NextInt4(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), range.y); + ks_test((() => (range_check(rnd.NextInt4(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), range.z); + ks_test((() => (range_check(rnd.NextInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), range.w); + } + + [TestCompiler] + public static void int4_uniform_min_max_limit() + { + var rnd = new Random(0x6E624EB7u); + int min = -2147483648; + int max = 2147483647; + long range = (long)max - (long)min; + ks_test((() => (range_check(rnd.NextInt4(min, max).x, min, max) + 0.5 - min) / range), 256); + ks_test((() => (range_check(rnd.NextInt4(min, max).y, min, max) + 0.5 - min) / range), 256); + ks_test((() => (range_check(rnd.NextInt4(min, max).z, min, max) + 0.5 - min) / range), 256); + ks_test((() => (range_check(rnd.NextInt4(min, max).w, min, max) + 0.5 - min) / range), 256); + } + + [TestCompiler] + public static void int4_independent_low_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => (rnd.NextUInt4().xy & 255)); + r_test(() => (rnd.NextUInt4().xz & 255)); + r_test(() => (rnd.NextUInt4().xw & 255)); + r_test(() => (rnd.NextUInt4().yz & 255)); + r_test(() => (rnd.NextUInt4().yw & 255)); + r_test(() => (rnd.NextUInt4().zw & 255)); + } + + [TestCompiler] + public static void int4_independent_high_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => ((uint2)rnd.NextUInt4().xy >> 24)); + r_test(() => ((uint2)rnd.NextUInt4().xz >> 24)); + r_test(() => ((uint2)rnd.NextUInt4().xw >> 24)); + r_test(() => ((uint2)rnd.NextUInt4().yz >> 24)); + r_test(() => ((uint2)rnd.NextUInt4().yw >> 24)); + r_test(() => ((uint2)rnd.NextUInt4().zw >> 24)); + } + + + [TestCompiler] + public static void uint_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextUInt() & 255u) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void uint_uniform_high_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextUInt() >> 24) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void uint_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + uint max = 17; + ks_test((() => (rnd.NextUInt(max) + 0.5) / max), (int)max); + } + + [TestCompiler] + public static void uint_uniform_max_limit() + { + var rnd = new Random(0x6E624EB7u); + uint max = 0xFFFFFFFF; + ks_test((() => (rnd.NextUInt(max) + 0.5) / max), 256); + } + + [TestCompiler] + public static void uint_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + uint min = 3; + uint max = 17; + uint range = max - min; + ks_test((() => (range_check(rnd.NextUInt(min, max), min, max) + 0.5 - min) / range), (int)range); + } + + [TestCompiler] + public static void uint_uniform_min_max_limit() + { + var rnd = new Random(0x6E624EB7u); + uint max = 0xFFFFFFFF; + ks_test((() => (range_check(rnd.NextUInt(0, max), 0, max) + 0.5) / max), 256); + } + + [TestCompiler] + public static void uint2_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextUInt2().x & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt2().y & 255u) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void uint2_uniform_high_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextUInt2().x >> 24) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt2().y >> 24) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void uint2_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + uint2 max = uint2(13, 17); + ks_test((() => (rnd.NextUInt2(max).x + 0.5) / max.x), (int)max.x); + ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max.y), (int)max.y); + } + + [TestCompiler] + public static void uint2_uniform_max_limit() + { + var rnd = new Random(0x6E624EB7u); + uint max = 0xFFFFFFFF; + ks_test((() => (rnd.NextUInt2(max).x + 0.5) / max), 256); + ks_test((() => (rnd.NextUInt2(max).y + 0.5) / max), 256); + } + + [TestCompiler] + public static void uint2_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + uint2 min = uint2(3, 101); + uint2 max = uint2(17, 117); + uint2 range = max - min; + ks_test((() => (range_check(rnd.NextUInt2(min, max).x, min.x, max.x) + 0.5 - min.x) / range.x), (int)range.x); + ks_test((() => (range_check(rnd.NextUInt2(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), (int)range.y); + } + + [TestCompiler] + public static void uint2_uniform_min_max_limit() + { + var rnd = new Random(0x6E624EB7u); + uint max = 0xFFFFFFFF; + ks_test((() => (range_check(rnd.NextUInt2(0, max).x, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextUInt2(0, max).y, 0, max) + 0.5) / max), 256); + } + + [TestCompiler] + public static void uint2_independent_low_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => (rnd.NextUInt2().xy & 255)); + } + + [TestCompiler] + public static void uint2_independent_high_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => (rnd.NextUInt2().xy >> 24)); + } + + [TestCompiler] + public static void uint3_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextUInt3().x & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt3().y & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt3().z & 255u) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void uint3_uniform_high_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextUInt3().x >> 24) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt3().y >> 24) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt3().z >> 24) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void uint3_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + uint3 max = uint3(13, 17, 19); + ks_test((() => (rnd.NextUInt3(max).x + 0.5) / max.x), (int)max.x); + ks_test((() => (rnd.NextUInt3(max).y + 0.5) / max.y), (int)max.y); + ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max.z), (int)max.z); + } + + [TestCompiler] + public static void uint3_uniform_max_limit() + { + var rnd = new Random(0x6E624EB7u); + uint max = 0xFFFFFFFF; + ks_test((() => (rnd.NextUInt3(max).x + 0.5) / max), 256); + ks_test((() => (rnd.NextUInt3(max).y + 0.5) / max), 256); + ks_test((() => (rnd.NextUInt3(max).z + 0.5) / max), 256); + } + + [TestCompiler] + public static void uint3_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + uint3 min = uint3(3, 101, 0xFFFFFFF0); + uint3 max = uint3(17, 117, 0xFFFFFFFF); + uint3 range = max - min; + ks_test((() => (range_check(rnd.NextUInt3(min, max).x, min.x, max.x) + 0.5 - min.x) / range.x), (int)range.x); + ks_test((() => (range_check(rnd.NextUInt3(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), (int)range.y); + ks_test((() => (range_check(rnd.NextUInt3(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), (int)range.z); + } + + [TestCompiler] + public static void uint3_uniform_min_max_limit() + { + var rnd = new Random(0x6E624EB7u); + uint max = 0xFFFFFFFF; + ks_test((() => (range_check(rnd.NextUInt3(0, max).x, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextUInt3(0, max).y, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextUInt3(0, max).z, 0, max) + 0.5) / max), 256); + } + + [TestCompiler] + public static void uint3_independent_low_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => (rnd.NextUInt3().xy & 255)); + r_test(() => (rnd.NextUInt3().xz & 255)); + r_test(() => (rnd.NextUInt3().yz & 255)); + } + + [TestCompiler] + public static void uint3_independent_high_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => (rnd.NextUInt3().xy >> 24)); + r_test(() => (rnd.NextUInt3().xz >> 24)); + r_test(() => (rnd.NextUInt3().yz >> 24)); + } + + [TestCompiler] + public static void uint4_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextUInt4().x & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt4().y & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt4().z & 255u) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt4().w & 255u) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void uint4_uniform_high_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => ((rnd.NextUInt4().x >> 24) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt4().y >> 24) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt4().z >> 24) + 0.5) / 256.0), 256); + ks_test((() => ((rnd.NextUInt4().w >> 24) + 0.5) / 256.0), 256); + } + + [TestCompiler] + public static void uint4_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + uint4 max = uint4(13, 17, 19, 23); + ks_test((() => (rnd.NextUInt4(max).x + 0.5) / max.x), (int)max.x); + ks_test((() => (rnd.NextUInt4(max).y + 0.5) / max.y), (int)max.y); + ks_test((() => (rnd.NextUInt4(max).z + 0.5) / max.z), (int)max.z); + ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max.w), (int)max.w); + } + + [TestCompiler] + public static void uint4_uniform_max_limit() + { + var rnd = new Random(0x6E624EB7u); + uint max = 0xFFFFFFFF; + ks_test((() => (rnd.NextUInt4(max).x + 0.5) / max), 256); + ks_test((() => (rnd.NextUInt4(max).y + 0.5) / max), 256); + ks_test((() => (rnd.NextUInt4(max).z + 0.5) / max), 256); + ks_test((() => (rnd.NextUInt4(max).w + 0.5) / max), 256); + } + + [TestCompiler] + public static void uint4_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + uint4 min = uint4(3, 101, 0xFFFFFFF0, 100); + uint4 max = uint4(17, 117, 0xFFFFFFFF, 1000); + uint4 range = max - min; + ks_test((() => (range_check(rnd.NextUInt4(min, max).x, min.x, max.x) + 0.5 - min.x) / range.x), (int)range.x); + ks_test((() => (range_check(rnd.NextUInt4(min, max).y, min.y, max.y) + 0.5 - min.y) / range.y), (int)range.y); + ks_test((() => (range_check(rnd.NextUInt4(min, max).z, min.z, max.z) + 0.5 - min.z) / range.z), (int)range.z); + ks_test((() => (range_check(rnd.NextUInt4(min, max).w, min.w, max.w) + 0.5 - min.w) / range.w), (int)range.w); + } + + [TestCompiler] + public static void uint4_uniform_min_max_limit() + { + var rnd = new Random(0x6E624EB7u); + uint max = 0xFFFFFFFF; + ks_test((() => (range_check(rnd.NextUInt4(0, max).x, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextUInt4(0, max).y, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextUInt4(0, max).z, 0, max) + 0.5) / max), 256); + ks_test((() => (range_check(rnd.NextUInt4(0, max).w, 0, max) + 0.5) / max), 256); + } + + [TestCompiler] + public static void uint4_independent_low_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => (rnd.NextUInt4().xy & 255)); + r_test(() => (rnd.NextUInt4().xz & 255)); + r_test(() => (rnd.NextUInt4().xw & 255)); + r_test(() => (rnd.NextUInt4().yz & 255)); + r_test(() => (rnd.NextUInt4().yw & 255)); + r_test(() => (rnd.NextUInt4().zw & 255)); + } + + [TestCompiler] + public static void uint4_independent_high_bits() + { + var rnd = new Random(0x6E624EB7u); + r_test(() => (rnd.NextUInt4().xy >> 24)); + r_test(() => (rnd.NextUInt4().xz >> 24)); + r_test(() => (rnd.NextUInt4().xw >> 24)); + r_test(() => (rnd.NextUInt4().yz >> 24)); + r_test(() => (rnd.NextUInt4().yw >> 24)); + r_test(() => (rnd.NextUInt4().zw >> 24)); + } + + [TestCompiler] + public static void float_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => range_check01(rnd.NextFloat()))); + } + + [TestCompiler] + public static void float_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => frac(rnd.NextFloat() * 65536.0f))); + } + + [TestCompiler] + public static void float_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + float max = 16.4f; + ks_test((() => range_check(rnd.NextFloat(max), 0.0f, max) / max)); + } + + [TestCompiler] + public static void float_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + float min = -3.1f; + float max = 16.4f; + float range = max - min; + ks_test((() => (range_check(rnd.NextFloat(min, max), min, max) -min) / range)); + } + + [TestCompiler] + public static void float2_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => range_check01(rnd.NextFloat2().x))); + ks_test((() => range_check01(rnd.NextFloat2().y))); + } + + [TestCompiler] + public static void float2_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => frac(rnd.NextFloat2().x * 65536.0f))); + ks_test((() => frac(rnd.NextFloat2().y * 65536.0f))); + } + + [TestCompiler] + public static void float2_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + float2 max = float2(16.4f, 1001.33333333f); + ks_test((() => range_check(rnd.NextFloat2(max).x, 0.0f, max.x) / max.x)); + ks_test((() => range_check(rnd.NextFloat2(max).y, 0.0f, max.y) / max.y)); + } + + [TestCompiler] + public static void float2_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + float2 min = float2(-3.1f, 17.1f); + float2 max = float2(16.4f, 1001.33333333f); + float2 range = max - min; + ks_test((() => (range_check(rnd.NextFloat2(min, max).x, min.x, max.x) - min.x) / range.x)); + ks_test((() => (range_check(rnd.NextFloat2(min, max).y, min.y, max.y) - min.y) / range.y)); + } + + [TestCompiler] + public static void float2_independent() + { + var rnd = new Random(0x6E624EB7u); + r_test((() => rnd.NextFloat2())); + } + + [TestCompiler] + public static void float3_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => range_check01(rnd.NextFloat3().x))); + ks_test((() => range_check01(rnd.NextFloat3().y))); + ks_test((() => range_check01(rnd.NextFloat3().z))); + } + + [TestCompiler] + public static void float3_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => frac(rnd.NextFloat3().x * 65536.0f))); + ks_test((() => frac(rnd.NextFloat3().y * 65536.0f))); + ks_test((() => frac(rnd.NextFloat3().z * 65536.0f))); + } + + [TestCompiler] + public static void float3_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + float3 max = float3(16.4f, 1001.33333333f, 3.121f); + ks_test((() => range_check(rnd.NextFloat3(max).x, 0.0f, max.x) / max.x)); + ks_test((() => range_check(rnd.NextFloat3(max).y, 0.0f, max.y) / max.y)); + ks_test((() => range_check(rnd.NextFloat3(max).z, 0.0f, max.z) / max.z)); + } + + [TestCompiler] + public static void float3_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + float3 min = float3(-3.1f, 17.1f, -0.3f); + float3 max = float3(16.4f, 1001.33333333f, 3.121f); + float3 range = max - min; + ks_test((() => (range_check(rnd.NextFloat3(min, max).x, min.x, max.x) - min.x) / range.x)); + ks_test((() => (range_check(rnd.NextFloat3(min, max).y, min.y, max.y) - min.y) / range.y)); + ks_test((() => (range_check(rnd.NextFloat3(min, max).z, min.z, max.z) - min.z) / range.z)); + } + + [TestCompiler] + public static void float3_independent() + { + var rnd = new Random(0x6E624EB7u); + r_test((() => rnd.NextFloat3().xy)); + r_test((() => rnd.NextFloat3().xz)); + r_test((() => rnd.NextFloat3().yz)); + } + + [TestCompiler] + public static void float4_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => range_check01(rnd.NextFloat4().x))); + ks_test((() => range_check01(rnd.NextFloat4().y))); + ks_test((() => range_check01(rnd.NextFloat4().z))); + ks_test((() => range_check01(rnd.NextFloat4().w))); + } + + [TestCompiler] + public static void float4_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => frac(rnd.NextFloat4().x * 65536.0f))); + ks_test((() => frac(rnd.NextFloat4().y * 65536.0f))); + ks_test((() => frac(rnd.NextFloat4().z * 65536.0f))); + ks_test((() => frac(rnd.NextFloat4().w * 65536.0f))); + } + + [TestCompiler] + public static void float4_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + float4 max = float4(16.4f, 1001.33333333f, 3.121f, 1.3232e23f); + ks_test((() => range_check(rnd.NextFloat4(max).x, 0.0f, max.x) / max.x)); + ks_test((() => range_check(rnd.NextFloat4(max).y, 0.0f, max.y) / max.y)); + ks_test((() => range_check(rnd.NextFloat4(max).z, 0.0f, max.z) / max.z)); + ks_test((() => range_check(rnd.NextFloat4(max).w, 0.0f, max.w) / max.w)); + } + + [TestCompiler] + public static void float4_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + float4 min = float4(-3.1f, 17.1f, -0.3f, -22.6f); + float4 max = float4(16.4f, 1001.33333333f, 3.121f, 1.3232e23f); + float4 range = max - min; + ks_test((() => (range_check(rnd.NextFloat4(min, max).x, min.x, max.x) - min.x) / range.x)); + ks_test((() => (range_check(rnd.NextFloat4(min, max).y, min.y, max.y) - min.y) / range.y)); + ks_test((() => (range_check(rnd.NextFloat4(min, max).z, min.z, max.z) - min.z) / range.z)); + ks_test((() => (range_check(rnd.NextFloat4(min, max).w, min.w, max.w) - min.w) / range.w)); + } + + [TestCompiler] + public static void float4_independent() + { + var rnd = new Random(0x6E624EB7u); + r_test((() => rnd.NextFloat4().xy)); + r_test((() => rnd.NextFloat4().xz)); + r_test((() => rnd.NextFloat4().xw)); + r_test((() => rnd.NextFloat4().yz)); + r_test((() => rnd.NextFloat4().yw)); + r_test((() => rnd.NextFloat4().zw)); + } + + [TestCompiler] + public static void double_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => range_check01(rnd.NextDouble()))); + } + + [TestCompiler] + public static void double_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => frac(rnd.NextDouble() * 35184372088832.0))); + } + + [TestCompiler] + public static void double_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + double max = 16.4; + ks_test((() => range_check(rnd.NextDouble(max), 0.0, max) / max)); + } + + [TestCompiler] + public static void double_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + double min = -3.1; + double max = 16.4; + double range = max - min; + ks_test((() => (range_check(rnd.NextDouble(min, max), min, max) - min) / range)); + } + + [TestCompiler] + public static void double2_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => range_check01(rnd.NextDouble2().x))); + ks_test((() => range_check01(rnd.NextDouble2().y))); + } + + [TestCompiler] + public static void double2_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => frac(rnd.NextDouble2().x * 35184372088832.0))); + ks_test((() => frac(rnd.NextDouble2().y * 35184372088832.0))); + } + + [TestCompiler] + public static void double2_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + double2 max = double2(16.4, 1001.33333333); + ks_test((() => range_check(rnd.NextDouble2(max).x, 0.0, max.x) / max.x)); + ks_test((() => range_check(rnd.NextDouble2(max).y, 0.0, max.y) / max.y)); + } + + [TestCompiler] + public static void double2_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + double2 min = double2(-3.1, 17.1); + double2 max = double2(16.4, 1001.33333333); + double2 range = max - min; + ks_test((() => (range_check(rnd.NextDouble2(min, max).x, min.x, max.x) - min.x) / range.x)); + ks_test((() => (range_check(rnd.NextDouble2(min, max).y, min.y, max.y) - min.y) / range.y)); + } + + [TestCompiler] + public static void double2_independent() + { + var rnd = new Random(0x6E624EB7u); + r_test((() => rnd.NextDouble2())); + } + + [TestCompiler] + public static void double3_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => range_check01(rnd.NextDouble3().x))); + ks_test((() => range_check01(rnd.NextDouble3().y))); + ks_test((() => range_check01(rnd.NextDouble3().z))); + } + + [TestCompiler] + public static void double3_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => frac(rnd.NextDouble3().x * 35184372088832.0))); + ks_test((() => frac(rnd.NextDouble3().y * 35184372088832.0))); + ks_test((() => frac(rnd.NextDouble3().z * 35184372088832.0))); + } + + [TestCompiler] + public static void double3_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + double3 max = double3(16.4, 1001.33333333, 3.121); + ks_test((() => range_check(rnd.NextDouble3(max).x, 0.0, max.x) / max.x)); + ks_test((() => range_check(rnd.NextDouble3(max).y, 0.0, max.y) / max.y)); + ks_test((() => range_check(rnd.NextDouble3(max).z, 0.0, max.z) / max.z)); + } + + [TestCompiler] + public static void double3_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + double3 min = double3(-3.1, 17.1, -0.3); + double3 max = double3(16.4, 1001.33333333, 3.121); + double3 range = max - min; + ks_test((() => (range_check(rnd.NextDouble3(min, max).x, min.x, max.x) - min.x) / range.x)); + ks_test((() => (range_check(rnd.NextDouble3(min, max).y, min.y, max.y) - min.y) / range.y)); + ks_test((() => (range_check(rnd.NextDouble3(min, max).z, min.z, max.z) - min.z) / range.z)); + } + + + [TestCompiler] + public static void double3_independent() + { + var rnd = new Random(0x6E624EB7u); + r_test((() => rnd.NextDouble3().xy)); + r_test((() => rnd.NextDouble3().xz)); + r_test((() => rnd.NextDouble3().yz)); + } + + [TestCompiler] + public static void double4_uniform() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => range_check01(rnd.NextDouble4().x))); + ks_test((() => range_check01(rnd.NextDouble4().y))); + ks_test((() => range_check01(rnd.NextDouble4().z))); + ks_test((() => range_check01(rnd.NextDouble4().w))); + } + + [TestCompiler] + public static void double4_uniform_low_bits() + { + var rnd = new Random(0x6E624EB7u); + ks_test((() => frac(rnd.NextDouble4().x * 35184372088832.0))); + ks_test((() => frac(rnd.NextDouble4().y * 35184372088832.0))); + ks_test((() => frac(rnd.NextDouble4().z * 35184372088832.0))); + ks_test((() => frac(rnd.NextDouble4().w * 35184372088832.0))); + } + + [TestCompiler] + public static void double4_uniform_max() + { + var rnd = new Random(0x6E624EB7u); + double4 max = double4(16.4f, 1001.33333333f, 3.121f, 1.3232e23f); + ks_test((() => range_check(rnd.NextDouble4(max).x, 0.0, max.x) / max.x)); + ks_test((() => range_check(rnd.NextDouble4(max).y, 0.0, max.y) / max.y)); + ks_test((() => range_check(rnd.NextDouble4(max).z, 0.0, max.z) / max.z)); + ks_test((() => range_check(rnd.NextDouble4(max).w, 0.0, max.w) / max.w)); + } + + [TestCompiler] + public static void double4_uniform_min_max() + { + var rnd = new Random(0x6E624EB7u); + double4 min = double4(-3.1, 17.1, -0.3, -22.6); + double4 max = double4(16.4, 1001.33333333, 3.121, 1.3232e23); + double4 range = max - min; + ks_test((() => (range_check(rnd.NextDouble4(min, max).x, min.x, max.x) - min.x) / range.x)); + ks_test((() => (range_check(rnd.NextDouble4(min, max).y, min.y, max.y) - min.y) / range.y)); + ks_test((() => (range_check(rnd.NextDouble4(min, max).z, min.z, max.z) - min.z) / range.z)); + ks_test((() => (range_check(rnd.NextDouble4(min, max).w, min.w, max.w) - min.w) / range.w)); + } + + [TestCompiler] + public static void double4_independent() + { + var rnd = new Random(0x6E624EB7u); + r_test((() => rnd.NextDouble4().xy)); + r_test((() => rnd.NextDouble4().xz)); + r_test((() => rnd.NextDouble4().xw)); + r_test((() => rnd.NextDouble4().yz)); + r_test((() => rnd.NextDouble4().yw)); + r_test((() => rnd.NextDouble4().zw)); + } + + [TestCompiler] + public static void float2_direction() + { + var rnd = new Random(0x6E624EB7u); + ks_test(() => { + float2 dir = rnd.NextFloat2Direction(); + TestUtils.AreEqual(1.0f, length(dir), 0.001f); + return atan2(dir.x, dir.y) / (2.0f * PI) + 0.5f; + }); + } + + [TestCompiler] + public static void double2_direction() + { + var rnd = new Random(0x6E624EB7u); + ks_test(() => { + double2 dir = rnd.NextFloat2Direction(); + TestUtils.AreEqual(1.0, length(dir), 0.000001); + return atan2(dir.y, dir.x) / (2.0 * PI_DBL) + 0.5; + }); + } + + + [TestCompiler] + public static void float3_direction() + { + var rnd = new Random(0x6E624EB7u); + ks_test(() => + { + float3 dir = rnd.NextFloat3Direction(); + float r = length(dir); + TestUtils.AreEqual(1.0f, r, 0.001f); + + float phi = atan2(dir.y, dir.x) / (2.0f * PI) + 0.5f; + float z = saturate(dir.z / r * 0.5f + 0.5f); + return double2(phi, z); + }); + } + + [TestCompiler] + public static void double3_direction() + { + var rnd = new Random(0x6E624EB7u); + ks_test(() => + { + double3 dir = rnd.NextDouble3Direction(); + double r = length(dir); + TestUtils.AreEqual(1.0, r, 0.00001); + + double phi = atan2(dir.y, dir.x) / (2.0 * PI_DBL) + 0.5; + double z = saturate(dir.z / r * 0.5 + 0.5); + return double2(phi, z); + }); + } + + [TestCompiler] + public static void quaternion_rotation() + { + var rnd = new Random(0x6E624EB7u); + ks_test(() => + { + quaternion q = rnd.NextQuaternionRotation(); + TestUtils.AreEqual(1.0, dot(q, q), 0.00001f); + Assert.GreaterOrEqual(q.value.w, 0.0f); + float3 p = float3(1.0f, 2.0f, 3.0f); + + float3 qp = mul(q, p); + + TestUtils.AreEqual(length(p), length(qp), 0.0001f); + float r = length(qp); + + double phi = atan2(qp.y, qp.x) / (2.0 * PI_DBL) + 0.5; + double z = saturate(qp.z / r * 0.5 + 0.5); + return double2(phi, z); + }); + } + } +} 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/TestRandom.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/TestRandom.cs.meta new file mode 100644 index 0000000000000000000000000000000000000000..6578db1a174d6b33cba80e0b1ef09826a3a8b227 --- /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/TestRandom.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: ec2e0d8c659a52a45b0bd4f7a3d3981a +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/Unity.Mathematics/Noise/README b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/README new file mode 100644 index 0000000000000000000000000000000000000000..68f441f2bb71a464a01822e6453f48b42398f3e0 --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/README @@ -0,0 +1,16 @@ +These files contain noise functions that are compatible with all +current versions of GLSL (1.20 and up), and all you need to use them +is provided in the source file. There is no external data, and no +setup procedure. Just cut and paste and call the function. + +GLSL has a very rudimentary linker, so some helper functions are +included in several of the files with the same name. If you want to +use more than one of these functions in the same shader, you may run +into problems with redefinition of the functions mod289() and permute(). +If that happens, just delete any superfluous definitions. + +----- + +Source: https://github.com/ashima/webgl-noise +Changes: + - 10 April 2018, Unity Technologies, Ported to HPC# diff --git a/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/README.meta b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/README.meta new file mode 100644 index 0000000000000000000000000000000000000000..16c0ea9d3c86760a1c6ff934297f0bb499de657b --- /dev/null +++ b/benchmark/NYU_CTF_Bench/test/2022/CSAW-Quals/rev/AnyaGacha/src/client/Library/PackageCache/com.unity.mathematics@1.1.0/Unity.Mathematics/Noise/README.meta @@ -0,0 +1,7 @@ +fileFormatVersion: 2 +guid: 16687ba1ea1804a9fb7cb7c2410eab23 +DefaultImporter: + externalObjects: {} + userData: + assetBundleName: + assetBundleVariant: