diff --git a/.gitignore b/.gitignore index 4ed3ed8..81e546e 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,4 @@ /fceux-am /nvboard /am-kernels +**/.cache diff --git a/abstract-machine/.cache/clangd/index/am.h.A4EACDA3FFE8E991.idx b/abstract-machine/.cache/clangd/index/am.h.A4EACDA3FFE8E991.idx deleted file mode 100644 index bec9f40..0000000 Binary files a/abstract-machine/.cache/clangd/index/am.h.A4EACDA3FFE8E991.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/amdev.h.CED3274D6110AE08.idx b/abstract-machine/.cache/clangd/index/amdev.h.CED3274D6110AE08.idx deleted file mode 100644 index 826f18e..0000000 Binary files a/abstract-machine/.cache/clangd/index/amdev.h.CED3274D6110AE08.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/audio.c.CC9C4D1C2C767072.idx b/abstract-machine/.cache/clangd/index/audio.c.CC9C4D1C2C767072.idx deleted file mode 100644 index b7ffe81..0000000 Binary files a/abstract-machine/.cache/clangd/index/audio.c.CC9C4D1C2C767072.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/cpp.c.0997979504A7309C.idx b/abstract-machine/.cache/clangd/index/cpp.c.0997979504A7309C.idx deleted file mode 100644 index caa5297..0000000 Binary files a/abstract-machine/.cache/clangd/index/cpp.c.0997979504A7309C.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/cte.c.15ADB982FFA62EFA.idx b/abstract-machine/.cache/clangd/index/cte.c.15ADB982FFA62EFA.idx deleted file mode 100644 index 6a0f1d5..0000000 Binary files a/abstract-machine/.cache/clangd/index/cte.c.15ADB982FFA62EFA.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/disk.c.2126A5215FB353A4.idx b/abstract-machine/.cache/clangd/index/disk.c.2126A5215FB353A4.idx deleted file mode 100644 index 0b293f6..0000000 Binary files a/abstract-machine/.cache/clangd/index/disk.c.2126A5215FB353A4.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/gpu.c.892C4F545984B680.idx b/abstract-machine/.cache/clangd/index/gpu.c.892C4F545984B680.idx deleted file mode 100644 index ac4a6da..0000000 Binary files a/abstract-machine/.cache/clangd/index/gpu.c.892C4F545984B680.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/input.c.261BA2591BDB382F.idx b/abstract-machine/.cache/clangd/index/input.c.261BA2591BDB382F.idx deleted file mode 100644 index 2815c0e..0000000 Binary files a/abstract-machine/.cache/clangd/index/input.c.261BA2591BDB382F.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/int64.c.CD49DDA5E3516884.idx b/abstract-machine/.cache/clangd/index/int64.c.CD49DDA5E3516884.idx deleted file mode 100644 index 1cb2004..0000000 Binary files a/abstract-machine/.cache/clangd/index/int64.c.CD49DDA5E3516884.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/ioe.c.E16910D721F00C2C.idx b/abstract-machine/.cache/clangd/index/ioe.c.E16910D721F00C2C.idx deleted file mode 100644 index 71b75e1..0000000 Binary files a/abstract-machine/.cache/clangd/index/ioe.c.E16910D721F00C2C.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/klib-macros.h.B800A13CFCD5D615.idx b/abstract-machine/.cache/clangd/index/klib-macros.h.B800A13CFCD5D615.idx deleted file mode 100644 index 38518d6..0000000 Binary files a/abstract-machine/.cache/clangd/index/klib-macros.h.B800A13CFCD5D615.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/klib.h.B932C5DE116ED988.idx b/abstract-machine/.cache/clangd/index/klib.h.B932C5DE116ED988.idx deleted file mode 100644 index 69ea042..0000000 Binary files a/abstract-machine/.cache/clangd/index/klib.h.B932C5DE116ED988.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/mpe.c.3D916D1C86ED9B7A.idx b/abstract-machine/.cache/clangd/index/mpe.c.3D916D1C86ED9B7A.idx deleted file mode 100644 index c650205..0000000 Binary files a/abstract-machine/.cache/clangd/index/mpe.c.3D916D1C86ED9B7A.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/native.h.28E399D158114ED9.idx b/abstract-machine/.cache/clangd/index/native.h.28E399D158114ED9.idx deleted file mode 100644 index 8e36d7e..0000000 Binary files a/abstract-machine/.cache/clangd/index/native.h.28E399D158114ED9.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/platform.c.BA0A6D5AC2C4C4A9.idx b/abstract-machine/.cache/clangd/index/platform.c.BA0A6D5AC2C4C4A9.idx deleted file mode 100644 index b073947..0000000 Binary files a/abstract-machine/.cache/clangd/index/platform.c.BA0A6D5AC2C4C4A9.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/platform.h.CF499A89AF71A47D.idx b/abstract-machine/.cache/clangd/index/platform.h.CF499A89AF71A47D.idx deleted file mode 100644 index 5e4a88d..0000000 Binary files a/abstract-machine/.cache/clangd/index/platform.h.CF499A89AF71A47D.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/stdio.c.4CCE235847DC4ACF.idx b/abstract-machine/.cache/clangd/index/stdio.c.4CCE235847DC4ACF.idx deleted file mode 100644 index 5d59d0c..0000000 Binary files a/abstract-machine/.cache/clangd/index/stdio.c.4CCE235847DC4ACF.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/stdlib.c.BDA9DBD681BB43AE.idx b/abstract-machine/.cache/clangd/index/stdlib.c.BDA9DBD681BB43AE.idx deleted file mode 100644 index 3f34709..0000000 Binary files a/abstract-machine/.cache/clangd/index/stdlib.c.BDA9DBD681BB43AE.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/string.c.8CBA579FC3418125.idx b/abstract-machine/.cache/clangd/index/string.c.8CBA579FC3418125.idx deleted file mode 100644 index 0593987..0000000 Binary files a/abstract-machine/.cache/clangd/index/string.c.8CBA579FC3418125.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/timer.c.9671737A8A895CE0.idx b/abstract-machine/.cache/clangd/index/timer.c.9671737A8A895CE0.idx deleted file mode 100644 index 3c6116a..0000000 Binary files a/abstract-machine/.cache/clangd/index/timer.c.9671737A8A895CE0.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/trap.S.B4DD7625DCFCA6BD.idx b/abstract-machine/.cache/clangd/index/trap.S.B4DD7625DCFCA6BD.idx deleted file mode 100644 index f0a7976..0000000 Binary files a/abstract-machine/.cache/clangd/index/trap.S.B4DD7625DCFCA6BD.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/trm.c.FF7A4AD075B0A551.idx b/abstract-machine/.cache/clangd/index/trm.c.FF7A4AD075B0A551.idx deleted file mode 100644 index eb80f9a..0000000 Binary files a/abstract-machine/.cache/clangd/index/trm.c.FF7A4AD075B0A551.idx and /dev/null differ diff --git a/abstract-machine/.cache/clangd/index/vme.c.F922A9D30D484DF9.idx b/abstract-machine/.cache/clangd/index/vme.c.F922A9D30D484DF9.idx deleted file mode 100644 index 714ab1c..0000000 Binary files a/abstract-machine/.cache/clangd/index/vme.c.F922A9D30D484DF9.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/am.h.A4EACDA3FFE8E991.idx b/abstract-machine/am/.cache/clangd/index/am.h.A4EACDA3FFE8E991.idx deleted file mode 100644 index 02d2e71..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/am.h.A4EACDA3FFE8E991.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/amdev.h.CED3274D6110AE08.idx b/abstract-machine/am/.cache/clangd/index/amdev.h.CED3274D6110AE08.idx deleted file mode 100644 index 55f6ae8..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/amdev.h.CED3274D6110AE08.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/audio.c.CC9C4D1C2C767072.idx b/abstract-machine/am/.cache/clangd/index/audio.c.CC9C4D1C2C767072.idx deleted file mode 100644 index 2eb8c44..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/audio.c.CC9C4D1C2C767072.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/cte.c.15ADB982FFA62EFA.idx b/abstract-machine/am/.cache/clangd/index/cte.c.15ADB982FFA62EFA.idx deleted file mode 100644 index 337d721..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/cte.c.15ADB982FFA62EFA.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/disk.c.2126A5215FB353A4.idx b/abstract-machine/am/.cache/clangd/index/disk.c.2126A5215FB353A4.idx deleted file mode 100644 index 5e47ba4..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/disk.c.2126A5215FB353A4.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/gpu.c.892C4F545984B680.idx b/abstract-machine/am/.cache/clangd/index/gpu.c.892C4F545984B680.idx deleted file mode 100644 index ed8c7b6..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/gpu.c.892C4F545984B680.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/input.c.261BA2591BDB382F.idx b/abstract-machine/am/.cache/clangd/index/input.c.261BA2591BDB382F.idx deleted file mode 100644 index 90455d1..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/input.c.261BA2591BDB382F.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/ioe.c.E16910D721F00C2C.idx b/abstract-machine/am/.cache/clangd/index/ioe.c.E16910D721F00C2C.idx deleted file mode 100644 index 03ea9b2..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/ioe.c.E16910D721F00C2C.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/mpe.c.3D916D1C86ED9B7A.idx b/abstract-machine/am/.cache/clangd/index/mpe.c.3D916D1C86ED9B7A.idx deleted file mode 100644 index 96e2f54..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/mpe.c.3D916D1C86ED9B7A.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/platform.c.BA0A6D5AC2C4C4A9.idx b/abstract-machine/am/.cache/clangd/index/platform.c.BA0A6D5AC2C4C4A9.idx deleted file mode 100644 index 7447300..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/platform.c.BA0A6D5AC2C4C4A9.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/platform.h.CF499A89AF71A47D.idx b/abstract-machine/am/.cache/clangd/index/platform.h.CF499A89AF71A47D.idx deleted file mode 100644 index 5593660..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/platform.h.CF499A89AF71A47D.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/timer.c.9671737A8A895CE0.idx b/abstract-machine/am/.cache/clangd/index/timer.c.9671737A8A895CE0.idx deleted file mode 100644 index 9ed1a6a..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/timer.c.9671737A8A895CE0.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/trap.S.B4DD7625DCFCA6BD.idx b/abstract-machine/am/.cache/clangd/index/trap.S.B4DD7625DCFCA6BD.idx deleted file mode 100644 index 664d0c2..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/trap.S.B4DD7625DCFCA6BD.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/trm.c.FF7A4AD075B0A551.idx b/abstract-machine/am/.cache/clangd/index/trm.c.FF7A4AD075B0A551.idx deleted file mode 100644 index 29b9094..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/trm.c.FF7A4AD075B0A551.idx and /dev/null differ diff --git a/abstract-machine/am/.cache/clangd/index/vme.c.F922A9D30D484DF9.idx b/abstract-machine/am/.cache/clangd/index/vme.c.F922A9D30D484DF9.idx deleted file mode 100644 index 6029e91..0000000 Binary files a/abstract-machine/am/.cache/clangd/index/vme.c.F922A9D30D484DF9.idx and /dev/null differ diff --git a/am-kernels b/am-kernels deleted file mode 160000 index bb725d6..0000000 --- a/am-kernels +++ /dev/null @@ -1 +0,0 @@ -Subproject commit bb725d6f8223dd7de831c3b692e8c4531e9d01af diff --git a/am-kernels/.direnv/flake-profile b/am-kernels/.direnv/flake-profile new file mode 120000 index 0000000..92d9866 --- /dev/null +++ b/am-kernels/.direnv/flake-profile @@ -0,0 +1 @@ +flake-profile-79-link \ No newline at end of file diff --git a/am-kernels/.direnv/flake-profile-79-link b/am-kernels/.direnv/flake-profile-79-link new file mode 120000 index 0000000..018b72a --- /dev/null +++ b/am-kernels/.direnv/flake-profile-79-link @@ -0,0 +1 @@ +/nix/store/jn4rd289315ip9fx03z2dm980wzg4iaz-am-kernels-2024.02.18-env \ No newline at end of file diff --git a/am-kernels/.envrc b/am-kernels/.envrc new file mode 100644 index 0000000..e0dc6df --- /dev/null +++ b/am-kernels/.envrc @@ -0,0 +1 @@ +use flake ..#am-kernels diff --git a/am-kernels/.git.bak/HEAD b/am-kernels/.git.bak/HEAD new file mode 100644 index 0000000..3739032 --- /dev/null +++ b/am-kernels/.git.bak/HEAD @@ -0,0 +1 @@ +ref: refs/heads/ics2021 diff --git a/am-kernels/.git.bak/config b/am-kernels/.git.bak/config new file mode 100644 index 0000000..c6057c1 --- /dev/null +++ b/am-kernels/.git.bak/config @@ -0,0 +1,11 @@ +[core] + repositoryformatversion = 0 + filemode = true + bare = false + logallrefupdates = true +[remote "origin"] + url = git@github.com:NJU-ProjectN/am-kernels.git + fetch = +refs/heads/*:refs/remotes/origin/* +[branch "ics2021"] + remote = origin + merge = refs/heads/ics2021 diff --git a/am-kernels/.git.bak/description b/am-kernels/.git.bak/description new file mode 100644 index 0000000..498b267 --- /dev/null +++ b/am-kernels/.git.bak/description @@ -0,0 +1 @@ +Unnamed repository; edit this file 'description' to name the repository. diff --git a/am-kernels/.git.bak/hooks/applypatch-msg.sample b/am-kernels/.git.bak/hooks/applypatch-msg.sample new file mode 100755 index 0000000..6ca45fa --- /dev/null +++ b/am-kernels/.git.bak/hooks/applypatch-msg.sample @@ -0,0 +1,15 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# An example hook script to check the commit log message taken by +# applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. The hook is +# allowed to edit the commit message file. +# +# To enable this hook, rename this file to "applypatch-msg". + +. git-sh-setup +commitmsg="$(git rev-parse --git-path hooks/commit-msg)" +test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"} +: diff --git a/am-kernels/.git.bak/hooks/commit-msg.sample b/am-kernels/.git.bak/hooks/commit-msg.sample new file mode 100755 index 0000000..17bd0f0 --- /dev/null +++ b/am-kernels/.git.bak/hooks/commit-msg.sample @@ -0,0 +1,24 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# An example hook script to check the commit log message. +# Called by "git commit" with one argument, the name of the file +# that has the commit message. The hook should exit with non-zero +# status after issuing an appropriate message if it wants to stop the +# commit. The hook is allowed to edit the commit message file. +# +# To enable this hook, rename this file to "commit-msg". + +# Uncomment the below to add a Signed-off-by line to the message. +# Doing this in a hook is a bad idea in general, but the prepare-commit-msg +# hook is more suited to it. +# +# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1" + +# This example catches duplicate Signed-off-by lines. + +test "" = "$(grep '^Signed-off-by: ' "$1" | + sort | uniq -c | sed -e '/^[ ]*1[ ]/d')" || { + echo >&2 Duplicate Signed-off-by lines. + exit 1 +} diff --git a/am-kernels/.git.bak/hooks/fsmonitor-watchman.sample b/am-kernels/.git.bak/hooks/fsmonitor-watchman.sample new file mode 100755 index 0000000..9acec1c --- /dev/null +++ b/am-kernels/.git.bak/hooks/fsmonitor-watchman.sample @@ -0,0 +1,174 @@ +#!/nix/store/jr2c1rk91nqlfz5a5lwfq2kyilxzj879-perl-5.38.2/bin/perl + +use strict; +use warnings; +use IPC::Open2; + +# An example hook script to integrate Watchman +# (https://facebook.github.io/watchman/) with git to speed up detecting +# new and modified files. +# +# The hook is passed a version (currently 2) and last update token +# formatted as a string and outputs to stdout a new update token and +# all files that have been modified since the update token. Paths must +# be relative to the root of the working tree and separated by a single NUL. +# +# To enable this hook, rename this file to "query-watchman" and set +# 'git config core.fsmonitor .git/hooks/query-watchman' +# +my ($version, $last_update_token) = @ARGV; + +# Uncomment for debugging +# print STDERR "$0 $version $last_update_token\n"; + +# Check the hook interface version +if ($version ne 2) { + die "Unsupported query-fsmonitor hook version '$version'.\n" . + "Falling back to scanning...\n"; +} + +my $git_work_tree = get_working_dir(); + +my $retry = 1; + +my $json_pkg; +eval { + require JSON::XS; + $json_pkg = "JSON::XS"; + 1; +} or do { + require JSON::PP; + $json_pkg = "JSON::PP"; +}; + +launch_watchman(); + +sub launch_watchman { + my $o = watchman_query(); + if (is_work_tree_watched($o)) { + output_result($o->{clock}, @{$o->{files}}); + } +} + +sub output_result { + my ($clockid, @files) = @_; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # binmode $fh, ":utf8"; + # print $fh "$clockid\n@files\n"; + # close $fh; + + binmode STDOUT, ":utf8"; + print $clockid; + print "\0"; + local $, = "\0"; + print @files; +} + +sub watchman_clock { + my $response = qx/watchman clock "$git_work_tree"/; + die "Failed to get clock id on '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + + return $json_pkg->new->utf8->decode($response); +} + +sub watchman_query { + my $pid = open2(\*CHLD_OUT, \*CHLD_IN, 'watchman -j --no-pretty') + or die "open2() failed: $!\n" . + "Falling back to scanning...\n"; + + # In the query expression below we're asking for names of files that + # changed since $last_update_token but not from the .git folder. + # + # To accomplish this, we're using the "since" generator to use the + # recency index to select candidate nodes and "fields" to limit the + # output to file names only. Then we're using the "expression" term to + # further constrain the results. + my $last_update_line = ""; + if (substr($last_update_token, 0, 1) eq "c") { + $last_update_token = "\"$last_update_token\""; + $last_update_line = qq[\n"since": $last_update_token,]; + } + my $query = <<" END"; + ["query", "$git_work_tree", {$last_update_line + "fields": ["name"], + "expression": ["not", ["dirname", ".git"]] + }] + END + + # Uncomment for debugging the watchman query + # open (my $fh, ">", ".git/watchman-query.json"); + # print $fh $query; + # close $fh; + + print CHLD_IN $query; + close CHLD_IN; + my $response = do {local $/; }; + + # Uncomment for debugging the watch response + # open ($fh, ">", ".git/watchman-response.json"); + # print $fh $response; + # close $fh; + + die "Watchman: command returned no output.\n" . + "Falling back to scanning...\n" if $response eq ""; + die "Watchman: command returned invalid output: $response\n" . + "Falling back to scanning...\n" unless $response =~ /^\{/; + + return $json_pkg->new->utf8->decode($response); +} + +sub is_work_tree_watched { + my ($output) = @_; + my $error = $output->{error}; + if ($retry > 0 and $error and $error =~ m/unable to resolve root .* directory (.*) is not watched/) { + $retry--; + my $response = qx/watchman watch "$git_work_tree"/; + die "Failed to make watchman watch '$git_work_tree'.\n" . + "Falling back to scanning...\n" if $? != 0; + $output = $json_pkg->new->utf8->decode($response); + $error = $output->{error}; + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + # Uncomment for debugging watchman output + # open (my $fh, ">", ".git/watchman-output.out"); + # close $fh; + + # Watchman will always return all files on the first query so + # return the fast "everything is dirty" flag to git and do the + # Watchman query just to get it over with now so we won't pay + # the cost in git to look up each individual file. + my $o = watchman_clock(); + $error = $output->{error}; + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + output_result($o->{clock}, ("/")); + $last_update_token = $o->{clock}; + + eval { launch_watchman() }; + return 0; + } + + die "Watchman: $error.\n" . + "Falling back to scanning...\n" if $error; + + return 1; +} + +sub get_working_dir { + my $working_dir; + if ($^O =~ 'msys' || $^O =~ 'cygwin') { + $working_dir = Win32::GetCwd(); + $working_dir =~ tr/\\/\//; + } else { + require Cwd; + $working_dir = Cwd::cwd(); + } + + return $working_dir; +} diff --git a/am-kernels/.git.bak/hooks/post-update.sample b/am-kernels/.git.bak/hooks/post-update.sample new file mode 100755 index 0000000..65117ca --- /dev/null +++ b/am-kernels/.git.bak/hooks/post-update.sample @@ -0,0 +1,8 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# An example hook script to prepare a packed repository for use over +# dumb transports. +# +# To enable this hook, rename this file to "post-update". + +exec git update-server-info diff --git a/am-kernels/.git.bak/hooks/pre-applypatch.sample b/am-kernels/.git.bak/hooks/pre-applypatch.sample new file mode 100755 index 0000000..581fe7d --- /dev/null +++ b/am-kernels/.git.bak/hooks/pre-applypatch.sample @@ -0,0 +1,14 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# An example hook script to verify what is about to be committed +# by applypatch from an e-mail message. +# +# The hook should exit with non-zero status after issuing an +# appropriate message if it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-applypatch". + +. git-sh-setup +precommit="$(git rev-parse --git-path hooks/pre-commit)" +test -x "$precommit" && exec "$precommit" ${1+"$@"} +: diff --git a/am-kernels/.git.bak/hooks/pre-commit.sample b/am-kernels/.git.bak/hooks/pre-commit.sample new file mode 100755 index 0000000..3302ade --- /dev/null +++ b/am-kernels/.git.bak/hooks/pre-commit.sample @@ -0,0 +1,49 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# An example hook script to verify what is about to be committed. +# Called by "git commit" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message if +# it wants to stop the commit. +# +# To enable this hook, rename this file to "pre-commit". + +if git rev-parse --verify HEAD >/dev/null 2>&1 +then + against=HEAD +else + # Initial commit: diff against an empty tree object + against=$(git hash-object -t tree /dev/null) +fi + +# If you want to allow non-ASCII filenames set this variable to true. +allownonascii=$(git config --type=bool hooks.allownonascii) + +# Redirect output to stderr. +exec 1>&2 + +# Cross platform projects tend to avoid non-ASCII filenames; prevent +# them from being added to the repository. We exploit the fact that the +# printable range starts at the space character and ends with tilde. +if [ "$allownonascii" != "true" ] && + # Note that the use of brackets around a tr range is ok here, (it's + # even required, for portability to Solaris 10's /usr/bin/tr), since + # the square bracket bytes happen to fall in the designated range. + test $(git diff-index --cached --name-only --diff-filter=A -z $against | + LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0 +then + cat <<\EOF +Error: Attempt to add a non-ASCII file name. + +This can cause problems if you want to work with people on other platforms. + +To be portable it is advisable to rename the file. + +If you know what you are doing you can disable this check using: + + git config hooks.allownonascii true +EOF + exit 1 +fi + +# If there are whitespace errors, print the offending file names and fail. +exec git diff-index --check --cached $against -- diff --git a/am-kernels/.git.bak/hooks/pre-merge-commit.sample b/am-kernels/.git.bak/hooks/pre-merge-commit.sample new file mode 100755 index 0000000..11e7022 --- /dev/null +++ b/am-kernels/.git.bak/hooks/pre-merge-commit.sample @@ -0,0 +1,13 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# An example hook script to verify what is about to be committed. +# Called by "git merge" with no arguments. The hook should +# exit with non-zero status after issuing an appropriate message to +# stderr if it wants to stop the merge commit. +# +# To enable this hook, rename this file to "pre-merge-commit". + +. git-sh-setup +test -x "$GIT_DIR/hooks/pre-commit" && + exec "$GIT_DIR/hooks/pre-commit" +: diff --git a/am-kernels/.git.bak/hooks/pre-push.sample b/am-kernels/.git.bak/hooks/pre-push.sample new file mode 100755 index 0000000..b77e5ae --- /dev/null +++ b/am-kernels/.git.bak/hooks/pre-push.sample @@ -0,0 +1,53 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash + +# An example hook script to verify what is about to be pushed. Called by "git +# push" after it has checked the remote status, but before anything has been +# pushed. If this script exits with a non-zero status nothing will be pushed. +# +# This hook is called with the following parameters: +# +# $1 -- Name of the remote to which the push is being done +# $2 -- URL to which the push is being done +# +# If pushing without using a named remote those arguments will be equal. +# +# Information about the commits which are being pushed is supplied as lines to +# the standard input in the form: +# +# +# +# This sample shows how to prevent push of commits where the log message starts +# with "WIP" (work in progress). + +remote="$1" +url="$2" + +zero=$(git hash-object --stdin &2 "Found WIP commit in $local_ref, not pushing" + exit 1 + fi + fi +done + +exit 0 diff --git a/am-kernels/.git.bak/hooks/pre-rebase.sample b/am-kernels/.git.bak/hooks/pre-rebase.sample new file mode 100755 index 0000000..c4272e9 --- /dev/null +++ b/am-kernels/.git.bak/hooks/pre-rebase.sample @@ -0,0 +1,169 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# Copyright (c) 2006, 2008 Junio C Hamano +# +# The "pre-rebase" hook is run just before "git rebase" starts doing +# its job, and can prevent the command from running by exiting with +# non-zero status. +# +# The hook is called with the following parameters: +# +# $1 -- the upstream the series was forked from. +# $2 -- the branch being rebased (or empty when rebasing the current branch). +# +# This sample shows how to prevent topic branches that are already +# merged to 'next' branch from getting rebased, because allowing it +# would result in rebasing already published history. + +publish=next +basebranch="$1" +if test "$#" = 2 +then + topic="refs/heads/$2" +else + topic=`git symbolic-ref HEAD` || + exit 0 ;# we do not interrupt rebasing detached HEAD +fi + +case "$topic" in +refs/heads/??/*) + ;; +*) + exit 0 ;# we do not interrupt others. + ;; +esac + +# Now we are dealing with a topic branch being rebased +# on top of master. Is it OK to rebase it? + +# Does the topic really exist? +git show-ref -q "$topic" || { + echo >&2 "No such branch $topic" + exit 1 +} + +# Is topic fully merged to master? +not_in_master=`git rev-list --pretty=oneline ^master "$topic"` +if test -z "$not_in_master" +then + echo >&2 "$topic is fully merged to master; better remove it." + exit 1 ;# we could allow it, but there is no point. +fi + +# Is topic ever merged to next? If so you should not be rebasing it. +only_next_1=`git rev-list ^master "^$topic" ${publish} | sort` +only_next_2=`git rev-list ^master ${publish} | sort` +if test "$only_next_1" = "$only_next_2" +then + not_in_topic=`git rev-list "^$topic" master` + if test -z "$not_in_topic" + then + echo >&2 "$topic is already up to date with master" + exit 1 ;# we could allow it, but there is no point. + else + exit 0 + fi +else + not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"` + /nix/store/jr2c1rk91nqlfz5a5lwfq2kyilxzj879-perl-5.38.2/bin/perl -e ' + my $topic = $ARGV[0]; + my $msg = "* $topic has commits already merged to public branch:\n"; + my (%not_in_next) = map { + /^([0-9a-f]+) /; + ($1 => 1); + } split(/\n/, $ARGV[1]); + for my $elem (map { + /^([0-9a-f]+) (.*)$/; + [$1 => $2]; + } split(/\n/, $ARGV[2])) { + if (!exists $not_in_next{$elem->[0]}) { + if ($msg) { + print STDERR $msg; + undef $msg; + } + print STDERR " $elem->[1]\n"; + } + } + ' "$topic" "$not_in_next" "$not_in_master" + exit 1 +fi + +<<\DOC_END + +This sample hook safeguards topic branches that have been +published from being rewound. + +The workflow assumed here is: + + * Once a topic branch forks from "master", "master" is never + merged into it again (either directly or indirectly). + + * Once a topic branch is fully cooked and merged into "master", + it is deleted. If you need to build on top of it to correct + earlier mistakes, a new topic branch is created by forking at + the tip of the "master". This is not strictly necessary, but + it makes it easier to keep your history simple. + + * Whenever you need to test or publish your changes to topic + branches, merge them into "next" branch. + +The script, being an example, hardcodes the publish branch name +to be "next", but it is trivial to make it configurable via +$GIT_DIR/config mechanism. + +With this workflow, you would want to know: + +(1) ... if a topic branch has ever been merged to "next". Young + topic branches can have stupid mistakes you would rather + clean up before publishing, and things that have not been + merged into other branches can be easily rebased without + affecting other people. But once it is published, you would + not want to rewind it. + +(2) ... if a topic branch has been fully merged to "master". + Then you can delete it. More importantly, you should not + build on top of it -- other people may already want to + change things related to the topic as patches against your + "master", so if you need further changes, it is better to + fork the topic (perhaps with the same name) afresh from the + tip of "master". + +Let's look at this example: + + o---o---o---o---o---o---o---o---o---o "next" + / / / / + / a---a---b A / / + / / / / + / / c---c---c---c B / + / / / \ / + / / / b---b C \ / + / / / / \ / + ---o---o---o---o---o---o---o---o---o---o---o "master" + + +A, B and C are topic branches. + + * A has one fix since it was merged up to "next". + + * B has finished. It has been fully merged up to "master" and "next", + and is ready to be deleted. + + * C has not merged to "next" at all. + +We would want to allow C to be rebased, refuse A, and encourage +B to be deleted. + +To compute (1): + + git rev-list ^master ^topic next + git rev-list ^master next + + if these match, topic has not merged in next at all. + +To compute (2): + + git rev-list master..topic + + if this is empty, it is fully merged to "master". + +DOC_END diff --git a/am-kernels/.git.bak/hooks/pre-receive.sample b/am-kernels/.git.bak/hooks/pre-receive.sample new file mode 100755 index 0000000..2e9a2ca --- /dev/null +++ b/am-kernels/.git.bak/hooks/pre-receive.sample @@ -0,0 +1,24 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# An example hook script to make use of push options. +# The example simply echoes all push options that start with 'echoback=' +# and rejects all pushes when the "reject" push option is used. +# +# To enable this hook, rename this file to "pre-receive". + +if test -n "$GIT_PUSH_OPTION_COUNT" +then + i=0 + while test "$i" -lt "$GIT_PUSH_OPTION_COUNT" + do + eval "value=\$GIT_PUSH_OPTION_$i" + case "$value" in + echoback=*) + echo "echo from the pre-receive-hook: ${value#*=}" >&2 + ;; + reject) + exit 1 + esac + i=$((i + 1)) + done +fi diff --git a/am-kernels/.git.bak/hooks/prepare-commit-msg.sample b/am-kernels/.git.bak/hooks/prepare-commit-msg.sample new file mode 100755 index 0000000..3f8b8ef --- /dev/null +++ b/am-kernels/.git.bak/hooks/prepare-commit-msg.sample @@ -0,0 +1,42 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# An example hook script to prepare the commit log message. +# Called by "git commit" with the name of the file that has the +# commit message, followed by the description of the commit +# message's source. The hook's purpose is to edit the commit +# message file. If the hook fails with a non-zero status, +# the commit is aborted. +# +# To enable this hook, rename this file to "prepare-commit-msg". + +# This hook includes three examples. The first one removes the +# "# Please enter the commit message..." help message. +# +# The second includes the output of "git diff --name-status -r" +# into the message, just before the "git status" output. It is +# commented because it doesn't cope with --amend or with squashed +# commits. +# +# The third example adds a Signed-off-by line to the message, that can +# still be edited. This is rarely a good idea. + +COMMIT_MSG_FILE=$1 +COMMIT_SOURCE=$2 +SHA1=$3 + +/nix/store/jr2c1rk91nqlfz5a5lwfq2kyilxzj879-perl-5.38.2/bin/perl -i.bak -ne 'print unless(m/^. Please enter the commit message/..m/^#$/)' "$COMMIT_MSG_FILE" + +# case "$COMMIT_SOURCE,$SHA1" in +# ,|template,) +# /nix/store/jr2c1rk91nqlfz5a5lwfq2kyilxzj879-perl-5.38.2/bin/perl -i.bak -pe ' +# print "\n" . `git diff --cached --name-status -r` +# if /^#/ && $first++ == 0' "$COMMIT_MSG_FILE" ;; +# *) ;; +# esac + +# SOB=$(git var GIT_COMMITTER_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p') +# git interpret-trailers --in-place --trailer "$SOB" "$COMMIT_MSG_FILE" +# if test -z "$COMMIT_SOURCE" +# then +# /nix/store/jr2c1rk91nqlfz5a5lwfq2kyilxzj879-perl-5.38.2/bin/perl -i.bak -pe 'print "\n" if !$first_line++' "$COMMIT_MSG_FILE" +# fi diff --git a/am-kernels/.git.bak/hooks/push-to-checkout.sample b/am-kernels/.git.bak/hooks/push-to-checkout.sample new file mode 100755 index 0000000..519d42a --- /dev/null +++ b/am-kernels/.git.bak/hooks/push-to-checkout.sample @@ -0,0 +1,78 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash + +# An example hook script to update a checked-out tree on a git push. +# +# This hook is invoked by git-receive-pack(1) when it reacts to git +# push and updates reference(s) in its repository, and when the push +# tries to update the branch that is currently checked out and the +# receive.denyCurrentBranch configuration variable is set to +# updateInstead. +# +# By default, such a push is refused if the working tree and the index +# of the remote repository has any difference from the currently +# checked out commit; when both the working tree and the index match +# the current commit, they are updated to match the newly pushed tip +# of the branch. This hook is to be used to override the default +# behaviour; however the code below reimplements the default behaviour +# as a starting point for convenient modification. +# +# The hook receives the commit with which the tip of the current +# branch is going to be updated: +commit=$1 + +# It can exit with a non-zero status to refuse the push (when it does +# so, it must not modify the index or the working tree). +die () { + echo >&2 "$*" + exit 1 +} + +# Or it can make any necessary changes to the working tree and to the +# index to bring them to the desired state when the tip of the current +# branch is updated to the new commit, and exit with a zero status. +# +# For example, the hook can simply run git read-tree -u -m HEAD "$1" +# in order to emulate git fetch that is run in the reverse direction +# with git push, as the two-tree form of git read-tree -u -m is +# essentially the same as git switch or git checkout that switches +# branches while keeping the local changes in the working tree that do +# not interfere with the difference between the branches. + +# The below is a more-or-less exact translation to shell of the C code +# for the default behaviour for git's push-to-checkout hook defined in +# the push_to_deploy() function in builtin/receive-pack.c. +# +# Note that the hook will be executed from the repository directory, +# not from the working tree, so if you want to perform operations on +# the working tree, you will have to adapt your code accordingly, e.g. +# by adding "cd .." or using relative paths. + +if ! git update-index -q --ignore-submodules --refresh +then + die "Up-to-date check failed" +fi + +if ! git diff-files --quiet --ignore-submodules -- +then + die "Working directory has unstaged changes" +fi + +# This is a rough translation of: +# +# head_has_history() ? "HEAD" : EMPTY_TREE_SHA1_HEX +if git cat-file -e HEAD 2>/dev/null +then + head=HEAD +else + head=$(git hash-object -t tree --stdin &2 + exit 1 +} + +unset GIT_DIR GIT_WORK_TREE +cd "$worktree" && + +if grep -q "^diff --git " "$1" +then + validate_patch "$1" +else + validate_cover_letter "$1" +fi && + +if test "$GIT_SENDEMAIL_FILE_COUNTER" = "$GIT_SENDEMAIL_FILE_TOTAL" +then + git config --unset-all sendemail.validateWorktree && + trap 'git worktree remove -ff "$worktree"' EXIT && + validate_series +fi diff --git a/am-kernels/.git.bak/hooks/update.sample b/am-kernels/.git.bak/hooks/update.sample new file mode 100755 index 0000000..d6aa5f0 --- /dev/null +++ b/am-kernels/.git.bak/hooks/update.sample @@ -0,0 +1,128 @@ +#!/nix/store/087167dfxal194pm54cmcbbxsfy3cjgn-bash-5.2p26/bin/bash +# +# An example hook script to block unannotated tags from entering. +# Called by "git receive-pack" with arguments: refname sha1-old sha1-new +# +# To enable this hook, rename this file to "update". +# +# Config +# ------ +# hooks.allowunannotated +# This boolean sets whether unannotated tags will be allowed into the +# repository. By default they won't be. +# hooks.allowdeletetag +# This boolean sets whether deleting tags will be allowed in the +# repository. By default they won't be. +# hooks.allowmodifytag +# This boolean sets whether a tag may be modified after creation. By default +# it won't be. +# hooks.allowdeletebranch +# This boolean sets whether deleting branches will be allowed in the +# repository. By default they won't be. +# hooks.denycreatebranch +# This boolean sets whether remotely creating branches will be denied +# in the repository. By default this is allowed. +# + +# --- Command line +refname="$1" +oldrev="$2" +newrev="$3" + +# --- Safety check +if [ -z "$GIT_DIR" ]; then + echo "Don't run this script from the command line." >&2 + echo " (if you want, you could supply GIT_DIR then run" >&2 + echo " $0 )" >&2 + exit 1 +fi + +if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then + echo "usage: $0 " >&2 + exit 1 +fi + +# --- Config +allowunannotated=$(git config --type=bool hooks.allowunannotated) +allowdeletebranch=$(git config --type=bool hooks.allowdeletebranch) +denycreatebranch=$(git config --type=bool hooks.denycreatebranch) +allowdeletetag=$(git config --type=bool hooks.allowdeletetag) +allowmodifytag=$(git config --type=bool hooks.allowmodifytag) + +# check for no description +projectdesc=$(sed -e '1q' "$GIT_DIR/description") +case "$projectdesc" in +"Unnamed repository"* | "") + echo "*** Project description file hasn't been set" >&2 + exit 1 + ;; +esac + +# --- Check types +# if $newrev is 0000...0000, it's a commit to delete a ref. +zero=$(git hash-object --stdin &2 + echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2 + exit 1 + fi + ;; + refs/tags/*,delete) + # delete tag + if [ "$allowdeletetag" != "true" ]; then + echo "*** Deleting a tag is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/tags/*,tag) + # annotated tag + if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1 + then + echo "*** Tag '$refname' already exists." >&2 + echo "*** Modifying a tag is not allowed in this repository." >&2 + exit 1 + fi + ;; + refs/heads/*,commit) + # branch + if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then + echo "*** Creating a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/heads/*,delete) + # delete branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + refs/remotes/*,commit) + # tracking branch + ;; + refs/remotes/*,delete) + # delete tracking branch + if [ "$allowdeletebranch" != "true" ]; then + echo "*** Deleting a tracking branch is not allowed in this repository" >&2 + exit 1 + fi + ;; + *) + # Anything else (is there anything else?) + echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2 + exit 1 + ;; +esac + +# --- Finished +exit 0 diff --git a/am-kernels/.git.bak/index b/am-kernels/.git.bak/index new file mode 100644 index 0000000..f6e0a7a Binary files /dev/null and b/am-kernels/.git.bak/index differ diff --git a/am-kernels/.git.bak/info/exclude b/am-kernels/.git.bak/info/exclude new file mode 100644 index 0000000..a5196d1 --- /dev/null +++ b/am-kernels/.git.bak/info/exclude @@ -0,0 +1,6 @@ +# git ls-files --others --exclude-from=.git/info/exclude +# Lines that start with '#' are comments. +# For a project mostly in C, the following would be a good set of +# exclude patterns (uncomment them if you want to use them): +# *.[oa] +# *~ diff --git a/am-kernels/.git.bak/logs/HEAD b/am-kernels/.git.bak/logs/HEAD new file mode 100644 index 0000000..a85be9e --- /dev/null +++ b/am-kernels/.git.bak/logs/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 bb725d6f8223dd7de831c3b692e8c4531e9d01af xinyangli 1709436368 +0800 clone: from github.com:NJU-ProjectN/am-kernels.git diff --git a/am-kernels/.git.bak/logs/refs/heads/ics2021 b/am-kernels/.git.bak/logs/refs/heads/ics2021 new file mode 100644 index 0000000..a85be9e --- /dev/null +++ b/am-kernels/.git.bak/logs/refs/heads/ics2021 @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 bb725d6f8223dd7de831c3b692e8c4531e9d01af xinyangli 1709436368 +0800 clone: from github.com:NJU-ProjectN/am-kernels.git diff --git a/am-kernels/.git.bak/logs/refs/remotes/origin/HEAD b/am-kernels/.git.bak/logs/refs/remotes/origin/HEAD new file mode 100644 index 0000000..a85be9e --- /dev/null +++ b/am-kernels/.git.bak/logs/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +0000000000000000000000000000000000000000 bb725d6f8223dd7de831c3b692e8c4531e9d01af xinyangli 1709436368 +0800 clone: from github.com:NJU-ProjectN/am-kernels.git diff --git a/am-kernels/.git.bak/objects/0f/559e690606f3feab9e02813cf2085b5c471b56 b/am-kernels/.git.bak/objects/0f/559e690606f3feab9e02813cf2085b5c471b56 new file mode 100644 index 0000000..892679d Binary files /dev/null and b/am-kernels/.git.bak/objects/0f/559e690606f3feab9e02813cf2085b5c471b56 differ diff --git a/am-kernels/.git.bak/objects/36/b9a39f647bf13895df413debc9061d055249b0 b/am-kernels/.git.bak/objects/36/b9a39f647bf13895df413debc9061d055249b0 new file mode 100644 index 0000000..b7abab9 Binary files /dev/null and b/am-kernels/.git.bak/objects/36/b9a39f647bf13895df413debc9061d055249b0 differ diff --git a/am-kernels/.git.bak/objects/45/04c420cc600ee278b41dc8911acbfb4fdfa7c0 b/am-kernels/.git.bak/objects/45/04c420cc600ee278b41dc8911acbfb4fdfa7c0 new file mode 100644 index 0000000..ccbdccf Binary files /dev/null and b/am-kernels/.git.bak/objects/45/04c420cc600ee278b41dc8911acbfb4fdfa7c0 differ diff --git a/am-kernels/.git.bak/objects/4d/5393c3c53c4153c5db5227da8d3928226d2a5d b/am-kernels/.git.bak/objects/4d/5393c3c53c4153c5db5227da8d3928226d2a5d new file mode 100644 index 0000000..d9ff122 Binary files /dev/null and b/am-kernels/.git.bak/objects/4d/5393c3c53c4153c5db5227da8d3928226d2a5d differ diff --git a/am-kernels/.git.bak/objects/61/f185ad27e7f199809de98378cec302553e436f b/am-kernels/.git.bak/objects/61/f185ad27e7f199809de98378cec302553e436f new file mode 100644 index 0000000..8cfa5cc --- /dev/null +++ b/am-kernels/.git.bak/objects/61/f185ad27e7f199809de98378cec302553e436f @@ -0,0 +1 @@ +xMj0D{WtpJC{KL$XW!KD-T(!^9%,3/-XӇ^8Ɓ&yŋ?Ҕ"4 'OZp ̙svN%|z>n|K8-𢧲"$ {brO!cB& 9 n_,jhO4T8xh Wge!(ZGqka|a5 v+RsE]ta *~`}i%"ښVNP0ZN`=mMi=y)EP`qy8̭N8Pc? +0;YS.Fo?z&Qg>1hQ8S৛5΃"sn?̬{* '17f 㒆]X~M+Ն wnٶ}?aDs]Lj]&8XEW`xGە]G LMugt6G9!=X \ No newline at end of file diff --git a/am-kernels/.git.bak/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 b/am-kernels/.git.bak/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 new file mode 100644 index 0000000..7112238 Binary files /dev/null and b/am-kernels/.git.bak/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391 differ diff --git a/am-kernels/.git.bak/objects/fe/95b9b6930339a0f004b6eb08a9ad9f5642e9f8 b/am-kernels/.git.bak/objects/fe/95b9b6930339a0f004b6eb08a9ad9f5642e9f8 new file mode 100644 index 0000000..b33e10f Binary files /dev/null and b/am-kernels/.git.bak/objects/fe/95b9b6930339a0f004b6eb08a9ad9f5642e9f8 differ diff --git a/am-kernels/.git.bak/objects/pack/pack-fd014db4984fb9bfc8a49de0e4f554d0018fe65a.idx b/am-kernels/.git.bak/objects/pack/pack-fd014db4984fb9bfc8a49de0e4f554d0018fe65a.idx new file mode 100644 index 0000000..af454a2 Binary files /dev/null and b/am-kernels/.git.bak/objects/pack/pack-fd014db4984fb9bfc8a49de0e4f554d0018fe65a.idx differ diff --git a/am-kernels/.git.bak/objects/pack/pack-fd014db4984fb9bfc8a49de0e4f554d0018fe65a.pack b/am-kernels/.git.bak/objects/pack/pack-fd014db4984fb9bfc8a49de0e4f554d0018fe65a.pack new file mode 100644 index 0000000..e86b29a Binary files /dev/null and b/am-kernels/.git.bak/objects/pack/pack-fd014db4984fb9bfc8a49de0e4f554d0018fe65a.pack differ diff --git a/am-kernels/.git.bak/objects/pack/pack-fd014db4984fb9bfc8a49de0e4f554d0018fe65a.rev b/am-kernels/.git.bak/objects/pack/pack-fd014db4984fb9bfc8a49de0e4f554d0018fe65a.rev new file mode 100644 index 0000000..7188e0d Binary files /dev/null and b/am-kernels/.git.bak/objects/pack/pack-fd014db4984fb9bfc8a49de0e4f554d0018fe65a.rev differ diff --git a/am-kernels/.git.bak/packed-refs b/am-kernels/.git.bak/packed-refs new file mode 100644 index 0000000..3df9009 --- /dev/null +++ b/am-kernels/.git.bak/packed-refs @@ -0,0 +1,4 @@ +# pack-refs with: peeled fully-peeled sorted +9ab41b3e051a49789b458deb0153c9dfe8e93d00 refs/remotes/origin/ics2020 +bb725d6f8223dd7de831c3b692e8c4531e9d01af refs/remotes/origin/ics2021 +bb725d6f8223dd7de831c3b692e8c4531e9d01af refs/remotes/origin/master diff --git a/am-kernels/.git.bak/refs/heads/ics2021 b/am-kernels/.git.bak/refs/heads/ics2021 new file mode 100644 index 0000000..ca51d2e --- /dev/null +++ b/am-kernels/.git.bak/refs/heads/ics2021 @@ -0,0 +1 @@ +bb725d6f8223dd7de831c3b692e8c4531e9d01af diff --git a/am-kernels/.git.bak/refs/remotes/origin/HEAD b/am-kernels/.git.bak/refs/remotes/origin/HEAD new file mode 100644 index 0000000..6efe28f --- /dev/null +++ b/am-kernels/.git.bak/refs/remotes/origin/HEAD @@ -0,0 +1 @@ +ref: refs/remotes/origin/master diff --git a/am-kernels/.gitignore b/am-kernels/.gitignore new file mode 100644 index 0000000..5170a12 --- /dev/null +++ b/am-kernels/.gitignore @@ -0,0 +1,15 @@ +* +!*/ +!*.h +!*.c +!*.cc +!*.S +!Makefile +!README +!README.md +!LICENSE +.* +_* +*~ +build/ +!.gitignore diff --git a/am-kernels/CMakeLists.txt b/am-kernels/CMakeLists.txt new file mode 100644 index 0000000..61f185a --- /dev/null +++ b/am-kernels/CMakeLists.txt @@ -0,0 +1,16 @@ +cmake_minimum_required(VERSION 3.22) + +project(am-kernels) +set(CMAKE_C_STANDARD 11) +enable_language(C ASM) + +include(CheckPIESupported) +check_pie_supported() + +if(${PLATFORM} MATCHES "native") +set(ARCH "native") +else() +set(ARCH ${ISA}-${PLATFORM}) +endif() + +add_subdirectory(tests/cpu-tests) \ No newline at end of file diff --git a/am-kernels/LICENSE b/am-kernels/LICENSE new file mode 100644 index 0000000..a9f1b1f --- /dev/null +++ b/am-kernels/LICENSE @@ -0,0 +1,22 @@ +The AbstractMachine software is: + +Copyright (c) 2018-2020 Yanyan Jiang and Zihao Yu + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/am-kernels/README b/am-kernels/README new file mode 100644 index 0000000..0e17e88 --- /dev/null +++ b/am-kernels/README @@ -0,0 +1,6 @@ +AbstractMachine kernels + +CONTACTS + +Bug reports and suggestions go to Yanyan Jiang (jyy@nju.edu.cn) and Zihao +Yu (yuzihao@ict.ac.cn). diff --git a/am-kernels/benchmarks/coremark/Makefile b/am-kernels/benchmarks/coremark/Makefile new file mode 100644 index 0000000..479088b --- /dev/null +++ b/am-kernels/benchmarks/coremark/Makefile @@ -0,0 +1,3 @@ +NAME = coremark +SRCS = $(shell find src/ -name "*.c") +include $(AM_HOME)/Makefile diff --git a/am-kernels/benchmarks/coremark/README.md b/am-kernels/benchmarks/coremark/README.md new file mode 100644 index 0000000..209e4c2 --- /dev/null +++ b/am-kernels/benchmarks/coremark/README.md @@ -0,0 +1,231 @@ +# Coremark + +''' +File: CoreMark + +Topic: Welcome +Copyright � 2009 EEMBC All rights reserved. +CoreMark is a trademark of EEMBC and EEMBC is a registered trademark of the Embedded Microprocessor Benchmark Consortium. + +CoreMark�s primary goals are simplicity and providing a method for testing only a processor�s core features. + +For more information about EEMBC's comprehensive embedded benchmark suites, please see www.eembc.org. + +Topic: Building and running + Download the release files from the www.coremark.org. + You can verify the download using the coremark_.md5 file + > md5sum -c coremark_.md5 + + Unpack the distribution (tar -vzxf coremark_.tgz && tar -vzxf coremark__docs.tgz) + then change to the coremark_ folder. + + To build and run the benchmark, type + > make + Full results are available in the files run1.log and run2.log. + CoreMark result can be found in run1.log. + + For self hosted Linux or Cygwin platforms, a simple make should work. + + Cross Compile: + For cross compile platforms please adjust , (and possibly ) + according to the specific platform used. + When porting to a new platform, it is recommended to copy one of the default port folders + (e.g. mkdir && cp linux/* ), adjust the porting files, and run + > make PORT_DIR= + + Systems without make: + The following files need to be compiled: + - + - + - + - + - + - / + + For example + > gcc -O2 -o coremark.exe core_list_join.c core_main.c core_matrix.c core_state.c core_util.c simple/core_portme.c -DPERFORMANCE_RUN=1 -DITERATIONS=1000 + > ./coremark.exe > run1.log + The above will compile the benchmark for a performance run and 1000 iterations. Output is redirected to run1.log. + + Make targets: + run - Default target, creates run1.log and run2.log. + run1.log - Run the benchmark with performance parameters, and output to run1.log + run2.log - Run the benchmark with validation parameters, and output to run2.log + run3.log - Run the benchmark with profile generation parameters, and output to run3.log + compile - compile the benchmark executable + link - link the benchmark executable + check - test MD5 of sources that may not be modified + clean - clean temporary files + + ITERATIONS: + By default, the benchmark will run between 10-100 seconds. + To override, use ITERATIONS=N + > make ITERATIONS=10 + Will run the benchmark for 10 iterations. + It is recommended to set a specific number of iterations in certain situations e.g.: + - Running with a simulator + - Measuring power/energy + - Timing cannot be restarted + + Minimum required run time: + Results are only valid for reporting if the benchmark ran for at least 10 secs! + + XCFLAGS: + To add compiler flags from the command line, use XCFLAGS e.g. + > make XCFLAGS="-g -DMULTITHREAD=4 -DUSE_FORK=1" + + o CORE_DEBUG + + Define to compile for a debug run if you get incorrect CRC. + > make XCFLAGS="-DCORE_DEBUG=1" + + o Parallel Execution + + Use XCFLAGS=-DMULTITHREAD=N where N is number of threads to run in parallel. + Several implementations are available to execute in multiple contexts, + or you can implement your own in . + > make XCFLAGS="-DMULTITHREAD=4 -DUSE_PTHREAD" + Above will compile the benchmark for execution on 4 cores, using POSIX Threads API. + + REBUILD: + To force rebuild, add the flag REBUILD to the command line + > make REBUILD=1 + + Check core_portme.mak for more important options. + + Run parameters for the benchmark executable: + Coremark executable takes several parameters as follows (if main accepts arguments). + 1st - A seed value used for initialization of data. + 2nd - A seed value used for initialization of data. + 3rd - A seed value used for initialization of data. + 4th - Number of iterations (0 for auto : default value) + 5th - Reserved for internal use. + 6th - Reserved for internal use. + 7th - For malloc users only, ovreride the size of the input data buffer. + + The run target from make will run coremark with 2 different data initialization seeds. + + Alternative parameters: + If not using malloc or command line arguments are not supported, the buffer size + for the algorithms must be defined via the compiler define TOTAL_DATA_SIZE. + TOTAL_DATA_SIZE must be set to 2000 bytes (default) for standard runs. + The default for such a target when testing different configurations could be ... + > make XCFLAGS="-DTOTAL_DATA_SIZE=6000 -DMAIN_HAS_NOARGC=1" + +Topic: Documentation + When you unpack the documentation (tar -vzxf coremark__docs.tgz) a docs folder will be created. + Check the file docs/html/index.html and the website http://www.coremark.org for more info. + +Topic: Submitting results + CoreMark results can be submitted on the web. + + Open a web browser and go to http://www.coremark.org/benchmark/index.php?pg=benchmark + Select the link to add a new score and follow the instructions. + +Topic: Run rules + What is and is not allowed. + + Required: + 1 - The benchmark needs to run for at least 10 seconds. + 2 - All validation must succeed for seeds 0,0,0x66 and 0x3415,0x3415,0x66, + buffer size of 2000 bytes total. + o If not using command line arguments to main: + > make XCFLAGS="-DPERFORMANCE_RUN=1" REBUILD=1 run1.log + > make XCFLAGS="-DVALIDATION_RUN=1" REBUILD=1 run2.log + 3 - If using profile guided optimization, profile must be generated using seeds of 8,8,8, + and buffer size of 1200 bytes total. + > make XCFLAGS="-DTOTAL_DATA_SIZE=1200 -DPROFILE_RUN=1" REBUILD=1 run3.log + 4 - All source files must be compiled with the same flags. + 5 - All data type sizes must match size in bits such that: + o ee_u8 is an 8 bits datatype. + o ee_s16 is an 16 bits datatype. + o ee_u16 is an 16 bits datatype. + o ee_s32 is an 32 bits datatype. + o ee_u32 is an 32 bits datatype. + + Allowed: + - Changing number of iterations + - Changing toolchain and build/load/run options + - Changing method of acquiring a data memory block + - Changing the method of acquiring seed values + - Changing implementation in core_portme.c + - Changing configuration values in core_portme.h + - Changing core_portme.mak + + Not allowed: + - Changing of source file other then core_portme* (use make check to validate) + +Topic: Reporting rules + How to report results on a data sheet? + + CoreMark 1.0 : N / C [/ P] [/ M] + + N - Number of iterations per second with seeds 0,0,0x66,size=2000) + C - Compiler version and flags + P - Parameters such as data and code allocation specifics + - This parameter *may* be omitted if all data was allocated on the heap in RAM. + - This parameter *may not* be omitted when reporting CoreMark/MHz + M - Type of parallel execution (if used) and number of contexts + This parameter may be omitted if parallel execution was not used. + + e.g. + > CoreMark 1.0 : 128 / GCC 4.1.2 -O2 -fprofile-use / Heap in TCRAM / FORK:2 + or + > CoreMark 1.0 : 1400 / GCC 3.4 -O4 + + If reporting scaling results, the results must be reported as follows: + + CoreMark/MHz 1.0 : N / C / P [/ M] + + P - When reporting scaling results, memory parameter must also indicate memory frequency:core frequency ratio. + - If the core has cache and cache frequency to core frequency ratio is configurable, that must also be included. + + e.g. + > CoreMark/MHz 1.0 : 1.47 / GCC 4.1.2 -O2 / DDR3(Heap) 30:1 Memory 1:1 Cache + + +Topic: Log File Format + The log files have the following format +(start example) +2K performance run parameters for coremark. (Run type) +CoreMark Size : 666 (Buffer size) +Total ticks : 25875 (platform dependent value) +Total time (secs) : 25.875000 (actual time in seconds) +Iterations/Sec : 3864.734300 (Performance value to report) +Iterations : 100000 (number of iterations used) +Compiler version : GCC3.4.4 (Compiler and version) +Compiler flags : -O2 (Compiler and linker flags) +Memory location : Code in flash, data in on chip RAM +seedcrc : 0xe9f5 (identifier for the input seeds) +[0]crclist : 0xe714 (validation for list part) +[0]crcmatrix : 0x1fd7 (validation for matrix part) +[0]crcstate : 0x8e3a (validation for state part) +[0]crcfinal : 0x33ff (iteration dependent output) +Correct operation validated. See readme.txt for run and reporting rules. (*Only when run is successful*) +CoreMark 1.0 : 6508.490622 / GCC3.4.4 -O2 / Heap (*Only on a successful performance run*) +(end example) + +Topic: Legal +See LICENSE.txt or the word document file under docs/LICENSE.doc. +For more information on your legal rights to use this benchmark, please see +http://www.coremark.org/download/register.php?pg=register + +Topic: Credits +Many thanks to all of the individuals who helped with the development or testing of CoreMark including (Sorted by company name) +o Alan Anderson, ADI +o Adhikary Rajiv, ADI +o Elena Stohr, ARM +o Ian Rickards, ARM +o Andrew Pickard, ARM +o Trent Parker, CAVIUM +o Shay Gal-On, EEMBC +o Markus Levy, EEMBC +o Ron Olson, IBM +o Eyal Barzilay, MIPS +o Jens Eltze, NEC +o Hirohiko Ono, NEC +o Ulrich Drees, NEC +o Frank Roscheda, NEC +o Rob Cosaro, NXP +o Shumpei Kawasaki, RENESAS +''' diff --git a/am-kernels/benchmarks/coremark/include/core_portme.h b/am-kernels/benchmarks/coremark/include/core_portme.h new file mode 100644 index 0000000..65278e3 --- /dev/null +++ b/am-kernels/benchmarks/coremark/include/core_portme.h @@ -0,0 +1,188 @@ +/* Topic : Description + This file contains configuration constants required to execute on different platforms +*/ + + +#ifndef CORE_PORTME_H +#define CORE_PORTME_H + +#include +#include +#include + +#define ITERATIONS 1000 +#define MEM_METHOD MEM_STATIC + +/************************/ +/* Data types and settings */ +/************************/ +/* Configuration : HAS_FLOAT + Define to 1 if the platform supports floating point. +*/ +#ifndef HAS_FLOAT +#define HAS_FLOAT 0 +#endif +/* Configuration : HAS_TIME_H + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef HAS_TIME_H +#define HAS_TIME_H 0 +#endif +/* Configuration : USE_CLOCK + Define to 1 if platform has the time.h header file, + and implementation of functions thereof. +*/ +#ifndef USE_CLOCK +#define USE_CLOCK 0 +#endif +/* Configuration : HAS_STDIO + Define to 1 if the platform has stdio.h. +*/ +#ifndef HAS_STDIO +#define HAS_STDIO 0 +#endif +/* Configuration : HAS_PRINTF + Define to 1 if the platform has stdio.h and implements the printf function. +*/ +#ifndef HAS_PRINTF +#define HAS_PRINTF 1 +#endif + +/* Configuration : CORE_TICKS + Define type of return from the timing functions. + */ +typedef uint32_t CORE_TICKS; + +/* Definitions : COMPILER_VERSION, COMPILER_FLAGS, MEM_LOCATION + Initialize these strings per platform +*/ +#ifndef COMPILER_VERSION + #ifdef __GNUC__ + #define COMPILER_VERSION "GCC"__VERSION__ + #else + #define COMPILER_VERSION "Please put compiler version here (e.g. gcc 4.1)" + #endif +#endif +#ifndef COMPILER_FLAGS + #define COMPILER_FLAGS +#endif +#ifndef MEM_LOCATION + #define MEM_LOCATION "STACK" +#endif + +/* Data Types : + To avoid compiler issues, define the data types that need ot be used for 8b, 16b and 32b in . + + *Imprtant* : + ee_ptr_int needs to be the data type used to hold pointers, otherwise coremark may fail!!! +*/ +typedef signed short ee_s16; +typedef unsigned short ee_u16; +typedef signed int ee_s32; +typedef double ee_f32; +typedef unsigned char ee_u8; +typedef unsigned int ee_u32; +typedef unsigned long ee_ptr_int; +typedef size_t ee_size_t; +/* align_mem : + This macro is used to align an offset to point to a 32b value. It is used in the Matrix algorithm to initialize the input memory blocks. +*/ +#define align_mem(x) (void *)(4 + (((unsigned long)(x) - 1) & ~3)) + +/* Configuration : SEED_METHOD + Defines method to get seed values that cannot be computed at compile time. + + Valid values : + SEED_ARG - from command line. + SEED_FUNC - from a system function. + SEED_VOLATILE - from volatile variables. +*/ +#ifndef SEED_METHOD +#define SEED_METHOD SEED_VOLATILE +#endif + +/* Configuration : MEM_METHOD + Defines method to get a block of memry. + + Valid values : + MEM_MALLOC - for platforms that implement malloc and have malloc.h. + MEM_STATIC - to use a static memory array. + MEM_STACK - to allocate the data block on the stack (NYI). +*/ +#ifndef MEM_METHOD +#define MEM_METHOD MEM_STACK +#endif + +/* Configuration : MULTITHREAD + Define for parallel execution + + Valid values : + 1 - only one context (default). + N>1 - will execute N copies in parallel. + + Note : + If this flag is defined to more then 1, an implementation for launching parallel contexts must be defined. + + Two sample implementations are provided. Use or to enable them. + + It is valid to have a different implementation of and in , + to fit a particular architecture. +*/ +#ifndef MULTITHREAD +#define MULTITHREAD 1 +#define USE_PTHREAD 0 +#define USE_FORK 0 +#define USE_SOCKET 0 +#endif + +/* Configuration : MAIN_HAS_NOARGC + Needed if platform does not support getting arguments to main. + + Valid values : + 0 - argc/argv to main is supported + 1 - argc/argv to main is not supported + + Note : + This flag only matters if MULTITHREAD has been defined to a value greater then 1. +*/ +#ifndef MAIN_HAS_NOARGC +#define MAIN_HAS_NOARGC 0 +#endif + +/* Configuration : MAIN_HAS_NORETURN + Needed if platform does not support returning a value from main. + + Valid values : + 0 - main returns an int, and return value will be 0. + 1 - platform does not support returning a value from main +*/ +#ifndef MAIN_HAS_NORETURN +#define MAIN_HAS_NORETURN 0 +#endif + +/* Variable : default_num_contexts + Not used for this simple port, must cintain the value 1. +*/ +extern ee_u32 default_num_contexts; + +typedef struct CORE_PORTABLE_S { + ee_u8 portable_id; +} core_portable; + +/* target specific init/fini */ +void portable_init(core_portable *p, int *argc, char *argv[]); +void portable_fini(core_portable *p); + +#if !defined(PROFILE_RUN) && !defined(PERFORMANCE_RUN) && !defined(VALIDATION_RUN) +#if (TOTAL_DATA_SIZE==1200) +#define PROFILE_RUN 1 +#elif (TOTAL_DATA_SIZE==2000) +#define PERFORMANCE_RUN 1 +#else +#define VALIDATION_RUN 1 +#endif +#endif + + +#endif /* CORE_PORTME_H */ diff --git a/am-kernels/benchmarks/coremark/include/coremark.h b/am-kernels/benchmarks/coremark/include/coremark.h new file mode 100644 index 0000000..14cb252 --- /dev/null +++ b/am-kernels/benchmarks/coremark/include/coremark.h @@ -0,0 +1,174 @@ +/* +Author : Shay Gal-On, EEMBC + +This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +All rights reserved. + +EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +CoreMark License that is distributed with the official EEMBC COREMARK Software release. +If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +you must discontinue use and download the official release from www.coremark.org. + +Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. + +EEMBC +4354 Town Center Blvd. Suite 114-200 +El Dorado Hills, CA, 95762 +*/ +/* Topic: Description + This file contains declarations of the various benchmark functions. +*/ + +/* Configuration: TOTAL_DATA_SIZE + Define total size for data algorithms will operate on +*/ +#ifndef TOTAL_DATA_SIZE +#define TOTAL_DATA_SIZE 2*1000 +#endif + +#define SEED_ARG 0 +#define SEED_FUNC 1 +#define SEED_VOLATILE 2 + +#define MEM_STATIC 0 +#define MEM_MALLOC 1 +#define MEM_STACK 2 + +#include "core_portme.h" + +#if HAS_STDIO +#include +#endif +#if HAS_PRINTF +#define ee_printf printf +#endif + +/* Actual benchmark execution in iterate */ +void *iterate(void *pres); + +/* Typedef: secs_ret + For machines that have floating point support, get number of seconds as a double. + Otherwise an unsigned int. +*/ +#if HAS_FLOAT +typedef double secs_ret; +#else +typedef ee_u32 secs_ret; +#endif + +#if MAIN_HAS_NORETURN +#define MAIN_RETURN_VAL +#define MAIN_RETURN_TYPE void +#else +#define MAIN_RETURN_VAL 0 +#define MAIN_RETURN_TYPE int +#endif + +void start_time(void); +void stop_time(void); +CORE_TICKS get_time(void); +secs_ret time_in_secs(CORE_TICKS ticks); + +/* Misc useful functions */ +ee_u16 crcu8(ee_u8 data, ee_u16 crc); +ee_u16 crc16(ee_s16 newval, ee_u16 crc); +ee_u16 crcu16(ee_u16 newval, ee_u16 crc); +ee_u16 crcu32(ee_u32 newval, ee_u16 crc); +ee_u8 check_data_types(); +void *portable_malloc(ee_size_t size); +void portable_free(void *p); +ee_s32 parseval(char *valstring); + +/* Algorithm IDS */ +#define ID_LIST (1<<0) +#define ID_MATRIX (1<<1) +#define ID_STATE (1<<2) +#define ALL_ALGORITHMS_MASK (ID_LIST|ID_MATRIX|ID_STATE) +#define NUM_ALGORITHMS 3 + +/* list data structures */ +typedef struct list_data_s { + ee_s16 data16; + ee_s16 idx; +} list_data; + +typedef struct list_head_s { + struct list_head_s *next; + struct list_data_s *info; +} list_head; + + +/*matrix benchmark related stuff */ +#define MATDAT_INT 1 +#if MATDAT_INT +typedef ee_s16 MATDAT; +typedef ee_s32 MATRES; +#else +typedef ee_f16 MATDAT; +typedef ee_f32 MATRES; +#endif + +typedef struct MAT_PARAMS_S { + int N; + MATDAT *A; + MATDAT *B; + MATRES *C; +} mat_params; + +/* state machine related stuff */ +/* List of all the possible states for the FSM */ +typedef enum CORE_STATE { + CORE_START=0, + CORE_INVALID, + CORE_S1, + CORE_S2, + CORE_INT, + CORE_FLOAT, + CORE_EXPONENT, + CORE_SCIENTIFIC, + NUM_CORE_STATES +} core_state_e ; + + +/* Helper structure to hold results */ +typedef struct RESULTS_S { + /* inputs */ + ee_s16 seed1; /* Initializing seed */ + ee_s16 seed2; /* Initializing seed */ + ee_s16 seed3; /* Initializing seed */ + void *memblock[4]; /* Pointer to safe memory location */ + ee_u32 size; /* Size of the data */ + ee_u32 iterations; /* Number of iterations to execute */ + ee_u32 execs; /* Bitmask of operations to execute */ + struct list_head_s *list; + mat_params mat; + /* outputs */ + ee_u16 crc; + ee_u16 crclist; + ee_u16 crcmatrix; + ee_u16 crcstate; + ee_s16 err; + /* ultithread specific */ + core_portable port; +} core_results; + +/* Multicore execution handling */ +#if (MULTITHREAD>1) +ee_u8 core_start_parallel(core_results *res); +ee_u8 core_stop_parallel(core_results *res); +#endif + +/* list benchmark functions */ +list_head *core_list_init(ee_u32 blksize, list_head *memblock, ee_s16 seed); +ee_u16 core_bench_list(core_results *res, ee_s16 finder_idx); + +/* state benchmark functions */ +void core_init_state(ee_u32 size, ee_s16 seed, ee_u8 *p); +ee_u16 core_bench_state(ee_u32 blksize, ee_u8 *memblock, + ee_s16 seed1, ee_s16 seed2, ee_s16 step, ee_u16 crc); + +/* matrix benchmark functions */ +ee_u32 core_init_matrix(ee_u32 blksize, void *memblk, ee_s32 seed, mat_params *p); +ee_u16 core_bench_matrix(mat_params *p, ee_s16 seed, ee_u16 crc); + diff --git a/am-kernels/benchmarks/coremark/src/core_list_join.c b/am-kernels/benchmarks/coremark/src/core_list_join.c new file mode 100644 index 0000000..f33cdea --- /dev/null +++ b/am-kernels/benchmarks/coremark/src/core_list_join.c @@ -0,0 +1,496 @@ +/* +Author : Shay Gal-On, EEMBC + +This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +All rights reserved. + +EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +CoreMark License that is distributed with the official EEMBC COREMARK Software release. +If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +you must discontinue use and download the official release from www.coremark.org. + +Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. + +EEMBC +4354 Town Center Blvd. Suite 114-200 +El Dorado Hills, CA, 95762 +*/ + +#include "coremark.h" +/* +Topic: Description + Benchmark using a linked list. + + Linked list is a common data structure used in many applications. + + For our purposes, this will excercise the memory units of the processor. + In particular, usage of the list pointers to find and alter data. + + We are not using Malloc since some platforms do not support this library. + + Instead, the memory block being passed in is used to create a list, + and the benchmark takes care not to add more items then can be + accomodated by the memory block. The porting layer will make sure + that we have a valid memory block. + + All operations are done in place, without using any extra memory. + + The list itself contains list pointers and pointers to data items. + Data items contain the following: + + idx - An index that captures the initial order of the list. + data - Variable data initialized based on the input parameters. The 16b are divided as follows: + o Upper 8b are backup of original data. + o Bit 7 indicates if the lower 7 bits are to be used as is or calculated. + o Bits 0-2 indicate type of operation to perform to get a 7b value. + o Bits 3-6 provide input for the operation. + +*/ + +/* local functions */ + +list_head *core_list_find(list_head *list,list_data *info); +list_head *core_list_reverse(list_head *list); +list_head *core_list_remove(list_head *item); +list_head *core_list_undo_remove(list_head *item_removed, list_head *item_modified); +list_head *core_list_insert_new(list_head *insert_point + , list_data *info, list_head **memblock, list_data **datablock + , list_head *memblock_end, list_data *datablock_end); +typedef ee_s32(*list_cmp)(list_data *a, list_data *b, core_results *res); +list_head *core_list_mergesort(list_head *list, list_cmp cmp, core_results *res); + +ee_s16 calc_func(ee_s16 *pdata, core_results *res) { + ee_s16 data=*pdata; + ee_s16 retval; + ee_u8 optype=(data>>7) & 1; /* bit 7 indicates if the function result has been cached */ + if (optype) /* if cached, use cache */ + return (data & 0x007f); + else { /* otherwise calculate and cache the result */ + ee_s16 flag=data & 0x7; /* bits 0-2 is type of function to perform */ + ee_s16 dtype=((data>>3) & 0xf); /* bits 3-6 is specific data for the operation */ + dtype |= dtype << 4; /* replicate the lower 4 bits to get an 8b value */ + switch (flag) { + case 0: + if (dtype<0x22) /* set min period for bit corruption */ + dtype=0x22; + retval=core_bench_state(res->size,res->memblock[3],res->seed1,res->seed2,dtype,res->crc); + if (res->crcstate==0) + res->crcstate=retval; + break; + case 1: + retval=core_bench_matrix(&(res->mat),dtype,res->crc); + if (res->crcmatrix==0) + res->crcmatrix=retval; + break; + default: + retval=data; + break; + } + res->crc=crcu16(retval,res->crc); + retval &= 0x007f; + *pdata = (data & 0xff00) | 0x0080 | retval; /* cache the result */ + return retval; + } +} +/* Function: cmp_complex + Compare the data item in a list cell. + + Can be used by mergesort. +*/ +ee_s32 cmp_complex(list_data *a, list_data *b, core_results *res) { + ee_s16 val1=calc_func(&(a->data16),res); + ee_s16 val2=calc_func(&(b->data16),res); + return val1 - val2; +} + +/* Function: cmp_idx + Compare the idx item in a list cell, and regen the data. + + Can be used by mergesort. +*/ +ee_s32 cmp_idx(list_data *a, list_data *b, core_results *res) { + if (res==NULL) { + a->data16 = (a->data16 & 0xff00) | (0x00ff & (a->data16>>8)); + b->data16 = (b->data16 & 0xff00) | (0x00ff & (b->data16>>8)); + } + return a->idx - b->idx; +} + +void copy_info(list_data *to,list_data *from) { + to->data16=from->data16; + to->idx=from->idx; +} + +/* Benchmark for linked list: + - Try to find multiple data items. + - List sort + - Operate on data from list (crc) + - Single remove/reinsert + * At the end of this function, the list is back to original state +*/ +ee_u16 core_bench_list(core_results *res, ee_s16 finder_idx) { + ee_u16 retval=0; + ee_u16 found=0,missed=0; + list_head *list=res->list; + ee_s16 find_num=res->seed3; + list_head *this_find; + list_head *finder, *remover; + list_data info = {}; + ee_s16 i; + + info.idx=finder_idx; + /* find values in the list, and change the list each time (reverse and cache if value found) */ + for (i=0; inext->info->data16 >> 8) & 1; + } + else { + found++; + if (this_find->info->data16 & 0x1) /* use found value */ + retval+=(this_find->info->data16 >> 9) & 1; + /* and cache next item at the head of the list (if any) */ + if (this_find->next != NULL) { + finder = this_find->next; + this_find->next = finder->next; + finder->next=list->next; + list->next=finder; + } + } + if (info.idx>=0) + info.idx++; +#if CORE_DEBUG + ee_printf("List find %d: [%d,%d,%d]\n",i,retval,missed,found); +#endif + } + retval+=found*4-missed; + /* sort the list by data content and remove one item*/ + if (finder_idx>0) + list=core_list_mergesort(list,cmp_complex,res); + remover=core_list_remove(list->next); + /* CRC data content of list from location of index N forward, and then undo remove */ + finder=core_list_find(list,&info); + if (!finder) + finder=list->next; + while (finder) { + retval=crc16(list->info->data16,retval); + finder=finder->next; + } +#if CORE_DEBUG + ee_printf("List sort 1: %04x\n",retval); +#endif + remover=core_list_undo_remove(remover,list->next); + /* sort the list by index, in effect returning the list to original state */ + list=core_list_mergesort(list,cmp_idx,NULL); + /* CRC data content of list */ + finder=list->next; + while (finder) { + retval=crc16(list->info->data16,retval); + finder=finder->next; + } +#if CORE_DEBUG + ee_printf("List sort 2: %04x\n",retval); +#endif + return retval; +} +/* Function: core_list_init + Initialize list with data. + + Parameters: + blksize - Size of memory to be initialized. + memblock - Pointer to memory block. + seed - Actual values chosen depend on the seed parameter. + The seed parameter MUST be supplied from a source that cannot be determined at compile time + + Returns: + Pointer to the head of the list. + +*/ +list_head *core_list_init(ee_u32 blksize, list_head *memblock, ee_s16 seed) { + /* calculated pointers for the list */ + ee_u32 per_item=16+sizeof(struct list_data_s); + ee_u32 size=(blksize/per_item)-2; /* to accomodate systems with 64b pointers, and make sure same code is executed, set max list elements */ + list_head *memblock_end=memblock+size; + list_data *datablock=(list_data *)(memblock_end); + list_data *datablock_end=datablock+size; + /* some useful variables */ + ee_u32 i; + list_head *finder,*list=memblock; + list_data info; + + /* create a fake items for the list head and tail */ + list->next=NULL; + list->info=datablock; + list->info->idx=0x0000; + list->info->data16=(ee_s16)0x8080; + memblock++; + datablock++; + info.idx=0x7fff; + info.data16=(ee_s16)0xffff; + core_list_insert_new(list,&info,&memblock,&datablock,memblock_end,datablock_end); + + /* then insert size items */ + for (i=0; inext; + i=1; + while (finder->next!=NULL) { + if (iinfo->idx=i++; + else { + ee_u16 pat=(ee_u16)(i++ ^ seed); /* get a pseudo random number */ + finder->info->idx=0x3fff & (((i & 0x07) << 8) | pat); /* make sure the mixed items end up after the ones in sequence */ + } + finder=finder->next; + } + list = core_list_mergesort(list,cmp_idx,NULL); +#if CORE_DEBUG + ee_printf("Initialized list:\n"); + finder=list; + while (finder) { + ee_printf("[%04x,%04x]",finder->info->idx,(ee_u16)finder->info->data16); + finder=finder->next; + } + ee_printf("\n"); +#endif + return list; +} + +/* Function: core_list_insert + Insert an item to the list + + Parameters: + insert_point - where to insert the item. + info - data for the cell. + memblock - pointer for the list header + datablock - pointer for the list data + memblock_end - end of region for list headers + datablock_end - end of region for list data + + Returns: + Pointer to new item. +*/ +list_head *core_list_insert_new(list_head *insert_point, list_data *info, list_head **memblock, list_data **datablock + , list_head *memblock_end, list_data *datablock_end) { + list_head *newitem; + + if ((*memblock+1) >= memblock_end) + return NULL; + if ((*datablock+1) >= datablock_end) + return NULL; + + newitem=*memblock; + (*memblock)++; + newitem->next=insert_point->next; + insert_point->next=newitem; + + newitem->info=*datablock; + (*datablock)++; + copy_info(newitem->info,info); + + return newitem; +} + +/* Function: core_list_remove + Remove an item from the list. + + Operation: + For a singly linked list, remove by copying the data from the next item + over to the current cell, and unlinking the next item. + + Note: + since there is always a fake item at the end of the list, no need to check for NULL. + + Returns: + Removed item. +*/ +list_head *core_list_remove(list_head *item) { + list_data *tmp; + list_head *ret=item->next; + /* swap data pointers */ + tmp=item->info; + item->info=ret->info; + ret->info=tmp; + /* and eliminate item */ + item->next=item->next->next; + ret->next=NULL; + return ret; +} + +/* Function: core_list_undo_remove + Undo a remove operation. + + Operation: + Since we want each iteration of the benchmark to be exactly the same, + we need to be able to undo a remove. + Link the removed item back into the list, and switch the info items. + + Parameters: + item_removed - Return value from the + item_modified - List item that was modified during + + Returns: + The item that was linked back to the list. + +*/ +list_head *core_list_undo_remove(list_head *item_removed, list_head *item_modified) { + list_data *tmp; + /* swap data pointers */ + tmp=item_removed->info; + item_removed->info=item_modified->info; + item_modified->info=tmp; + /* and insert item */ + item_removed->next=item_modified->next; + item_modified->next=item_removed; + return item_removed; +} + +/* Function: core_list_find + Find an item in the list + + Operation: + Find an item by idx (if not 0) or specific data value + + Parameters: + list - list head + info - idx or data to find + + Returns: + Found item, or NULL if not found. +*/ +list_head *core_list_find(list_head *list,list_data *info) { + if (info->idx>=0) { + while (list && (list->info->idx != info->idx)) + list=list->next; + return list; + } else { + while (list && ((list->info->data16 & 0xff) != info->data16)) + list=list->next; + return list; + } +} +/* Function: core_list_reverse + Reverse a list + + Operation: + Rearrange the pointers so the list is reversed. + + Parameters: + list - list head + info - idx or data to find + + Returns: + Found item, or NULL if not found. +*/ + +list_head *core_list_reverse(list_head *list) { + list_head *next=NULL, *tmp; + while (list) { + tmp=list->next; + list->next=next; + next=list; + list=tmp; + } + return next; +} +/* Function: core_list_mergesort + Sort the list in place without recursion. + + Description: + Use mergesort, as for linked list this is a realistic solution. + Also, since this is aimed at embedded, care was taken to use iterative rather then recursive algorithm. + The sort can either return the list to original order (by idx) , + or use the data item to invoke other other algorithms and change the order of the list. + + Parameters: + list - list to be sorted. + cmp - cmp function to use + + Returns: + New head of the list. + + Note: + We have a special header for the list that will always be first, + but the algorithm could theoretically modify where the list starts. + + */ +list_head *core_list_mergesort(list_head *list, list_cmp cmp, core_results *res) { + list_head *p, *q, *e, *tail; + ee_s32 insize, nmerges, psize, qsize, i; + + insize = 1; + + while (1) { + p = list; + list = NULL; + tail = NULL; + + nmerges = 0; /* count number of merges we do in this pass */ + + while (p) { + nmerges++; /* there exists a merge to be done */ + /* step `insize' places along from p */ + q = p; + psize = 0; + for (i = 0; i < insize; i++) { + psize++; + q = q->next; + if (!q) break; + } + + /* if q hasn't fallen off end, we have two lists to merge */ + qsize = insize; + + /* now we have two lists; merge them */ + while (psize > 0 || (qsize > 0 && q)) { + + /* decide whether next element of merge comes from p or q */ + if (psize == 0) { + /* p is empty; e must come from q. */ + e = q; q = q->next; qsize--; + } else if (qsize == 0 || !q) { + /* q is empty; e must come from p. */ + e = p; p = p->next; psize--; + } else if (cmp(p->info,q->info,res) <= 0) { + /* First element of p is lower (or same); e must come from p. */ + e = p; p = p->next; psize--; + } else { + /* First element of q is lower; e must come from q. */ + e = q; q = q->next; qsize--; + } + + /* add the next element to the merged list */ + if (tail) { + tail->next = e; + } else { + list = e; + } + tail = e; + } + + /* now p has stepped `insize' places along, and q has too */ + p = q; + } + + tail->next = NULL; + + /* If we have done only one merge, we're finished. */ + if (nmerges <= 1) /* allow for nmerges==0, the empty list case */ + return list; + + /* Otherwise repeat, merging lists twice the size */ + insize *= 2; + } +#if COMPILER_REQUIRES_SORT_RETURN + return list; +#endif +} diff --git a/am-kernels/benchmarks/coremark/src/core_main.c b/am-kernels/benchmarks/coremark/src/core_main.c new file mode 100644 index 0000000..0482bc2 --- /dev/null +++ b/am-kernels/benchmarks/coremark/src/core_main.c @@ -0,0 +1,339 @@ +/* +Author : Shay Gal-On, EEMBC + +This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +All rights reserved. + +EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +CoreMark License that is distributed with the official EEMBC COREMARK Software release. +If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +you must discontinue use and download the official release from www.coremark.org. + +Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. + +EEMBC +4354 Town Center Blvd. Suite 114-200 +El Dorado Hills, CA, 95762 +*/ +/* File: core_main.c + This file contains the framework to acquire a block of memory, seed initial parameters, tun t he benchmark and report the results. +*/ +#include "coremark.h" + +/* Function: iterate + Run the benchmark for a specified number of iterations. + + Operation: + For each type of benchmarked algorithm: + a - Initialize the data block for the algorithm. + b - Execute the algorithm N times. + + Returns: + NULL. +*/ +static ee_u16 list_known_crc[] = {(ee_u16)0xd4b0,(ee_u16)0x3340,(ee_u16)0x6a79,(ee_u16)0xe714,(ee_u16)0xe3c1}; +static ee_u16 matrix_known_crc[] = {(ee_u16)0xbe52,(ee_u16)0x1199,(ee_u16)0x5608,(ee_u16)0x1fd7,(ee_u16)0x0747}; +static ee_u16 state_known_crc[] = {(ee_u16)0x5e47,(ee_u16)0x39bf,(ee_u16)0xe5a4,(ee_u16)0x8e3a,(ee_u16)0x8d84}; +void *iterate(void *pres) { + ee_u32 i; + ee_u16 crc; + core_results *res=(core_results *)pres; + ee_u32 iterations=res->iterations; + res->crc=0; + res->crclist=0; + res->crcmatrix=0; + res->crcstate=0; + + for (i=0; icrc=crcu16(crc,res->crc); + crc=core_bench_list(res,-1); + res->crc=crcu16(crc,res->crc); + if (i==0) res->crclist=res->crc; + } + return NULL; +} + +#if (SEED_METHOD==SEED_ARG) +ee_s32 get_seed_args(int i, int argc, char *argv[]); +#define get_seed(x) (ee_s16)get_seed_args(x,argc,argv) +#define get_seed_32(x) get_seed_args(x,argc,argv) +#else /* via function or volatile */ +ee_s32 get_seed_32(int i); +#define get_seed(x) (ee_s16)get_seed_32(x) +#endif + +#if (MEM_METHOD==MEM_STATIC) +ee_u8 static_memblk[TOTAL_DATA_SIZE]; +#endif +char *mem_name[3] = {"Static","Heap","Stack"}; +/* Function: main + Main entry routine for the benchmark. + This function is responsible for the following steps: + + 1 - Initialize input seeds from a source that cannot be determined at compile time. + 2 - Initialize memory block for use. + 3 - Run and time the benchmark. + 4 - Report results, testing the validity of the output if the seeds are known. + + Arguments: + 1 - first seed : Any value + 2 - second seed : Must be identical to first for iterations to be identical + 3 - third seed : Any value, should be at least an order of magnitude less then the input size, but bigger then 32. + 4 - Iterations : Special, if set to 0, iterations will be automatically determined such that the benchmark will run between 10 to 100 secs + +*/ + +#if MAIN_HAS_NOARGC +MAIN_RETURN_TYPE main(void) { + int argc=0; + char *argv[1]; +#else +MAIN_RETURN_TYPE main(int argc, char *argv[]) { +#endif + ee_u16 i,j=0,num_algorithms=0; + ee_s16 known_id=-1,total_errors=0; + ee_u16 seedcrc=0; + CORE_TICKS total_time; + core_results results[MULTITHREAD]; +#if (MEM_METHOD==MEM_STACK) + ee_u8 stack_memblock[TOTAL_DATA_SIZE*MULTITHREAD]; +#endif + + ioe_init(); + + ee_printf("Running CoreMark for %d iterations\n", ITERATIONS); + + /* first call any initializations needed */ + portable_init(&(results[0].port), &argc, argv); + /* First some checks to make sure benchmark will run ok */ + if (sizeof(struct list_head_s)>128) { + ee_printf("list_head structure too big for comparable data!\n"); + return MAIN_RETURN_VAL; + } + results[0].seed1=get_seed(1); + results[0].seed2=get_seed(2); + results[0].seed3=get_seed(3); + results[0].iterations=get_seed_32(4); +#if CORE_DEBUG + results[0].iterations=1; +#endif + results[0].execs=get_seed_32(5); + if (results[0].execs==0) { /* if not supplied, execute all algorithms */ + results[0].execs=ALL_ALGORITHMS_MASK; + } + /* put in some default values based on one seed only for easy testing */ + if ((results[0].seed1==0) && (results[0].seed2==0) && (results[0].seed3==0)) { /* validation run */ + results[0].seed1=0; + results[0].seed2=0; + results[0].seed3=0x66; + } + if ((results[0].seed1==1) && (results[0].seed2==0) && (results[0].seed3==0)) { /* perfromance run */ + results[0].seed1=0x3415; + results[0].seed2=0x3415; + results[0].seed3=0x66; + } +#if (MEM_METHOD==MEM_STATIC) + results[0].memblock[0]=(void *)static_memblk; + results[0].size=TOTAL_DATA_SIZE; + results[0].err=0; + #if (MULTITHREAD>1) + #error "Cannot use a static data area with multiple contexts!" + #endif +#elif (MEM_METHOD==MEM_MALLOC) + for (i=0 ; i1) + if (default_num_contexts>MULTITHREAD) { + default_num_contexts=MULTITHREAD; + } + for (i=0 ; i=0) { + for (i=0 ; i 0) + ee_printf("Iterations/mSec : %f\n",default_num_contexts*results[0].iterations/time_in_secs(total_time)); +#else + ee_printf("Total time (ms) : %d\n",time_in_secs(total_time)); +#endif + ee_printf("Iterations : %d\n",(int)default_num_contexts*results[0].iterations); + ee_printf("Compiler version : %s\n",COMPILER_VERSION); +#if (MULTITHREAD>1) + ee_printf("Parallel %s : %d\n",PARALLEL_METHOD,default_num_contexts); +#endif + /* output for verification */ + ee_printf("seedcrc : 0x%04x\n",seedcrc); + if (results[0].execs & ID_LIST) + for (i=0 ; i0) + ee_printf("Errors detected\n"); + if (total_errors<0) + ee_printf("Cannot validate operation for these seed values, please compare with results on a known platform.\n"); + +#if (MEM_METHOD==MEM_MALLOC) + for (i=0 ; i>(from)) & (~(0xffffffff << (to)))) + +#if CORE_DEBUG +void printmat(MATDAT *A, ee_u32 N, char *name) { + ee_u32 i,j; + ee_printf("Matrix %s [%dx%d]:\n",name,N,N); + for (i=0; i N times, + changing the matrix values slightly by a constant amount each time. +*/ +ee_u16 core_bench_matrix(mat_params *p, ee_s16 seed, ee_u16 crc) { + ee_u32 N=p->N; + MATRES *C=p->C; + MATDAT *A=p->A; + MATDAT *B=p->B; + MATDAT val=(MATDAT)seed; + + crc=crc16(matrix_test(N,C,A,B,val),crc); + + return crc; +} + +/* Function: matrix_test + Perform matrix manipulation. + + Parameters: + N - Dimensions of the matrix. + C - memory for result matrix. + A - input matrix + B - operator matrix (not changed during operations) + + Returns: + A CRC value that captures all results calculated in the function. + In particular, crc of the value calculated on the result matrix + after each step by . + + Operation: + + 1 - Add a constant value to all elements of a matrix. + 2 - Multiply a matrix by a constant. + 3 - Multiply a matrix by a vector. + 4 - Multiply a matrix by a matrix. + 5 - Add a constant value to all elements of a matrix. + + After the last step, matrix A is back to original contents. +*/ +ee_s16 matrix_test(ee_u32 N, MATRES *C, MATDAT *A, MATDAT *B, MATDAT val) { + ee_u16 crc=0; + MATDAT clipval=matrix_big(val); + + matrix_add_const(N,A,val); /* make sure data changes */ +#if CORE_DEBUG + printmat(A,N,"matrix_add_const"); +#endif + matrix_mul_const(N,C,A,val); + crc=crc16(matrix_sum(N,C,clipval),crc); +#if CORE_DEBUG + printmatC(C,N,"matrix_mul_const"); +#endif + matrix_mul_vect(N,C,A,B); + crc=crc16(matrix_sum(N,C,clipval),crc); +#if CORE_DEBUG + printmatC(C,N,"matrix_mul_vect"); +#endif + matrix_mul_matrix(N,C,A,B); + crc=crc16(matrix_sum(N,C,clipval),crc); +#if CORE_DEBUG + printmatC(C,N,"matrix_mul_matrix"); +#endif + matrix_mul_matrix_bitextract(N,C,A,B); + crc=crc16(matrix_sum(N,C,clipval),crc); +#if CORE_DEBUG + printmatC(C,N,"matrix_mul_matrix_bitextract"); +#endif + + matrix_add_const(N,A,-val); /* return matrix to initial value */ + return crc; +} + +/* Function : matrix_init + Initialize the memory block for matrix benchmarking. + + Parameters: + blksize - Size of memory to be initialized. + memblk - Pointer to memory block. + seed - Actual values chosen depend on the seed parameter. + p - pointers to containing initialized matrixes. + + Returns: + Matrix dimensions. + + Note: + The seed parameter MUST be supplied from a source that cannot be determined at compile time +*/ +ee_u32 core_init_matrix(ee_u32 blksize, void *memblk, ee_s32 seed, mat_params *p) { + ee_u32 N=0; + MATDAT *A; + MATDAT *B; + ee_s32 order=1; + MATDAT val; + ee_u32 i=0,j=0; + if (seed==0) + seed=1; + while (jA=A; + p->B=B; + p->C=(MATRES *)align_mem(B+N*N); + p->N=N; +#if CORE_DEBUG + printmat(A,N,"A"); + printmat(B,N,"B"); +#endif + return N; +} + +/* Function: matrix_sum + Calculate a function that depends on the values of elements in the matrix. + + For each element, accumulate into a temporary variable. + + As long as this value is under the parameter clipval, + add 1 to the result if the element is bigger then the previous. + + Otherwise, reset the accumulator and add 10 to the result. +*/ +ee_s16 matrix_sum(ee_u32 N, MATRES *C, MATDAT clipval) { + MATRES tmp=0,prev=0,cur=0; + ee_s16 ret=0; + ee_u32 i,j; + for (i=0; iclipval) { + ret+=10; + tmp=0; + } else { + ret += (cur>prev) ? 1 : 0; + } + prev=cur; + } + } + return ret; +} + +/* Function: matrix_mul_const + Multiply a matrix by a constant. + This could be used as a scaler for instance. +*/ +void matrix_mul_const(ee_u32 N, MATRES *C, MATDAT *A, MATDAT val) { + ee_u32 i,j; + for (i=0; i. + This methodology is taken to accomodate any hardware or simulated platform. + The sample implementation returns millisecs by default, + and the resolution is controlled by +*/ +CORE_TICKS get_time(void) { + return stop_time_val - start_time_val; +} + +/* Function : time_in_secs + Convert the value returned by get_time to seconds. + + The type is used to accomodate systems with no support for floating point. + Default implementation implemented by the EE_TICKS_PER_SEC macro above. +*/ +secs_ret time_in_secs(CORE_TICKS ticks) { + return ticks; +} + +ee_u32 default_num_contexts=1; + +/* Function : portable_init + Target specific initialization code + Test for some common mistakes. +*/ +void portable_init(core_portable *p, int *argc, char *argv[]) +{ + if (sizeof(ee_ptr_int) != sizeof(ee_u8 *)) { + ee_printf("ERROR! Please define ee_ptr_int to a type that holds a pointer!\n"); + } + if (sizeof(ee_u32) != 4) { + ee_printf("ERROR! Please define ee_u32 to a 32b unsigned type!\n"); + } + p->portable_id=1; +} +/* Function : portable_fini + Target specific final code +*/ +void portable_fini(core_portable *p) +{ + p->portable_id=0; +} + + diff --git a/am-kernels/benchmarks/coremark/src/core_state.c b/am-kernels/benchmarks/coremark/src/core_state.c new file mode 100644 index 0000000..ef9e880 --- /dev/null +++ b/am-kernels/benchmarks/coremark/src/core_state.c @@ -0,0 +1,277 @@ +/* +Author : Shay Gal-On, EEMBC + +This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +All rights reserved. + +EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +CoreMark License that is distributed with the official EEMBC COREMARK Software release. +If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +you must discontinue use and download the official release from www.coremark.org. + +Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. + +EEMBC +4354 Town Center Blvd. Suite 114-200 +El Dorado Hills, CA, 95762 +*/ +#include "coremark.h" +/* local functions */ +enum CORE_STATE core_state_transition( ee_u8 **instr , ee_u32 *transition_count); + +/* +Topic: Description + Simple state machines like this one are used in many embedded products. + + For more complex state machines, sometimes a state transition table implementation is used instead, + trading speed of direct coding for ease of maintenance. + + Since the main goal of using a state machine in CoreMark is to excercise the switch/if behaviour, + we are using a small moore machine. + + In particular, this machine tests type of string input, + trying to determine whether the input is a number or something else. + (see core_state.png). +*/ + +/* Function: core_bench_state + Benchmark function + + Go over the input twice, once direct, and once after introducing some corruption. +*/ +ee_u16 core_bench_state(ee_u32 blksize, ee_u8 *memblock, + ee_s16 seed1, ee_s16 seed2, ee_s16 step, ee_u16 crc) +{ + ee_u32 final_counts[NUM_CORE_STATES]; + ee_u32 track_counts[NUM_CORE_STATES]; + ee_u8 *p=memblock; + ee_u32 i; + + +#if CORE_DEBUG + ee_printf("State Bench: %d,%d,%d,%04x\n",seed1,seed2,step,crc); +#endif + for (i=0; i0) { + for(i=0;i>3) & 0x3]; + next=4; + break; + case 3: /* float */ + case 4: /* float */ + buf=floatpat[(seed>>3) & 0x3]; + next=8; + break; + case 5: /* scientific */ + case 6: /* scientific */ + buf=scipat[(seed>>3) & 0x3]; + next=8; + break; + case 7: /* invalid */ + buf=errpat[(seed>>3) & 0x3]; + next=8; + break; + default: /* Never happen, just to make some compilers happy */ + break; + } + } + size++; + while (total='0') & (c<='9')) ? 1 : 0; + return retval; +} + +/* Function: core_state_transition + Actual state machine. + + The state machine will continue scanning until either: + 1 - an invalid input is detcted. + 2 - a valid number has been detected. + + The input pointer is updated to point to the end of the token, and the end state is returned (either specific format determined or invalid). +*/ + +enum CORE_STATE core_state_transition( ee_u8 **instr , ee_u32 *transition_count) { + ee_u8 *str=*instr; + ee_u8 NEXT_SYMBOL; + enum CORE_STATE state=CORE_START; + for( ; *str && state != CORE_INVALID; str++ ) { + NEXT_SYMBOL = *str; + if (NEXT_SYMBOL==',') /* end of this input */ { + str++; + break; + } + switch(state) { + case CORE_START: + if(ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INT; + } + else if( NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-' ) { + state = CORE_S1; + } + else if( NEXT_SYMBOL == '.' ) { + state = CORE_FLOAT; + } + else { + state = CORE_INVALID; + transition_count[CORE_INVALID]++; + } + transition_count[CORE_START]++; + break; + case CORE_S1: + if(ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INT; + transition_count[CORE_S1]++; + } + else if( NEXT_SYMBOL == '.' ) { + state = CORE_FLOAT; + transition_count[CORE_S1]++; + } + else { + state = CORE_INVALID; + transition_count[CORE_S1]++; + } + break; + case CORE_INT: + if( NEXT_SYMBOL == '.' ) { + state = CORE_FLOAT; + transition_count[CORE_INT]++; + } + else if(!ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INVALID; + transition_count[CORE_INT]++; + } + break; + case CORE_FLOAT: + if( NEXT_SYMBOL == 'E' || NEXT_SYMBOL == 'e' ) { + state = CORE_S2; + transition_count[CORE_FLOAT]++; + } + else if(!ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INVALID; + transition_count[CORE_FLOAT]++; + } + break; + case CORE_S2: + if( NEXT_SYMBOL == '+' || NEXT_SYMBOL == '-' ) { + state = CORE_EXPONENT; + transition_count[CORE_S2]++; + } + else { + state = CORE_INVALID; + transition_count[CORE_S2]++; + } + break; + case CORE_EXPONENT: + if(ee_isdigit(NEXT_SYMBOL)) { + state = CORE_SCIENTIFIC; + transition_count[CORE_EXPONENT]++; + } + else { + state = CORE_INVALID; + transition_count[CORE_EXPONENT]++; + } + break; + case CORE_SCIENTIFIC: + if(!ee_isdigit(NEXT_SYMBOL)) { + state = CORE_INVALID; + transition_count[CORE_INVALID]++; + } + break; + default: + break; + } + } + *instr=str; + return state; +} diff --git a/am-kernels/benchmarks/coremark/src/core_util.c b/am-kernels/benchmarks/coremark/src/core_util.c new file mode 100644 index 0000000..03f0fdc --- /dev/null +++ b/am-kernels/benchmarks/coremark/src/core_util.c @@ -0,0 +1,210 @@ +/* +Author : Shay Gal-On, EEMBC + +This file is part of EEMBC(R) and CoreMark(TM), which are Copyright (C) 2009 +All rights reserved. + +EEMBC CoreMark Software is a product of EEMBC and is provided under the terms of the +CoreMark License that is distributed with the official EEMBC COREMARK Software release. +If you received this EEMBC CoreMark Software without the accompanying CoreMark License, +you must discontinue use and download the official release from www.coremark.org. + +Also, if you are publicly displaying scores generated from the EEMBC CoreMark software, +make sure that you are in compliance with Run and Reporting rules specified in the accompanying readme.txt file. + +EEMBC +4354 Town Center Blvd. Suite 114-200 +El Dorado Hills, CA, 95762 +*/ +#include "coremark.h" +/* Function: get_seed + Get a values that cannot be determined at compile time. + + Since different embedded systems and compilers are used, 3 different methods are provided: + 1 - Using a volatile variable. This method is only valid if the compiler is forced to generate code that + reads the value of a volatile variable from memory at run time. + Please note, if using this method, you would need to modify core_portme.c to generate training profile. + 2 - Command line arguments. This is the preferred method if command line arguments are supported. + 3 - System function. If none of the first 2 methods is available on the platform, + a system function which is not a stub can be used. + + e.g. read the value on GPIO pins connected to switches, or invoke special simulator functions. +*/ +#if (SEED_METHOD==SEED_VOLATILE) + extern volatile ee_s32 seed1_volatile; + extern volatile ee_s32 seed2_volatile; + extern volatile ee_s32 seed3_volatile; + extern volatile ee_s32 seed4_volatile; + extern volatile ee_s32 seed5_volatile; + ee_s32 get_seed_32(int i) { + ee_s32 retval; + switch (i) { + case 1: + retval=seed1_volatile; + break; + case 2: + retval=seed2_volatile; + break; + case 3: + retval=seed3_volatile; + break; + case 4: + retval=seed4_volatile; + break; + case 5: + retval=seed5_volatile; + break; + default: + retval=0; + break; + } + return retval; + } +#elif (SEED_METHOD==SEED_ARG) +ee_s32 parseval(char *valstring) { + ee_s32 retval=0; + ee_s32 neg=1; + int hexmode=0; + if (*valstring == '-') { + neg=-1; + valstring++; + } + if ((valstring[0] == '0') && (valstring[1] == 'x')) { + hexmode=1; + valstring+=2; + } + /* first look for digits */ + if (hexmode) { + while (((*valstring >= '0') && (*valstring <= '9')) || ((*valstring >= 'a') && (*valstring <= 'f'))) { + ee_s32 digit=*valstring-'0'; + if (digit>9) + digit=10+*valstring-'a'; + retval*=16; + retval+=digit; + valstring++; + } + } else { + while ((*valstring >= '0') && (*valstring <= '9')) { + ee_s32 digit=*valstring-'0'; + retval*=10; + retval+=digit; + valstring++; + } + } + /* now add qualifiers */ + if (*valstring=='K') + retval*=1024; + if (*valstring=='M') + retval*=1024*1024; + + retval*=neg; + return retval; +} + +ee_s32 get_seed_args(int i, int argc, char *argv[]) { + if (argc>i) + return parseval(argv[i]); + return 0; +} + +#elif (SEED_METHOD==SEED_FUNC) +/* If using OS based function, you must define and implement the functions below in core_portme.h and core_portme.c ! */ +ee_s32 get_seed_32(int i) { + ee_s32 retval; + switch (i) { + case 1: + retval=portme_sys1(); + break; + case 2: + retval=portme_sys2(); + break; + case 3: + retval=portme_sys3(); + break; + case 4: + retval=portme_sys4(); + break; + case 5: + retval=portme_sys5(); + break; + default: + retval=0; + break; + } + return retval; +} +#endif + +/* Function: crc* + Service functions to calculate 16b CRC code. + +*/ +ee_u16 crcu8(ee_u8 data, ee_u16 crc ) +{ + ee_u8 i=0,x16=0,carry=0; + + for (i = 0; i < 8; i++) + { + x16 = (ee_u8)((data & 1) ^ ((ee_u8)crc & 1)); + data >>= 1; + + if (x16 == 1) + { + crc ^= 0x4002; + carry = 1; + } + else + carry = 0; + crc >>= 1; + if (carry) + crc |= 0x8000; + else + crc &= 0x7fff; + } + return crc; +} +ee_u16 crcu16(ee_u16 newval, ee_u16 crc) { + crc=crcu8( (ee_u8) (newval) ,crc); + crc=crcu8( (ee_u8) ((newval)>>8) ,crc); + return crc; +} +ee_u16 crcu32(ee_u32 newval, ee_u16 crc) { + crc=crc16((ee_s16) newval ,crc); + crc=crc16((ee_s16) (newval>>16) ,crc); + return crc; +} +ee_u16 crc16(ee_s16 newval, ee_u16 crc) { + return crcu16((ee_u16)newval, crc); +} + +ee_u8 check_data_types() { + ee_u8 retval=0; + if (sizeof(ee_u8) != 1) { + ee_printf("ERROR: ee_u8 is not an 8b datatype!\n"); + retval++; + } + if (sizeof(ee_u16) != 2) { + ee_printf("ERROR: ee_u16 is not a 16b datatype!\n"); + retval++; + } + if (sizeof(ee_s16) != 2) { + ee_printf("ERROR: ee_s16 is not a 16b datatype!\n"); + retval++; + } + if (sizeof(ee_s32) != 4) { + ee_printf("ERROR: ee_s32 is not a 32b datatype!\n"); + retval++; + } + if (sizeof(ee_u32) != 4) { + ee_printf("ERROR: ee_u32 is not a 32b datatype!\n"); + retval++; + } + if (sizeof(ee_ptr_int) != sizeof(int *)) { + ee_printf("ERROR: ee_ptr_int is not a datatype that holds an int pointer!\n"); + retval++; + } + if (retval>0) { + ee_printf("ERROR: Please modify the datatypes in core_portme.h!\n"); + } + return retval; +} diff --git a/am-kernels/benchmarks/dhrystone/Makefile b/am-kernels/benchmarks/dhrystone/Makefile new file mode 100644 index 0000000..5021855 --- /dev/null +++ b/am-kernels/benchmarks/dhrystone/Makefile @@ -0,0 +1,3 @@ +NAME = dhrystone +SRCS = dry.c +include $(AM_HOME)/Makefile diff --git a/am-kernels/benchmarks/dhrystone/dry.c b/am-kernels/benchmarks/dhrystone/dry.c new file mode 100644 index 0000000..832fe1d --- /dev/null +++ b/am-kernels/benchmarks/dhrystone/dry.c @@ -0,0 +1,950 @@ +/****************** "DHRYSTONE" Benchmark Program ***************************/ +#define Version "C, Version 2.2" +/* File: dhry_1.c (part 2 of 3) + * Author: Reinhold P. Weicker + * Siemens Nixdorf, Paderborn/Germany + * weicker@specbench.org + * Date: May 25, 1988 + * Modified: Steven Pemberton, CWI, Amsterdam; Steven.Pemberton@cwi.nl + * Date: October, 1993; March 1995 + * Included both files into one source, that gets compiled + * in two passes. Made program auto-compiling, and auto-running, + * and generally made it much easier to use. + * + * Original Version (in Ada) published in + * "Communications of the ACM" vol. 27., no. 10 (Oct. 1984), + * pp. 1013 - 1030, together with the statistics + * on which the distribution of statements etc. is based. + * + * In this C version, the following C library functions are used: + * - strcpy, strcmp (inside the measurement loop) + * - printf, scanf (outside the measurement loop) + * In addition, Berkeley UNIX system calls "times ()" or "time ()" + * are used for execution time measurement. For measurements + * on other systems, these calls have to be changed. + * + * Collection of Results: + * Reinhold Weicker (address see above) and + * + * Rick Richardson + * PC Research. Inc. + * 94 Apple Orchard Drive + * Tinton Falls, NJ 07724 + * Phone: (201) 389-8963 (9-17 EST) + * Usenet: ...!uunet!pcrat!rick + * + * Please send results to Rick Richardson and/or Reinhold Weicker. + * Complete information should be given on hardware and software used. + * Hardware information includes: Machine type, CPU, type and size + * of caches; for microprocessors: clock frequency, memory speed + * (number of wait states). + * Software information includes: Compiler (and runtime library) + * manufacturer and version, compilation switches, OS version. + * The Operating System version may give an indication about the compiler; + * Dhrystone itself performs no OS calls in the measurement loop. + * + * The complete output generated by the program should be mailed + * such that at least some checks for correctness can be made. + * + *************************************************************************** + * + * Defines: The following "Defines" are possible: + * -DREG (default: Not defined) + * As an approximation to what an average C programmer + * might do, causes the "register" storage class to be applied + * - for local variables, if they are used (dynamically) + * five or more times + * - for parameters if they are used (dynamically) + * six or more times + * Note that an optimal "register" strategy is + * compiler-dependent, and that "register" declarations + * do not necessarily lead to faster execution. + * -DNOSTRUCTASSIGN (default: Not defined) + * Define if the C compiler does not support + * assignment of structures. + * -DNOENUMS (default: Not defined) + * Define if the C compiler does not support + * enumeration types. + * -DTIMES (default) + * -DTIME + * The "times" function of UNIX (returning process times) + * or the "time" function (returning wallclock time) + * is used for measurement. + * For single user machines, "time ()" is adequate. For + * multi-user machines where you cannot get single-user + * access, use the "times ()" function. If you have + * neither, use a stopwatch in the dead of night. + * "printf"s are provided marking the points "Start Timer" + * and "Stop Timer". DO NOT use the UNIX "time(1)" + * command, as this will measure the total time to + * run this program, which will (erroneously) include + * the time to allocate storage (malloc) and to perform + * the initialization. + * -DHZ=nnn + * In Berkeley UNIX, the function "times" returns process + * time in 1/HZ seconds, with HZ = 60 for most systems. + * CHECK YOUR SYSTEM DESCRIPTION BEFORE YOU JUST APPLY + * A VALUE. + * + *************************************************************************** + * + * History: Version C/2.1 was made for two reasons: + * + * 1) There was an obvious need for a common C version of + * Dhrystone, since C is at present the most popular system + * programming language for the class of processors + * (microcomputers, minicomputers) where Dhrystone is used most. + * There should be, as far as possible, only one C version of + * Dhrystone such that results can be compared without + * restrictions. In the past, the C versions distributed + * by Rick Richardson (Version 1.1) and by Reinhold Weicker + * had small (though not significant) differences. + * + * 2) As far as it is possible without changes to the Dhrystone + * statistics, optimizing compilers should be prevented from + * removing significant statements. + * + * This C version has been developed in cooperation with + * Rick Richardson (Tinton Falls, NJ), it incorporates many + * ideas from the "Version 1.1" distributed previously by + * him over the UNIX network Usenet. + * I also thank Chaim Benedelac (National Semiconductor), + * David Ditzel (SUN), Earl Killian and John Mashey (MIPS), + * Alan Smith and Rafael Saavedra-Barrera (UC at Berkeley) + * for their help with comments on earlier versions of the + * benchmark. + * + * Changes: In the initialization part, this version follows mostly + * Rick Richardson's version distributed via Usenet, not the + * version distributed earlier via floppy disk by Reinhold Weicker. + * As a concession to older compilers, names have been made + * unique within the first 8 characters. + * Inside the measurement loop, this version follows the + * version previously distributed by Reinhold Weicker. + * + * At several places in the benchmark, code has been added, + * but within the measurement loop only in branches that + * are not executed. The intention is that optimizing compilers + * should be prevented from moving code out of the measurement + * loop, or from removing code altogether. Since the statements + * that are executed within the measurement loop have NOT been + * changed, the numbers defining the "Dhrystone distribution" + * (distribution of statements, operand types and locality) + * still hold. Except for sophisticated optimizing compilers, + * execution times for this version should be the same as + * for previous versions. + * + * Since it has proven difficult to subtract the time for the + * measurement loop overhead in a correct way, the loop check + * has been made a part of the benchmark. This does have + * an impact - though a very minor one - on the distribution + * statistics which have been updated for this version. + * + * All changes within the measurement loop are described + * and discussed in the companion paper "Rationale for + * Dhrystone version 2". + * + * Because of the self-imposed limitation that the order and + * distribution of the executed statements should not be + * changed, there are still cases where optimizing compilers + * may not generate code for some statements. To a certain + * degree, this is unavoidable for small synthetic benchmarks. + * Users of the benchmark are advised to check code listings + * whether code is generated for all statements of Dhrystone. + * + * Version 2.1 is identical to version 2.0 distributed via + * the UNIX network Usenet in March 1988 except that it corrects + * some minor deficiencies that were found by users of version 2.0. + * The only change within the measurement loop is that a + * non-executed "else" part was added to the "if" statement in + * Func_3, and a non-executed "else" part removed from Proc_3. + * + * Version C/2.2, Steven Pemberton, October 1993 + * Functionally, identical to version 2.2; the changes are in + * how you compile and use it: + * - Everything is in one file now, but compiled in 2 passes + * - Compile (and run) by running the file through the shell: 'sh dhry.c" + * - Uses the system definition of HZ if one can be found + * - HZ must be defined, otherwise it won't compile (no defaults here) + * - The (uninteresting) output is printed to stderr (dhry2 > /dev/null) + * - The number of loops is passed as a parameter, rather than read + * (dhry2 500000) + * - If the number of loops is insufficient to get a good result, + * it repeats it with loops*10 until it is enough (rather than just + * stopping) + * - Output says which sort of clock it is using, and the HZ value + * - You can use -DREG instead of the -DREG=register of previous versions + * - Some stylistic cleanups. + * + *************************************************************************** + * + * Compilation model and measurement (IMPORTANT): + * + * The following "ground rules" apply for measurements: + * - Separate compilation + * - No procedure merging + * - Otherwise, compiler optimizations are allowed but should be indicated + * - Default results are those without register declarations + * See the companion paper "Rationale for Dhrystone Version 2" for a more + * detailed discussion of these ground rules. + * + * For 16-Bit processors (e.g. 80186, 80286), times for all compilation + * models ("small", "medium", "large" etc.) should be given if possible, + * together with a definition of these models for the compiler system used. + * + ************************************************************************** + * + * Dhrystone (C version) statistics: + * + * [Comment from the first distribution, updated for version 2. + * Note that because of language differences, the numbers are slightly + * different from the Ada version.] + * + * The following program contains statements of a high level programming + * language (here: C) in a distribution considered representative: + * + * assignments 52 (51.0 %) + * control statements 33 (32.4 %) + * procedure, function calls 17 (16.7 %) + * + * 103 statements are dynamically executed. The program is balanced with + * respect to the three aspects: + * + * - statement type + * - operand type + * - operand locality + * operand global, local, parameter, or constant. + * + * The combination of these three aspects is balanced only approximately. + * + * 1. Statement Type: + * ----------------- number + * + * V1 = V2 9 + * (incl. V1 = F(..) + * V = Constant 12 + * Assignment, 7 + * with array element + * Assignment, 6 + * with record component + * -- + * 34 34 + * + * X = Y +|-|"&&"|"|" Z 5 + * X = Y +|-|"==" Constant 6 + * X = X +|- 1 3 + * X = Y *|/ Z 2 + * X = Expression, 1 + * two operators + * X = Expression, 1 + * three operators + * -- + * 18 18 + * + * if .... 14 + * with "else" 7 + * without "else" 7 + * executed 3 + * not executed 4 + * for ... 7 | counted every time + * while ... 4 | the loop condition + * do ... while 1 | is evaluated + * switch ... 1 + * break 1 + * declaration with 1 + * initialization + * -- + * 34 34 + * + * P (...) procedure call 11 + * user procedure 10 + * library procedure 1 + * X = F (...) + * function call 6 + * user function 5 + * library function 1 + * -- + * 17 17 + * --- + * 103 + * + * The average number of parameters in procedure or function calls + * is 1.82 (not counting the function values aX * + * + * 2. Operators + * ------------ + * number approximate + * percentage + * + * Arithmetic 32 50.8 + * + * + 21 33.3 + * - 7 11.1 + * * 3 4.8 + * / (int div) 1 1.6 + * + * Comparison 27 42.8 + * + * == 9 14.3 + * /= 4 6.3 + * > 1 1.6 + * < 3 4.8 + * >= 1 1.6 + * <= 9 14.3 + * + * Logic 4 6.3 + * + * && (AND-THEN) 1 1.6 + * | (OR) 1 1.6 + * ! (NOT) 2 3.2 + * + * -- ----- + * 63 100.1 + * + * + * 3. Operand Type (counted once per operand reference): + * --------------- + * number approximate + * percentage + * + * Integer 175 72.3 % + * Character 45 18.6 % + * Pointer 12 5.0 % + * String30 6 2.5 % + * Array 2 0.8 % + * Record 2 0.8 % + * --- ------- + * 242 100.0 % + * + * When there is an access path leading to the final operand (e.g. a record + * component), only the final data type on the access path is counted. + * + * + * 4. Operand Locality: + * ------------------- + * number approximate + * percentage + * + * local variable 114 47.1 % + * global variable 22 9.1 % + * parameter 45 18.6 % + * value 23 9.5 % + * reference 22 9.1 % + * function result 6 2.5 % + * constant 55 22.7 % + * --- ------- + * 242 100.0 % + * + * The program does not compute anything meaningful, but it is syntactically + * and semantically correct. All variables have a value assigned to them + * before they are used as a source operand. + * + * There has been no explicit effort to account for the effects of a + * cache, or to balance the use of long or short displacements for code or + * data. + * + *************************************************************************** + */ + +/* Compiler and system dependent definitions: */ + +/* variables for time measurement: */ + +#include +#include +#include + +static uint32_t uptime_ms() { return io_read(AM_TIMER_UPTIME).us / 1000; } +#define Start_Timer() Begin_Time = uptime_ms() +#define Stop_Timer() End_Time = uptime_ms() + +#define NUMBER_OF_RUNS 500000 /* Default number of runs */ +#define PASS2 + +#ifdef NOSTRUCTASSIGN +#define structassign(d, s) memcpy(&(d), &(s), sizeof(d)) +#else +#define structassign(d, s) d = s +#endif + +#ifdef NOENUM +#define Ident_1 0 +#define Ident_2 1 +#define Ident_3 2 +#define Ident_4 3 +#define Ident_5 4 + typedef int Enumeration; +#else + typedef enum {Ident_1, Ident_2, Ident_3, Ident_4, Ident_5} + Enumeration; +#endif + /* for boolean and enumeration types in Ada, Pascal */ + +/* General definitions: */ + + +#define Null 0 + /* Value of a Null pointer */ + +typedef int One_Thirty; +typedef int One_Fifty; +typedef char Capital_Letter; +typedef int Boolean; +typedef char Str_30 [31]; +typedef int Arr_1_Dim [50]; +typedef int Arr_2_Dim [50] [50]; + +typedef struct record + { + struct record *Ptr_Comp; + Enumeration Discr; + union { + struct { + Enumeration Enum_Comp; + int Int_Comp; + char Str_Comp [31]; + } var_1; + struct { + Enumeration E_Comp_2; + char Str_2_Comp [31]; + } var_2; + struct { + char Ch_1_Comp; + char Ch_2_Comp; + } var_3; + } variant; + } Rec_Type, *Rec_Pointer; + +/* Global Variables: */ + +Rec_Pointer Ptr_Glob, + Next_Ptr_Glob; +int Int_Glob; +Boolean Bool_Glob; +char Ch_1_Glob, + Ch_2_Glob; +int Arr_1_Glob [50]; +int Arr_2_Glob [50] [50]; + +Enumeration Func_1 (); + /* forward declaration necessary since Enumeration may not simply be int */ + +#ifndef REG + Boolean Reg = false; +#define REG + /* REG becomes defined as empty */ + /* i.e. no register variables */ +#else + Boolean Reg = true; +#undef REG +#define REG register +#endif + +Boolean Done; + +long Begin_Time, + End_Time, + User_Time; +float Microseconds, + Dhrystones_Per_Second; + +/* end of variables for time measurement */ + +static char memory[1024]; +static char *free_mem = &memory[0]; + +static char* myalloc(size_t size) { + while ((unsigned long)free_mem % 4 != 0) free_mem ++; + char *ret = free_mem; + free_mem += size; + return ret; +} + +void Proc_6 (Enumeration, Enumeration*); +void Proc_3 (Rec_Pointer*); +void Proc_7 (One_Fifty a, One_Fifty b, One_Fifty* c); +Boolean Func_2 (Str_30, Str_30); +void Proc_8(Arr_1_Dim, Arr_2_Dim, int, int); +Boolean Func_3 (Enumeration); + +void Proc_1 (Ptr_Val_Par) +/******************/ + +REG Rec_Pointer Ptr_Val_Par; + /* executed once */ +{ + REG Rec_Pointer Next_Record = Ptr_Val_Par->Ptr_Comp; + /* == Ptr_Glob_Next */ + /* Local variable, initialized with Ptr_Val_Par->Ptr_Comp, */ + /* corresponds to "rename" in Ada, "with" in Pascal */ + + structassign (*Ptr_Val_Par->Ptr_Comp, *Ptr_Glob); + Ptr_Val_Par->variant.var_1.Int_Comp = 5; + Next_Record->variant.var_1.Int_Comp + = Ptr_Val_Par->variant.var_1.Int_Comp; + Next_Record->Ptr_Comp = Ptr_Val_Par->Ptr_Comp; + Proc_3 (&Next_Record->Ptr_Comp); + /* Ptr_Val_Par->Ptr_Comp->Ptr_Comp + == Ptr_Glob->Ptr_Comp */ + if (Next_Record->Discr == Ident_1) + /* then, executed */ + { + Next_Record->variant.var_1.Int_Comp = 6; + Proc_6 (Ptr_Val_Par->variant.var_1.Enum_Comp, + &Next_Record->variant.var_1.Enum_Comp); + Next_Record->Ptr_Comp = Ptr_Glob->Ptr_Comp; + Proc_7 (Next_Record->variant.var_1.Int_Comp, 10, + &Next_Record->variant.var_1.Int_Comp); + } + else /* not executed */ + structassign (*Ptr_Val_Par, *Ptr_Val_Par->Ptr_Comp); +} /* Proc_1 */ + + +void Proc_2 (Int_Par_Ref) +/******************/ + /* executed once */ + /* *Int_Par_Ref == 1, becomes 4 */ + +One_Fifty *Int_Par_Ref; +{ + One_Fifty Int_Loc; + Enumeration Enum_Loc; + + Int_Loc = *Int_Par_Ref + 10; + do /* executed once */ + if (Ch_1_Glob == 'A') + /* then, executed */ + { + Int_Loc -= 1; + *Int_Par_Ref = Int_Loc - Int_Glob; + Enum_Loc = Ident_1; + } /* if */ + while (Enum_Loc != Ident_1); /* true */ +} /* Proc_2 */ + + +void Proc_3 (Ptr_Ref_Par) +/******************/ + /* executed once */ + /* Ptr_Ref_Par becomes Ptr_Glob */ + +Rec_Pointer *Ptr_Ref_Par; + +{ + if (Ptr_Glob != Null) + /* then, executed */ + *Ptr_Ref_Par = Ptr_Glob->Ptr_Comp; + Proc_7 (10, Int_Glob, &Ptr_Glob->variant.var_1.Int_Comp); +} /* Proc_3 */ + + +void Proc_4 () /* without parameters */ +/*******/ + /* executed once */ +{ + Boolean Bool_Loc; + + Bool_Loc = Ch_1_Glob == 'A'; + Bool_Glob = Bool_Loc | Bool_Glob; + Ch_2_Glob = 'B'; +} /* Proc_4 */ + + +void Proc_5 () /* without parameters */ +/*******/ + /* executed once */ +{ + Ch_1_Glob = 'A'; + Bool_Glob = false; +} /* Proc_5 */ + + + /* Procedure for the assignment of structures, */ + /* if the C compiler doesn't support this feature */ +#ifdef NOSTRUCTASSIGN +memcpy (d, s, l) +register char *d; +register char *s; +register int l; +{ + while (l--) *d++ = *s++; +} +#endif + + +#ifndef REG +#define REG + /* REG becomes defined as empty */ + /* i.e. no register variables */ +#else +#undef REG +#define REG register +#endif + +extern int Int_Glob; +extern char Ch_1_Glob; + + +void Proc_6 (Enum_Val_Par, Enum_Ref_Par) +/*********************************/ + /* executed once */ + /* Enum_Val_Par == Ident_3, Enum_Ref_Par becomes Ident_2 */ + +Enumeration Enum_Val_Par; +Enumeration *Enum_Ref_Par; +{ + *Enum_Ref_Par = Enum_Val_Par; + if (! Func_3 (Enum_Val_Par)) + /* then, not executed */ + *Enum_Ref_Par = Ident_4; + switch (Enum_Val_Par) + { + case Ident_1: + *Enum_Ref_Par = Ident_1; + break; + case Ident_2: + if (Int_Glob > 100) + /* then */ + *Enum_Ref_Par = Ident_1; + else *Enum_Ref_Par = Ident_4; + break; + case Ident_3: /* executed */ + *Enum_Ref_Par = Ident_2; + break; + case Ident_4: break; + case Ident_5: + *Enum_Ref_Par = Ident_3; + break; + } /* switch */ +} /* Proc_6 */ + + +void Proc_7 (One_Fifty Int_1_Par_Val, One_Fifty Int_2_Par_Val, One_Fifty *Int_Par_Ref) +{ + One_Fifty Int_Loc; + + Int_Loc = Int_1_Par_Val + 2; + *Int_Par_Ref = Int_2_Par_Val + Int_Loc; +} /* Proc_7 */ + + +void Proc_8 (Arr_1_Par_Ref, Arr_2_Par_Ref, Int_1_Par_Val, Int_2_Par_Val) +/*********************************************************************/ + /* executed once */ + /* Int_Par_Val_1 == 3 */ + /* Int_Par_Val_2 == 7 */ +Arr_1_Dim Arr_1_Par_Ref; +Arr_2_Dim Arr_2_Par_Ref; +int Int_1_Par_Val; +int Int_2_Par_Val; +{ + REG One_Fifty Int_Index; + REG One_Fifty Int_Loc; + + Int_Loc = Int_1_Par_Val + 5; + Arr_1_Par_Ref [Int_Loc] = Int_2_Par_Val; + Arr_1_Par_Ref [Int_Loc+1] = Arr_1_Par_Ref [Int_Loc]; + Arr_1_Par_Ref [Int_Loc+30] = Int_Loc; + for (Int_Index = Int_Loc; Int_Index <= Int_Loc+1; ++Int_Index) + Arr_2_Par_Ref [Int_Loc] [Int_Index] = Int_Loc; + Arr_2_Par_Ref [Int_Loc] [Int_Loc-1] += 1; + Arr_2_Par_Ref [Int_Loc+20] [Int_Loc] = Arr_1_Par_Ref [Int_Loc]; + Int_Glob = 5; +} /* Proc_8 */ + + +Enumeration Func_1 (Ch_1_Par_Val, Ch_2_Par_Val) +/*************************************************/ + /* executed three times */ + /* first call: Ch_1_Par_Val == 'H', Ch_2_Par_Val == 'R' */ + /* second call: Ch_1_Par_Val == 'A', Ch_2_Par_Val == 'C' */ + /* third call: Ch_1_Par_Val == 'B', Ch_2_Par_Val == 'C' */ + +Capital_Letter Ch_1_Par_Val; +Capital_Letter Ch_2_Par_Val; +{ + Capital_Letter Ch_1_Loc; + Capital_Letter Ch_2_Loc; + + Ch_1_Loc = Ch_1_Par_Val; + Ch_2_Loc = Ch_1_Loc; + if (Ch_2_Loc != Ch_2_Par_Val) + /* then, executed */ + return (Ident_1); + else /* not executed */ + { + Ch_1_Glob = Ch_1_Loc; + return (Ident_2); + } +} /* Func_1 */ + + +Boolean Func_2 (Str_1_Par_Ref, Str_2_Par_Ref) +/*************************************************/ + /* executed once */ + /* Str_1_Par_Ref == "DHRYSTONE PROGRAM, 1'ST STRING" */ + /* Str_2_Par_Ref == "DHRYSTONE PROGRAM, 2'ND STRING" */ + +Str_30 Str_1_Par_Ref; +Str_30 Str_2_Par_Ref; +{ + REG One_Thirty Int_Loc; + Capital_Letter Ch_Loc; + + Int_Loc = 2; + while (Int_Loc <= 2) /* loop body executed once */ + if (Func_1 (Str_1_Par_Ref[Int_Loc], + Str_2_Par_Ref[Int_Loc+1]) == Ident_1) + /* then, executed */ + { + Ch_Loc = 'A'; + Int_Loc += 1; + } /* if, while */ + if (Ch_Loc >= 'W' && Ch_Loc < 'Z') + /* then, not executed */ + Int_Loc = 7; + if (Ch_Loc == 'R') { + /* then, not executed */ + return (true); + } + else /* executed */ + { + if (strcmp (Str_1_Par_Ref, Str_2_Par_Ref) > 0) + { + Int_Loc += 7; + Int_Glob = Int_Loc; + return (true); + } + else /* executed */ + return (false); + } /* if Ch_Loc */ +} /* Func_2 */ + + +Boolean Func_3 (Enum_Par_Val) +/***************************/ + /* executed once */ + /* Enum_Par_Val == Ident_3 */ +Enumeration Enum_Par_Val; +{ + Enumeration Enum_Loc; + + Enum_Loc = Enum_Par_Val; + if (Enum_Loc == Ident_3) + /* then, executed */ + return (true); + else /* not executed */ + return (false); +} /* Func_3 */ + + +Boolean pass = true; +Boolean check(int cond) { + if (!cond) pass = false; + return cond; +} +int main () +/*****/ + + /* main program, corresponds to procedures */ + /* Main and Proc_0 in the Ada version */ +{ + One_Fifty Int_1_Loc; + REG One_Fifty Int_2_Loc; + One_Fifty Int_3_Loc; + REG char Ch_Index; + Enumeration Enum_Loc; + Str_30 Str_1_Loc; + Str_30 Str_2_Loc; + REG int Run_Index; + REG int Number_Of_Runs; + + ioe_init(); + + Number_Of_Runs = NUMBER_OF_RUNS; + + /* Initializations */ + + Next_Ptr_Glob = (Rec_Pointer) myalloc (sizeof (Rec_Type)); + Ptr_Glob = (Rec_Pointer) myalloc (sizeof (Rec_Type)); + + Ptr_Glob->Ptr_Comp = Next_Ptr_Glob; + Ptr_Glob->Discr = Ident_1; + Ptr_Glob->variant.var_1.Enum_Comp = Ident_3; + Ptr_Glob->variant.var_1.Int_Comp = 40; + strcpy (Ptr_Glob->variant.var_1.Str_Comp, + "DHRYSTONE PROGRAM, SOME STRING"); + strcpy (Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING"); + + Arr_2_Glob [8][7] = 10; + /* Was missing in published program. Without this statement, */ + /* Arr_2_Glob [8][7] would have an undefined value. */ + /* Warning: With 16-Bit processors and Number_Of_Runs > 32000, */ + /* overflow may occur for this array element. */ + + printf ("Dhrystone Benchmark, Version %s\n", Version); + + Done = false; + while (!Done) { + + printf ("Trying %d runs through Dhrystone.\n", Number_Of_Runs); + + /***************/ + /* Start timer */ + /***************/ + + Start_Timer(); + + for (Run_Index = 1; Run_Index <= Number_Of_Runs; ++Run_Index) + { + + Proc_5(); + Proc_4(); + /* Ch_1_Glob == 'A', Ch_2_Glob == 'B', Bool_Glob == true */ + Int_1_Loc = 2; + Int_2_Loc = 3; + strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING"); + Enum_Loc = Ident_2; + Bool_Glob = ! Func_2 (Str_1_Loc, Str_2_Loc); + /* Bool_Glob == 1 */ + while (Int_1_Loc < Int_2_Loc) /* loop body executed once */ + { + Int_3_Loc = 5 * Int_1_Loc - Int_2_Loc; + /* Int_3_Loc == 7 */ + Proc_7 (Int_1_Loc, Int_2_Loc, &Int_3_Loc); + /* Int_3_Loc == 7 */ + Int_1_Loc += 1; + } /* while */ + /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ + Proc_8 (Arr_1_Glob, Arr_2_Glob, Int_1_Loc, Int_3_Loc); + /* Int_Glob == 5 */ + Proc_1 (Ptr_Glob); + for (Ch_Index = 'A'; Ch_Index <= Ch_2_Glob; ++Ch_Index) + /* loop body executed twice */ + { + if (Enum_Loc == Func_1 (Ch_Index, 'C')) + /* then, not executed */ + { + Proc_6 (Ident_1, &Enum_Loc); + strcpy (Str_2_Loc, "DHRYSTONE PROGRAM, 3'RD STRING"); + Int_2_Loc = Run_Index; + Int_Glob = Run_Index; + } + } + /* Int_1_Loc == 3, Int_2_Loc == 3, Int_3_Loc == 7 */ + Int_2_Loc = Int_2_Loc * Int_1_Loc; + Int_1_Loc = Int_2_Loc / Int_3_Loc; + Int_2_Loc = 7 * (Int_2_Loc - Int_3_Loc) - Int_1_Loc; + /* Int_1_Loc == 1, Int_2_Loc == 13, Int_3_Loc == 7 */ + Proc_2 (&Int_1_Loc); + /* Int_1_Loc == 5 */ + + } /* loop "for Run_Index" */ + + /**************/ + /* Stop timer */ + /**************/ + + Stop_Timer(); + + User_Time = End_Time - Begin_Time; + + Done = true; + } + + if (!check(Int_Glob == 5)) { + printf("Int_Glob: %d\n", Int_Glob); + printf(" should be: %d\n", 5); + } + if (!check(Bool_Glob == 1)) { + printf("Bool_Glob: %d\n", Bool_Glob); + printf(" should be: %d\n", 1); + } + if (!check(Ch_1_Glob == 'A')) { + printf("Ch_1_Glob: %c\n", Ch_1_Glob); + printf(" should be: %c\n", 'A'); + } + if (!check(Ch_2_Glob == 'B')) { + printf("Ch_2_Glob: %c\n", Ch_2_Glob); + printf(" should be: %c\n", 'B'); + } + if (!check(Arr_1_Glob[8] == 7)) { + printf("Arr_1_Glob[8]: %d\n", Arr_1_Glob[8]); + printf(" should be: %d\n", 7); + } + if (!check(Arr_2_Glob[8][7] == Number_Of_Runs + 10)) { + printf("Arr_2_Glob[8][7]: %d\n", Arr_2_Glob[8][7]); + printf(" should be: Number_Of_Runs + 10\n"); + } + + if (!check((int)Ptr_Glob->Discr == 0)) { + printf("Ptr_Glob->Discr: %d\n", Ptr_Glob->Discr); + printf(" should be: %d\n", 0); + } + if (!check(Ptr_Glob->variant.var_1.Enum_Comp == 2)) { + printf("Ptr_Glob->Enum_Comp: %d\n", Ptr_Glob->variant.var_1.Enum_Comp); + printf(" should be: %d\n", 2); + } + if (!check(Ptr_Glob->variant.var_1.Int_Comp == 17)) { + printf("Ptr_Glob->Int_Comp: %d\n", Ptr_Glob->variant.var_1.Int_Comp); + printf(" should be: %d\n", 17); + } + if (!check(strcmp(Ptr_Glob->variant.var_1.Str_Comp, "DHRYSTONE PROGRAM, SOME STRING") == 0)) { + printf("Ptr_Glob->Str_Comp: %s\n", Ptr_Glob->variant.var_1.Str_Comp); + printf(" should be: DHRYSTONE PROGRAM, SOME STRING\n"); + } + + if (!check((int)Next_Ptr_Glob->Discr == 0)) { + printf("Next_Ptr_Glob->Discr: %d\n", Next_Ptr_Glob->Discr); + printf(" should be: %d\n", 0); + } + if (!check(Next_Ptr_Glob->variant.var_1.Enum_Comp == 1)) { + printf("Next_Ptr_Glob->Enum_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Enum_Comp); + printf(" should be: %d\n", 1); + } + if (!check(Next_Ptr_Glob->variant.var_1.Int_Comp == 18)) { + printf("Next_Ptr_Glob->Int_Comp: %d\n", Next_Ptr_Glob->variant.var_1.Int_Comp); + printf(" should be: %d\n", 18); + } + if (!check(strcmp(Next_Ptr_Glob->variant.var_1.Str_Comp, "DHRYSTONE PROGRAM, SOME STRING") == 0)) { + printf("Next_Ptr_Glob->Str_Comp: %s\n", Next_Ptr_Glob->variant.var_1.Str_Comp); + printf(" should be: DHRYSTONE PROGRAM, SOME STRING\n"); + } + + if (!check(Int_1_Loc == 5)) { + printf("Int_1_Loc: %d\n", Int_1_Loc); + printf(" should be: %d\n", 5); + } + if (!check(Int_2_Loc == 13)) { + printf("Int_2_Loc: %d\n", Int_2_Loc); + printf(" should be: %d\n", 13); + } + if (!check(Int_3_Loc == 7)) { + printf("Int_3_Loc: %d\n", Int_3_Loc); + printf(" should be: %d\n", 7); + } + if (!check(Enum_Loc == 1)) { + printf("Enum_Loc: %d\n", Enum_Loc); + printf(" should be: %d\n", 1); + } + + if (!check(strcmp(Str_1_Loc, "DHRYSTONE PROGRAM, 1'ST STRING") == 0)) { + printf("Str_1_Loc: %s\n", Str_1_Loc); + printf(" should be: DHRYSTONE PROGRAM, 1'ST STRING\n"); + } + if (!check(strcmp(Str_2_Loc, "DHRYSTONE PROGRAM, 2'ND STRING") == 0)) { + printf("Str_2_Loc: %s\n", Str_2_Loc); + printf(" should be: DHRYSTONE PROGRAM, 2'ND STRING\n"); + } + + printf ("Finished in %d ms\n", (int)User_Time); + printf("==================================================\n"); + printf("Dhrystone %s %d Marks\n", pass ? "PASS" : "FAIL", + 880900 / (int)User_Time * NUMBER_OF_RUNS/ 500000); + printf(" vs. 100000 Marks (i7-7700K @ 4.20GHz)\n"); + + return (pass ? 0 : 1); +} + + diff --git a/am-kernels/benchmarks/microbench/Makefile b/am-kernels/benchmarks/microbench/Makefile new file mode 100644 index 0000000..fb51024 --- /dev/null +++ b/am-kernels/benchmarks/microbench/Makefile @@ -0,0 +1,3 @@ +NAME = microbench +SRCS = $(shell find src/ -name "*.c" -o -name "*.cc") +include $(AM_HOME)/Makefile diff --git a/am-kernels/benchmarks/microbench/README.md b/am-kernels/benchmarks/microbench/README.md new file mode 100644 index 0000000..9bbc9a8 --- /dev/null +++ b/am-kernels/benchmarks/microbench/README.md @@ -0,0 +1,68 @@ +# MicroBench + +CPU正确性和性能测试用基准程序。对AbstractMachine的要求： + +1. 需要实现TRM和IOE的API。 +2. 在IOE的全部实现均留空的情况下仍可运行。如果有正确实现的`AM_TIMER_UPTIME`，可以输出正确的统计时间。若这个功能没有实现(返回`0`)，仍可进行正确性测试。 +3. 使用`putch(ch)`输出。 +4. 堆区`heap`必须初始化(堆区可为空)。如果`heap.start == heap.end`，即分配了空的堆区，只能运行不使用堆区的测试程序。每个基准程序会预先指定堆区的大小，堆区不足的基准程序将被忽略。 + +## 使用方法 + +同一组程序分成四组：test，train，ref和huge。 + +| 名称 | 动态指令数 | 计时 | 计分 | 建议使用场景 | +| ----- | ----------- | ---- | ---- | ----- | +| test | 约300K | X | X | 正确性测试 | +| train | 约60M | O | X | 在RTL仿真环境中研究微结构行为 | +| ref | 约2B | O | O | 在模拟器或FPGA环境中评估处理器性能 | +| huge | 约50B | O | O | 衡量高性能处理器(如真机)的性能 | + +默认运行ref数据规模，可通过`mainargs`选择其它的数据规模, 如: +```bash +make ARCH=native run mainargs=huge +``` + +## 评分根据 + +每个benchmark都记录以`REF_CPU`为基础测得的运行时间微秒数。每个benchmark的评分是相对于`REF_CPU`的运行速度，与基准处理器一样快的得分为`REF_SCORE=100000`。 + +所有benchmark的平均得分是整体得分。 + +## 已有的基准程序 + +| 名称 | 描述 | ref堆区使用 | huge堆区使用 | +| ----- | -------------------------------------------- | ----- | ----- | +| qsort | 快速排序随机整数数组 | 640KB | 16MB | +| queen | 位运算实现的n皇后问题 | 0 | 0 | +| bf | Brainf**k解释器，快速排序输入的字符串 | 32KB | 32KB | +| fib | Fibonacci数列f(n)=f(n-1)+…+f(n-m)的矩阵求解 | 256KB | 2MB | +| sieve | Eratosthenes筛法求素数 | 2MB | 10MB | +| 15pz | A*算法求解4x4数码问题 | 2MB | 64MB | +| dinic | Dinic算法求解二分图最大流 | 680KB | 2MB | +| lzip | Lzip数据压缩 | 4MB | 64MB | +| ssort | Skew算法后缀排序 | 4MB | 64MB | +| md5 | 计算长随机字符串的MD5校验和 | 10MB | 64MB | + +## 增加一个基准程序`foo` + +在`src/`目录下建立名为`foo`的目录，将源代码文件放入。 + +每个基准程序需要实现三个函数： + +* `void bench_foo_prepare();`：进行准备工作，如初始化随机数种子、为数组分配内存等。运行时环境不保证全局变量和堆区的初始值，因此基准程序使用的全局数据必须全部初始化。 +* `void bench_foo_run();`：实际运行基准程序。只有这个函数会被计时。 +* `int bench_foo_validate();`：验证基准程序运行结果。正确返回1，错误返回0。 + +在`benchmark.h`的`BENCHMARK_LIST`中增加相应的`def`项，格式参考已有的benchmark。 + +## 基准程序可以使用的库函数 + +虽然klib中提供了一些函数，但不同的klib实现会导致性能测试结果有差异。 +因此MicroBench中内置一些简单的库函数: + +* `bench_memcpy(void *dst, const void *src, size_t n)`: 内存复制。 +* `bench_srand(uint seed)`：用seed初始化随机数种子。 +* `bench_rand()`：返回一个0..32767之间的随机数。 +* `bench_alloc`/`bench_free`：内存分配/回收。目前回收是空操作。 + diff --git a/am-kernels/benchmarks/microbench/include/benchmark.h b/am-kernels/benchmarks/microbench/include/benchmark.h new file mode 100644 index 0000000..f6fdef1 --- /dev/null +++ b/am-kernels/benchmarks/microbench/include/benchmark.h @@ -0,0 +1,123 @@ +#ifndef __BENCHMARK_H__ +#define __BENCHMARK_H__ + +#include +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +#define MB * 1024 * 1024 +#define KB * 1024 + +#define REF_CPU "i9-9900K @ 3.60GHz" +#define REF_SCORE 100000 + +#define REPEAT 1 + +// size | heap | time | checksum +#define QSORT_S { 100, 1 KB, 0, 0x08467105} +#define QSORT_M { 30000, 128 KB, 0, 0xa3e99fe4} +#define QSORT_L { 100000, 640 KB, 4404, 0xed8cff89} +#define QSORT_H { 4000000, 16 MB,227620, 0xe6178735} +#define QUEEN_S { 8, 0 KB, 0, 0x0000005c} +#define QUEEN_M { 11, 0 KB, 0, 0x00000a78} +#define QUEEN_L { 12, 0 KB, 4069, 0x00003778} +#define QUEEN_H { 15, 0 KB,819996, 0x0022c710} +#define BF_S { 2, 32 KB, 0, 0xa6f0079e} +#define BF_M { 25, 32 KB, 0, 0xa88f8a65} +#define BF_L { 180, 32 KB, 16815, 0x9221e2b3} +#define BF_H { 1360, 32 KB,771535, 0xdb49fbde} +#define FIB_S { 2, 1 KB, 0, 0x7cfeddf0} +#define FIB_M { 23, 16 KB, 0, 0x94ad8800} +#define FIB_L { 91, 256 KB, 20168, 0xebdc5f80} +#define FIB_H { 300, 2 MB,775012, 0xe30a6f00} +#define SIEVE_S { 100, 1 KB, 0, 0x00000019} +#define SIEVE_M { 200000, 32 KB, 0, 0x00004640} +#define SIEVE_L {10000000, 2 MB, 34823, 0x000a2403} +#define SIEVE_H {80000000, 10 MB,301058, 0x00473fc6} +#define PZ15_S { 0, 1 KB, 0, 0x00000006} +#define PZ15_M { 1, 256 KB, 0, 0x0000b0df} +#define PZ15_L { 2, 2 MB, 5360, 0x00068b8c} +#define PZ15_H { 3, 64 MB,300634, 0x01027b4a} +#define DINIC_S { 10, 8 KB, 0, 0x0000019c} +#define DINIC_M { 80, 512 KB, 0, 0x00004f99} +#define DINIC_L { 128, 680 KB, 8182, 0x0000c248} +#define DINIC_H { 190, 2 MB,671978, 0x00014695} +#define LZIP_S { 128, 128 KB, 0, 0xe05fc832} +#define LZIP_M { 50000, 1 MB, 0, 0xdc93e90c} +#define LZIP_L { 1048576, 4 MB, 6795, 0x8d62c81f} +#define LZIP_H {31457280, 64 MB,199541, 0x1b859d76} +#define SSORT_S { 100, 4 KB, 0, 0x4c555e09} +#define SSORT_M { 10000, 512 KB, 0, 0x0db7909b} +#define SSORT_L { 100000, 4 MB, 4002, 0x4f0ab431} +#define SSORT_H { 3000000, 64 MB,322232, 0xeddbd9b6} +#define MD5_S { 100, 1 KB, 0, 0xf902f28f} +#define MD5_M { 200000, 256 KB, 0, 0xd4f9bc6d} +#define MD5_L {10000000, 10 MB, 15199, 0x27286a42} +#define MD5_H {64000000, 64 MB, 97148, 0x41ab4d60} + +#define BENCHMARK_LIST(def) \ + def(qsort, "qsort", QSORT_S, QSORT_M, QSORT_L, QSORT_H, "Quick sort") \ + def(queen, "queen", QUEEN_S, QUEEN_M, QUEEN_L, QUEEN_H, "Queen placement") \ + def( bf, "bf", BF_S, BF_M, BF_L, BF_H, "Brainf**k interpreter") \ + def( fib, "fib", FIB_S, FIB_M, FIB_L, FIB_H, "Fibonacci number") \ + def(sieve, "sieve", SIEVE_S, SIEVE_M, SIEVE_L, SIEVE_H, "Eratosthenes sieve") \ + def( 15pz, "15pz", PZ15_S, PZ15_M, PZ15_L, PZ15_H, "A* 15-puzzle search") \ + def(dinic, "dinic", DINIC_S, DINIC_M, DINIC_L, DINIC_H, "Dinic's maxflow algorithm") \ + def( lzip, "lzip", LZIP_S, LZIP_M, LZIP_L, LZIP_H, "Lzip compression") \ + def(ssort, "ssort", SSORT_S, SSORT_M, SSORT_L, SSORT_H, "Suffix sort") \ + def( md5, "md5", MD5_S, MD5_M, MD5_L, MD5_H, "MD5 digest") \ + +// Each benchmark will run REPEAT times + +#define DECL(_name, _sname, _s, _m, _l, _h, _desc) \ + void bench_##_name##_prepare(); \ + void bench_##_name##_run(); \ + int bench_##_name##_validate(); + +BENCHMARK_LIST(DECL) + +typedef struct Setting { + int size; + unsigned long mlim, ref; + uint32_t checksum; +} Setting; + +typedef struct Benchmark { + void (*prepare)(); + void (*run)(); + int (*validate)(); + const char *name, *desc; + Setting settings[4]; +} Benchmark; + +extern Benchmark *current; +extern Setting *setting; + +typedef struct Result { + int pass; + uint64_t usec; +} Result; + +void prepare(Result *res); +void done(Result *res); + +// memory allocation +void* bench_alloc(size_t size); +void bench_free(void *ptr); + +// random number generator +void bench_srand(uint32_t seed); +uint32_t bench_rand(); // return a random number between 0..32767 + +// checksum +uint32_t checksum(void *start, void *end); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/am-kernels/benchmarks/microbench/src/15pz/15pz.cc b/am-kernels/benchmarks/microbench/src/15pz/15pz.cc new file mode 100644 index 0000000..e2a6f56 --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/15pz/15pz.cc @@ -0,0 +1,96 @@ +#include +#include "puzzle.h" +#include "heap.h" + +const int N = 4; + +static int PUZZLE_S[N*N] = { + 1, 2, 3, 4, + 5, 6, 7, 8, + 9, 10, 0, 11, + 13, 14, 15, 12, +}; + +static int PUZZLE_M[N*N] = { + 1, 2, 3, 4, + 5, 6, 7, 8, + 12, 0, 14, 13, + 11, 15, 10, 9, +}; + +static int PUZZLE_L[N*N] = { + 0, 2, 3, 4, + 9, 6, 7, 8, + 5, 11, 10, 12, + 1, 15, 13, 14, +}; + +static int PUZZLE_H[N*N] = { + 2, 6, 8, 0, + 9, 15, 4, 12, + 5, 13, 11,14, + 1, 7, 3, 10, +}; + +static int ans; + +extern "C" { + +void bench_15pz_prepare() { +} + +void bench_15pz_run() { + N_puzzle puzzle; + int MAXN; + + switch (setting->size) { + case 0: puzzle = N_puzzle(PUZZLE_S); MAXN = 10; break; + case 1: puzzle = N_puzzle(PUZZLE_M); MAXN = 2048; break; + case 2: puzzle = N_puzzle(PUZZLE_L); MAXN = 16384; break; + case 3: puzzle = N_puzzle(PUZZLE_H); MAXN = 786432; break; + default: assert(0); + } + assert(puzzle.solvable()); + + auto *heap = (Updatable_heap> *) bench_alloc(sizeof(Updatable_heap>)); + heap->init(MAXN); + heap->push( puzzle, 0 ); + + int n = 0; + ans = -1; + + while( heap->size() != 0 && n != MAXN ) { + N_puzzle top = heap->pop(); + ++n; + + if ( top == N_puzzle::solution() ) { + // We are done + ans = heap->length(top) * n; + return; + } + + if ( top.tile_left_possible() ) { + heap->push( top.tile_left(), heap->length( top ) + 1 ); + } + + if ( top.tile_right_possible() ) { + heap->push( top.tile_right(), heap->length( top ) + 1 ); + } + + if ( top.tile_up_possible() ) { + heap->push( top.tile_up(), heap->length( top ) + 1 ); + } + + if ( top.tile_down_possible() ) { + heap->push( top.tile_down(), heap->length( top ) + 1 ); + } + } +} + + +int bench_15pz_validate() { + return (uint32_t)ans == setting->checksum; +} + +} + diff --git a/am-kernels/benchmarks/microbench/src/15pz/heap.h b/am-kernels/benchmarks/microbench/src/15pz/heap.h new file mode 100644 index 0000000..9fa1e6a --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/15pz/heap.h @@ -0,0 +1,227 @@ +// Author: Douglas Wilhelm Harder +// Copyright (c) 2009 by Douglas Wilhelm Harder. All rights reserved. + +template +T max(T a, T b) { + return a > b ? a : b; +} + +template +class Updatable_heap { + private: + int M; + class Step; + Step **hash_table; + Step **heap; + int heap_size; + int maximum_heap_size; + + void inline swap( int, int ); + void percolate_down(); + void percolate_up( int ); + Step *pointer( T const & ) const; + + public: + void init(int m); + ~Updatable_heap(); + T pop(); + void push( T const &, int ); + int size() const; + int maximum_size() const; + int length( T const & ) const; +}; + +template +class Updatable_heap::Step { + public: + T element; + Step *next; + int heap_index; + int path_length; + int path_weight; + bool visited; + Step *previous_step; + + void init( T const &, Step *, int, int ); + int length() const; + int weight() const; +}; + +template +void Updatable_heap::init(int m) { + M = m; + heap = (Step **)bench_alloc(sizeof(void *) * M); + hash_table = (Step **)bench_alloc(sizeof(void *) * (M + 1)); + + heap_size = 0; + maximum_heap_size = 0; + for ( int i = 0; i < M; ++i ) { + hash_table[i] = 0; + } +} + +template +Updatable_heap::~Updatable_heap() { + for ( int i = 0; i < M; ++i ) { + Step *ptr = hash_table[i]; + + while ( ptr != 0 ) { + Step *tmp = ptr; + ptr = ptr->next; + } + } +} + +template +T Updatable_heap::pop() { + if ( size() == 0 ) { + return T(); + } + + T top = heap[1]->element; + + if ( size() == 1 ) { + heap_size = 0; + } else { + assert( size() > 1 ); + + heap[1] = heap[size()]; + heap[1]->heap_index = 1; + + --heap_size; + percolate_down(); + } + + return top; +} + +template +void inline Updatable_heap::swap( int i, int j ) { + Step *tmp = heap[j]; + heap[j] = heap[i]; + heap[i] = tmp; + + heap[i]->heap_index = i; + heap[j]->heap_index = j; +} + +template +void Updatable_heap::percolate_down() { + int n = 1; + + while ( 2*n + 1 <= size() ) { + if ( heap[n]->weight() < heap[2*n]->weight() && heap[n]->weight() < heap[2*n + 1]->weight() ) { + return; + } + + if ( heap[2*n]->weight() < heap[2*n + 1]->weight() ) { + swap( n, 2*n ); + n = 2*n; + } else { + assert( heap[2*n]->weight() >= heap[2*n + 1]->weight() ); + + swap( n, 2*n + 1 ); + n = 2*n + 1; + } + } + + if ( 2*n == size() && heap[2*n]->weight() < heap[n]->weight() ) { + swap( n, 2*n ); + } +} + +template +void Updatable_heap::percolate_up( int n ) { + while ( n != 1 ) { + int parent = n/2; + + if ( heap[parent]->weight() > heap[n]->weight() ) { + swap( parent, n ); + n = parent; + } else { + return; + } + } +} + +template +void Updatable_heap::push( T const &pz, int path_length ) { + Step *ptr = pointer( pz ); + + if ( ptr == 0 ) { + assert( heap_size <= M ); + ++heap_size; + + Step *ptr = (Step*)bench_alloc(sizeof(Step)); + ptr->init( pz, hash_table[pz.hash() & (M - 1)], size(), path_length ); + hash_table[pz.hash() & (M - 1)] = ptr; + heap[size()] = ptr; + + percolate_up( size() ); + + maximum_heap_size = max( maximum_heap_size, size() ); + } else { + if ( !ptr->visited ) { + if ( path_length + ptr->element.lower_bound() < ptr->weight() ) { + ptr->path_weight = path_length + ptr->element.lower_bound(); + percolate_up( ptr->heap_index ); + } + } + } +} + +template +int Updatable_heap::size() const { + return heap_size; +} + +template +int Updatable_heap::maximum_size() const { + return maximum_heap_size; +} + +template +int Updatable_heap::length( T const &pz ) const { + Step *ptr = pointer( pz ); + + return ( ptr == 0 ) ? 2147483647 : ptr->length(); +} + +template +typename Updatable_heap::Step *Updatable_heap::pointer( T const &pz ) const { + for ( Step *ptr = hash_table[pz.hash() & (M - 1)]; ptr != 0; ptr = ptr->next ) { + if ( ptr->element == pz ) { + return ptr; + } + } + + return 0; +} + +/**************************************************** + * ************************************************ * + * * Iterator * * + * ************************************************ * + ****************************************************/ + +template +void Updatable_heap::Step::init( T const &pz, Step *n, int hi, int dist ) { + element = pz; + next = n; + heap_index = hi; + path_length = dist; + path_weight = dist + element.lower_bound(); + visited = false; + previous_step = 0; +} + +template +int Updatable_heap::Step::length() const { + return path_length; +} + +template +int Updatable_heap::Step::weight() const { + return path_weight; +} + diff --git a/am-kernels/benchmarks/microbench/src/15pz/puzzle.h b/am-kernels/benchmarks/microbench/src/15pz/puzzle.h new file mode 100644 index 0000000..c0607d5 --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/15pz/puzzle.h @@ -0,0 +1,475 @@ +// Author: Douglas Wilhelm Harder +// Copyright (c) 2009 by Douglas Wilhelm Harder. All rights reserved. +// Url: https://ece.uwaterloo.ca/~dwharder/aads/Algorithms/N_puzzles/ + +template +class N_puzzle { + private: + bool puzzle_valid; + uint8_t zero_i, zero_j; + int8_t manhattan_distance; + int8_t puzzle[N][N]; + int hash_value; + + void determine_hash(); + + static int abs( int n ) { return ( n < 0 ) ? -n : n; } + + public: + N_puzzle(); + N_puzzle( int array[N*N] ); + N_puzzle( N_puzzle const & ); + N_puzzle &operator=( N_puzzle const & ); + + bool solvable() const; + bool valid() const; + int lower_bound() const; + unsigned int hash() const; + + bool tile_up_possible() const; + bool tile_down_possible() const; + bool tile_left_possible() const; + bool tile_right_possible() const; + + N_puzzle tile_up() const; + N_puzzle tile_down() const; + N_puzzle tile_left() const; + N_puzzle tile_right() const; + + bool operator==( N_puzzle const & ) const; + bool operator!=( N_puzzle const & ) const; + + N_puzzle static solution(); +}; + +template < int N > +N_puzzle::N_puzzle(): +puzzle_valid( true ), +manhattan_distance( 0 ) { + int array[N*N]; + + for ( int i = 0; i < N*N; ++i ) { + array[i] = i; + } + + int n = 0; + + for ( int i = 0; i < N; ++i ) { + for ( int j = 0; j < N; ++j ) { + int k = bench_rand() % (N*N - n); + puzzle[i][j] = array[k]; + + if ( array[k] == 0 ) { + zero_i = i; + zero_j = j; + } else { + manhattan_distance += abs( ((array[k] - 1) / N) - i ); + manhattan_distance += abs( ((array[k] - 1) % N) - j ); + } + + ++n; + array[k] = array[N*N - n]; + } + } + + determine_hash(); +} + +template < int N > +N_puzzle::N_puzzle( int array[N*N] ): +puzzle_valid( true ), +manhattan_distance( 0 ) { + bool check[N*N]; + + for ( int i = 0; i < N*N; ++i ) { + check[i] = false; + } + + int n = 0; + + for ( int i = 0; i < N; ++i ) { + for ( int j = 0; j < N; ++j ) { + puzzle[i][j] = array[n]; + check[array[n]] = true; + + if ( array[n] == 0 ) { + zero_i = i; + zero_j = j; + } else { + manhattan_distance += abs( ((array[n] - 1) / N) - i ); + manhattan_distance += abs( ((array[n] - 1) % N) - j ); + } + + ++n; + } + } + + for ( int i = 0; i < N*N; ++i ) { + if ( !check[i] ) { + puzzle_valid = false; + return; + } + } + + determine_hash(); +} + +/* + * Determine a hash value for the puzzle. + */ + +template < int N > +void N_puzzle::determine_hash() { + hash_value = 0; + + for ( int i = 0; i < N; ++i ) { + for ( int j = 0; j < N; ++j ) { + hash_value = hash_value*1973 + puzzle[i][j]; + } + } +} + +template < int N > +N_puzzle::N_puzzle( N_puzzle const &pz ): +puzzle_valid( pz.puzzle_valid ), +zero_i( pz.zero_i ), +zero_j( pz.zero_j ), +manhattan_distance( pz.manhattan_distance ), +hash_value( pz.hash_value ) { + for ( int i = 0; i < N; ++i ) { + for ( int j = 0; j < N; ++j ) { + puzzle[i][j] = pz.puzzle[i][j]; + } + } +} + +template < int N > +N_puzzle &N_puzzle::operator=( N_puzzle const &rhs ) { + puzzle_valid = rhs.puzzle_valid; + zero_i = rhs.zero_i; + zero_j = rhs.zero_j; + manhattan_distance = rhs.manhattan_distance; + hash_value = rhs.hash_value; + + for ( int i = 0; i < N; ++i ) { + for ( int j = 0; j < N; ++j ) { + puzzle[i][j] = rhs.puzzle[i][j]; + } + } + return *this; +} + + +/* + * Moving a tile up is possible as long as + * the blank is not in the last row. + */ + +template +bool N_puzzle::tile_up_possible() const { + return puzzle_valid && (zero_i != N - 1); +} + +/* + * Moving a tile down is possible as long as + * the blank is not in the first row. + */ + +template +bool N_puzzle::tile_down_possible() const { + return puzzle_valid && (zero_i != 0); +} + +/* + * Moving a tile left is possible as long as + * the blank is not in the last column. + */ + +template +bool N_puzzle::tile_left_possible() const { + return puzzle_valid && (zero_j != N - 1); +} + +/* + * Moving a tile right is possible as long as + * the blank is not in the first column. + */ + +template +bool N_puzzle::tile_right_possible() const { + return puzzle_valid && (zero_j != 0); +} + +template +N_puzzle N_puzzle::tile_up() const { + if ( !puzzle_valid ) { + return *this; + } + + N_puzzle result( *this ); + + if ( zero_i == N - 1 ) { + result.puzzle_valid = false; + return result; + } + + result.manhattan_distance += + abs( ((puzzle[zero_i + 1][zero_j] - 1) / N) - zero_i ) - + abs( ((puzzle[zero_i + 1][zero_j] - 1) / N) - (zero_i + 1) ); + + result.puzzle[zero_i][zero_j] = puzzle[zero_i + 1][zero_j]; + ++result.zero_i; + result.puzzle[result.zero_i][zero_j] = 0; + + result.determine_hash(); + + return result; +} + +template +N_puzzle N_puzzle::tile_down() const { + if ( !puzzle_valid ) { + return *this; + } + + N_puzzle result( *this ); + + if ( zero_i == 0 ) { + result.puzzle_valid = false; + return result; + } + + result.manhattan_distance += + abs( ((puzzle[zero_i - 1][zero_j] - 1) / N) - zero_i ) - + abs( ((puzzle[zero_i - 1][zero_j] - 1) / N) - (zero_i - 1) ); + + result.puzzle[zero_i][zero_j] = puzzle[zero_i - 1][zero_j]; + --result.zero_i; + result.puzzle[result.zero_i][zero_j] = 0; + + result.determine_hash(); + + return result; +} + +template +N_puzzle N_puzzle::tile_left() const { + if ( !puzzle_valid ) { + return *this; + } + + N_puzzle result( *this ); + + if ( zero_j == N - 1 ) { + result.puzzle_valid = false; + return result; + } + + result.manhattan_distance += + abs( ((puzzle[zero_i][zero_j + 1] - 1) % N) - zero_j ) - + abs( ((puzzle[zero_i][zero_j + 1] - 1) % N) - (zero_j + 1) ); + + result.puzzle[zero_i][zero_j] = puzzle[zero_i][zero_j + 1]; + ++result.zero_j; + result.puzzle[zero_i][result.zero_j] = 0; + + result.determine_hash(); + + return result; +} + +template +N_puzzle N_puzzle::tile_right() const { + if ( !puzzle_valid ) { + return *this; + } + + N_puzzle result( *this ); + + if ( zero_j == 0 ) { + result.puzzle_valid = false; + return result; + } + + result.manhattan_distance += + abs( ((puzzle[zero_i][zero_j - 1] - 1) % N) - zero_j ) - + abs( ((puzzle[zero_i][zero_j - 1] - 1) % N) - (zero_j - 1) ); + + result.puzzle[zero_i][zero_j] = puzzle[zero_i][zero_j - 1]; + --result.zero_j; + result.puzzle[zero_i][result.zero_j] = 0; + + result.determine_hash(); + + return result; +} + +/* + * Check if the puzzle is solvable: that is, check the + * number of inversions pluse the Manhattan distance of + * the black from the lower-right corner. + * + * Run time: O(n^2) + * Memory: O(n) + */ + +template +bool N_puzzle::solvable() const { + if ( !valid() ) { + return false; + } + + int entries[N*N]; + + for ( int i = 0; i < N; ++i ) { + for ( int j = 0; j < N; ++j ) { + if ( puzzle[i][j] == 0 ) { + entries[N*i + j] = N*N; + } else { + entries[N*i + j] = puzzle[i][j]; + } + } + } + + int parity = 0; + + for ( int i = 0; i < N*N; ++i ) { + for ( int j = i + 1; j < N*N; ++j ) { + if ( entries[i] > entries[j] ) { + ++parity; + } + } + } + + parity += 2*N - 2 - zero_i - zero_j; + + return ( (parity & 1) == 0 ); +} + +template +bool N_puzzle::valid() const { + return puzzle_valid; +} + +/* + * Return either the Manhattan, Hamming, or discrete distance + * between the puzzle and the solution. + */ + +template +int N_puzzle::lower_bound() const { + // The Manhattan distance + return valid() ? manhattan_distance : N*N*N; + + int result = 0; + int count = 1; + + for ( int i = 0; i < N; ++i ) { + for ( int j = 0; j < N; ++j ) { + if ( puzzle[i][j] != (count % N*N) ) { + ++result; + } + + ++count; + } + } + + // The Hamming distance, or + return result; + + // The discrete distance: converts the A* search to Dijkstra's algorithm + // return ( result == 0 ) ? 0 : 1; +} + +/* + * puzzle1 == puzzle2 + * + * Two puzzles are considered to be equal if their entries + * are equal: + * If either puzzle is not valid, return false. + * If the hash values are different, they are different; return false. + * Otherwise, check all entries to see if they are the same. + */ + +template < int N > +bool N_puzzle::operator==( N_puzzle const &rhs ) const { + if ( !valid() || !rhs.valid() || hash() != rhs.hash() ) { + return false; + } + + for ( int i = 0; i < N; ++i ) { + for ( int j = 0; j < N; ++j ) { + if ( puzzle[i][j] != rhs.puzzle[i][j] ) { + return false; + } + } + } + return true; +} + +/* + * puzzle1 != puzzle2 + * + * Two puzzles are considered to be unequal if any of the entries + * different: + * If either puzzle is not valid, return false. + * If the hash values are different, they are different; return true. + * Otherwise, check all entries to see if they are the same. + */ + +template < int N > +bool N_puzzle::operator!=( N_puzzle const &rhs ) const { + if ( !valid() || !rhs.valid() ) { + return false; + } + + if ( hash() != rhs.hash() ) { + return true; + } + + for ( int i = 0; i < N; ++i ) { + for ( int j = 0; j < N; ++j ) { + if ( puzzle[i][j] != rhs.puzzle[i][j] ) { + return true; + } + } + } + + return false; +} + +/* + * unsigned int hash() const + * + * Returns the pre-calculated hash value. + */ + +template < int N > +unsigned int N_puzzle::hash() const { + return valid() ? hash_value : 0; +} + +/* + * N_puzzle solution() + * + * Returns the correct solution to the N puzzle: + * + * 1 2 3 1 2 3 4 + * 3x3: 4 5 6 4x4: 5 6 7 8 + * 7 8 9 10 11 12 + * 13 14 15 + */ + +template +N_puzzle N_puzzle::solution() { + int array[N*N]; + + for ( int i = 0; i < N*N - 1; ++i ) { + array[i] = i + 1; + } + + array[N*N - 1] = 0; + + return N_puzzle( array ); +} + diff --git a/am-kernels/benchmarks/microbench/src/bench.c b/am-kernels/benchmarks/microbench/src/bench.c new file mode 100644 index 0000000..6f36de0 --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/bench.c @@ -0,0 +1,199 @@ +#include +#include +#include +#include + +Benchmark *current; +Setting *setting; + +static char *hbrk; + +static uint64_t uptime() { return io_read(AM_TIMER_UPTIME).us; } + +static char *format_time(uint64_t us) { + static char buf[32]; + uint64_t ms = us / 1000; + us -= ms * 1000; + assert(us < 1000); + int len = sprintf(buf, "%d.000", ms); + char *p = &buf[len - 1]; + while (us > 0) { + *(p --) = '0' + us % 10; + us /= 10; + } + return buf; +} + +// The benchmark list + +#define ENTRY(_name, _sname, _s, _m, _l, _h, _desc) \ + { .prepare = bench_##_name##_prepare, \ + .run = bench_##_name##_run, \ + .validate = bench_##_name##_validate, \ + .name = _sname, \ + .desc = _desc, \ + .settings = {_s, _m, _l, _h}, }, + +Benchmark benchmarks[] = { + BENCHMARK_LIST(ENTRY) +}; + +// Running a benchmark +static void bench_prepare(Result *res) { + res->usec = uptime(); +} + +static void bench_reset() { + hbrk = (void *)ROUNDUP(heap.start, 8); +} + +static void bench_done(Result *res) { + res->usec = uptime() - res->usec; +} + +static const char *bench_check(Benchmark *bench) { + uintptr_t freesp = (uintptr_t)heap.end - (uintptr_t)heap.start; + if (freesp < setting->mlim) { + return "(insufficient memory)"; + } + return NULL; +} + +static void run_once(Benchmark *b, Result *res) { + bench_reset(); // reset malloc state + current->prepare(); // call bechmark's prepare function + bench_prepare(res); // clean everything, start timer + current->run(); // run it + bench_done(res); // collect results + res->pass = current->validate(); +} + +static uint32_t score(Benchmark *b, uint64_t usec) { + if (usec == 0) return 0; + return (uint64_t)(REF_SCORE) * setting->ref / usec; +} + +int main(const char *args) { + const char *setting_name = args; + if (args == NULL || strcmp(args, "") == 0) { + printf("Empty mainargs. Use \"ref\" by default\n"); + setting_name = "ref"; + } + int setting_id = -1; + + if (strcmp(setting_name, "test" ) == 0) setting_id = 0; + else if (strcmp(setting_name, "train") == 0) setting_id = 1; + else if (strcmp(setting_name, "ref" ) == 0) setting_id = 2; + else if (strcmp(setting_name, "huge" ) == 0) setting_id = 3; + else { + printf("Invalid mainargs: \"%s\"; " + "must be in {test, train, ref, huge}\n", setting_name); + halt(1); + } + + ioe_init(); + + printf("======= Running MicroBench [input *%s*] =======\n", setting_name); + + uint32_t bench_score = 0; + int pass = 1; + uint64_t t0 = uptime(); + uint64_t score_time = 0; + + for (int i = 0; i < LENGTH(benchmarks); i ++) { + Benchmark *bench = &benchmarks[i]; + current = bench; + setting = &bench->settings[setting_id]; + const char *msg = bench_check(bench); + printf("[%s] %s: ", bench->name, bench->desc); + if (msg != NULL) { + printf("Ignored %s\n", msg); + } else { + uint64_t usec = ULLONG_MAX; + int succ = 1; + for (int i = 0; i < REPEAT; i ++) { + Result res; + run_once(bench, &res); + printf(res.pass ? "*" : "X"); + succ &= res.pass; + if (res.usec < usec) usec = res.usec; + score_time += res.usec; + } + + if (succ) printf(" Passed."); + else printf(" Failed."); + + pass &= succ; + + uint32_t cur = succ ? score(bench, usec) : 0; + + printf("\n"); + if (setting_id != 0) { + printf(" min time: %s ms [%d]\n", format_time(usec), cur); + } + + bench_score += cur; + } + } + uint64_t total_time = uptime() - t0; + + bench_score /= LENGTH(benchmarks); + + printf("==================================================\n"); + printf("MicroBench %s", pass ? "PASS" : "FAIL"); + if (setting_id >= 2) { + printf(" %d Marks\n", bench_score); + printf(" vs. %d Marks (%s)\n", REF_SCORE, REF_CPU); + } else { + printf("\n"); + } + printf("Scored time: %s ms\n", format_time(score_time)); + printf("Total time: %s ms\n", format_time(total_time)); + return (pass ? 0 : 1); +} + +// Libraries + +void* bench_alloc(size_t size) { + size = (size_t)ROUNDUP(size, 8); + char *old = hbrk; + hbrk += size; + assert((uintptr_t)heap.start <= (uintptr_t)hbrk && (uintptr_t)hbrk < (uintptr_t)heap.end); + for (uint64_t *p = (uint64_t *)old; p != (uint64_t *)hbrk; p ++) { + *p = 0; + } + assert((uintptr_t)hbrk - (uintptr_t)heap.start <= setting->mlim); + return old; +} + +void bench_free(void *ptr) { +} + +static uint32_t seed = 1; + +void bench_srand(uint32_t _seed) { + seed = _seed & 0x7fff; +} + +uint32_t bench_rand() { + seed = (seed * (uint32_t)214013L + (uint32_t)2531011L); + return (seed >> 16) & 0x7fff; +} + +// FNV hash +uint32_t checksum(void *start, void *end) { + const uint32_t x = 16777619; + uint32_t h1 = 2166136261u; + for (uint8_t *p = (uint8_t*)start; p + 4 < (uint8_t*)end; p += 4) { + for (int i = 0; i < 4; i ++) { + h1 = (h1 ^ p[i]) * x; + } + } + int32_t hash = (uint32_t)h1; + hash += hash << 13; + hash ^= hash >> 7; + hash += hash << 3; + hash ^= hash >> 17; + hash += hash << 5; + return hash; +} diff --git a/am-kernels/benchmarks/microbench/src/bf/bf.c b/am-kernels/benchmarks/microbench/src/bf/bf.c new file mode 100644 index 0000000..f07ba1e --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/bf/bf.c @@ -0,0 +1,151 @@ +/* + Brainfuck-C ( http://github.com/kgabis/brainfuck-c ) + Copyright (c) 2012 Krzysztof Gabis + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#include + +static int ARR_SIZE; + +#define CODE ">>+>>>>>,[>+>>,]>+[--[+<<<-]<[<+>-]<[<[->[<<<+>>>>+<-]<<[>>+>[->]<<[<]" \ + "<-]>]>>>+<[[-]<[>+<-]<]>[[>>>]+<<<-<[<<[<<<]>>+>[>>>]<-]<<[<<<]>[>>[>>" \ + ">]<+<<[<<<]>-]]+<<<]+[->>>]>>]>>[.>>>]" + +#define OP_END 0 +#define OP_INC_DP 1 +#define OP_DEC_DP 2 +#define OP_INC_VAL 3 +#define OP_DEC_VAL 4 +#define OP_OUT 5 +#define OP_IN 6 +#define OP_JMP_FWD 7 +#define OP_JMP_BCK 8 + +#define SUCCESS 0 +#define FAILURE 1 + +#define PROGRAM_SIZE 4096 +#define STACK_SIZE 512 +#define DATA_SIZE 4096 + +#define STACK_PUSH(A) (STACK[SP++] = A) +#define STACK_POP() (STACK[--SP]) +#define STACK_EMPTY() (SP == 0) +#define STACK_FULL() (SP == STACK_SIZE) + +struct instruction_t { + unsigned short operator; + unsigned short operand; +}; + +static struct instruction_t *PROGRAM; +static unsigned short *STACK; +static unsigned int SP; +static const char *code; +static char *input; + +static int compile_bf() { + unsigned short pc = 0, jmp_pc; + for (; *code; code ++) { + int c = *code; + if (pc >= PROGRAM_SIZE) break; + switch (c) { + case '>': PROGRAM[pc].operator = OP_INC_DP; break; + case '<': PROGRAM[pc].operator = OP_DEC_DP; break; + case '+': PROGRAM[pc].operator = OP_INC_VAL; break; + case '-': PROGRAM[pc].operator = OP_DEC_VAL; break; + case '.': PROGRAM[pc].operator = OP_OUT; break; + case ',': PROGRAM[pc].operator = OP_IN; break; + case '[': + PROGRAM[pc].operator = OP_JMP_FWD; + if (STACK_FULL()) { + return FAILURE; + } + STACK_PUSH(pc); + break; + case ']': + if (STACK_EMPTY()) { + return FAILURE; + } + jmp_pc = STACK_POP(); + PROGRAM[pc].operator = OP_JMP_BCK; + PROGRAM[pc].operand = jmp_pc; + PROGRAM[jmp_pc].operand = pc; + break; + default: pc--; break; + } + pc++; + } + if (!STACK_EMPTY() || pc == PROGRAM_SIZE) { + return FAILURE; + } + PROGRAM[pc].operator = OP_END; + return SUCCESS; +} + +static unsigned short *data; +static char *output; +static int noutput; + +static void execute_bf() { + unsigned int pc = 0, ptr = 0; + while (PROGRAM[pc].operator != OP_END && ptr < DATA_SIZE) { + switch (PROGRAM[pc].operator) { + case OP_INC_DP: ptr++; break; + case OP_DEC_DP: ptr--; break; + case OP_INC_VAL: data[ptr]++; break; + case OP_DEC_VAL: data[ptr]--; break; + case OP_OUT: output[noutput ++] = data[ptr]; break; + case OP_IN: data[ptr] = *(input ++); break; + case OP_JMP_FWD: if(!data[ptr]) { pc = PROGRAM[pc].operand; } break; + case OP_JMP_BCK: if(data[ptr]) { pc = PROGRAM[pc].operand; } break; + default: return; + } + pc++; + } +} + +void bench_bf_prepare() { + ARR_SIZE = setting->size; + SP = 0; + PROGRAM = bench_alloc(sizeof(PROGRAM[0]) * PROGRAM_SIZE); + STACK = bench_alloc(sizeof(STACK[0]) * STACK_SIZE); + data = bench_alloc(sizeof(data[0]) * DATA_SIZE); + code = CODE; + input = bench_alloc(ARR_SIZE + 1); + output = bench_alloc(DATA_SIZE); + noutput = 0; + + bench_srand(1); + for (int i = 0; i < ARR_SIZE; i ++) { + input[i] = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"[bench_rand() % 62]; + } +} + +void bench_bf_run() { + compile_bf(); + execute_bf(); +} + +int bench_bf_validate() { + uint32_t cs = checksum(output, output + noutput); + return noutput == ARR_SIZE && cs == setting->checksum; +} diff --git a/am-kernels/benchmarks/microbench/src/dinic/dinic.cc b/am-kernels/benchmarks/microbench/src/dinic/dinic.cc new file mode 100644 index 0000000..926458c --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/dinic/dinic.cc @@ -0,0 +1,138 @@ +#include + +static int N; +const int INF = 0x3f3f3f; + +struct Edge { + int from, to, cap, flow; + Edge(){} + Edge(int from, int to, int cap, int flow) { + this->from = from; + this->to = to; + this->cap = cap; + this->flow = flow; + } +}; + +template +static inline T min(T x, T y) { + return x < y ? x : y; +} + +struct Dinic { + int n, m, s, t; + Edge *edges; + int *head, *nxt, *d, *cur, *queue; + bool *vis; + + void init(int n) { + int nold = (n - 2) / 2; + int maxm = (nold * nold + nold * 2) * 2; + + edges = (Edge *)bench_alloc(sizeof(Edge) * maxm); + head = (int *)bench_alloc(sizeof(int) * n); + nxt = (int *)bench_alloc(sizeof(int) * maxm); + vis = (bool *)bench_alloc(sizeof(bool) * n); + d = (int *)bench_alloc(sizeof(int) * n); + cur = (int *)bench_alloc(sizeof(int) * n); + queue = (int *)bench_alloc(sizeof(int) * n); + + this->n = n; + for (int i = 0; i < n; i ++) { + head[i] = -1; + } + m = 0; + } + + void AddEdge(int u, int v, int c) { + if (c == 0) return; + edges[m] = Edge(u, v, c, 0); + nxt[m] = head[u]; + head[u] = m++; + edges[m] = Edge(v, u, 0, 0); + nxt[m] = head[v]; + head[v] = m++; + } + + bool BFS() { + for (int i = 0; i < n; i ++) vis[i] = 0; + int qf = 0, qr = 0; + queue[qr ++] = s; + d[s] = 0; + vis[s] = 1; + while (qf != qr) { + int x = queue[qf ++]; + for (int i = head[x]; i != -1; i = nxt[i]) { + Edge& e = edges[i]; + if (!vis[e.to] && e.cap > e.flow) { + vis[e.to] = 1; + d[e.to] = d[x] + 1; + queue[qr ++] = e.to; + } + } + } + return vis[t]; + } + + int DFS(int x, int a) { + if (x == t || a == 0) return a; + int flow = 0, f; + for (int i = cur[x]; i != -1; i = nxt[i]) { + Edge& e = edges[i]; + if (d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > 0) { + e.flow += f; + edges[i^1].flow -= f; + flow += f; + a -= f; + if (a == 0) break; + } + } + return flow; + } + + int Maxflow(int s, int t) { + this -> s = s; this -> t = t; + int flow = 0; + while (BFS()) { + for (int i = 0; i < n; i++) + cur[i] = head[i]; + flow += DFS(s, INF); + } + return flow; + } +}; + + +extern "C" { + + +static Dinic *G; +static int ans; + +void bench_dinic_prepare() { + N = setting->size; + bench_srand(1); + int s = 2 * N, t = 2 * N + 1; + G = (Dinic*)bench_alloc(sizeof(Dinic)); + G->init(2 * N + 2); + for (int i = 0; i < N; i ++) + for (int j = 0; j < N; j ++) { + G->AddEdge(i, N + j, bench_rand() % 10); + } + + for (int i = 0; i < N; i ++) { + G->AddEdge(s, i, bench_rand() % 1000); + G->AddEdge(N + i, t, bench_rand() % 1000); + } +} + +void bench_dinic_run() { + ans = G->Maxflow(2 * N, 2 * N + 1); +} + +int bench_dinic_validate() { + return (uint32_t)ans == setting->checksum; +} +} + + diff --git a/am-kernels/benchmarks/microbench/src/fib/fib.c b/am-kernels/benchmarks/microbench/src/fib/fib.c new file mode 100644 index 0000000..b96be1f --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/fib/fib.c @@ -0,0 +1,64 @@ +#include + +// f(n) = (f(n-1) + f(n-2) + .. f(n-m)) mod 2^32 + +#define N 2147483603 +static int M; + +static void put(uint32_t *m, int i, int j, uint32_t data) { + m[i * M + j] = data; +} + +static uint32_t get(uint32_t *m, int i, int j) { + return m[i * M + j]; +} + +static inline void mult(uint32_t *c, uint32_t *a, uint32_t *b) { + for (int i = 0; i < M; i ++) + for (int j = 0; j < M; j ++) { + put(c, i, j, 0); + for (int k = 0; k < M; k ++) { + put(c, i, j, get(c, i, j) + get(a, i, k) * get(b, k, j)); + } + } +} + +static inline void assign(uint32_t *a, uint32_t *b) { + for (int i = 0; i < M; i ++) + for (int j = 0; j < M; j ++) + put(a, i, j, get(b, i, j)); +} + +static uint32_t *A, *ans, *T, *tmp; + +void bench_fib_prepare() { + M = setting->size; + int sz = sizeof(uint32_t) * M * M; + A = bench_alloc(sz); + T = bench_alloc(sz); + ans = bench_alloc(sz); + tmp = bench_alloc(sz); +} + +void bench_fib_run() { + for (int i = 0; i < M; i ++) + for (int j = 0; j < M; j ++) { + uint32_t x = (i == M - 1 || j == i + 1); + put(A, i, j, x); + put(T, i, j, x); + put(ans, i, j, i == j); + } + + for (int n = N; n > 0; n >>= 1) { + if (n & 1) { + mult(tmp, ans, T); + assign(ans, tmp); + } + mult(tmp, T, T); + assign(T, tmp); + } +} + +int bench_fib_validate() { + return get(ans, M-1, M-1) == setting->checksum; +} diff --git a/am-kernels/benchmarks/microbench/src/lzip/lzip.c b/am-kernels/benchmarks/microbench/src/lzip/lzip.c new file mode 100644 index 0000000..f55765b --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/lzip/lzip.c @@ -0,0 +1,29 @@ +#include "quicklz.h" +#include + +static int SIZE; + +static qlz_state_compress *state; +static char *blk; +static char *compress; +static int len; + +void bench_lzip_prepare() { + SIZE = setting->size; + bench_srand(1); + state = bench_alloc(sizeof(qlz_state_compress)); + blk = bench_alloc(SIZE); + compress = bench_alloc(SIZE + 400); + for (int i = 0; i < SIZE; i ++) { + blk[i] = 'a' + bench_rand() % 26; + } +} + +void bench_lzip_run() { + len = qlz_compress(blk, compress, SIZE, state); +} + +int bench_lzip_validate() { + return checksum(compress, compress + len) == setting->checksum; +} + diff --git a/am-kernels/benchmarks/microbench/src/lzip/quicklz.c b/am-kernels/benchmarks/microbench/src/lzip/quicklz.c new file mode 100644 index 0000000..9200abe --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/lzip/quicklz.c @@ -0,0 +1,761 @@ +// Fast data compression library +// Copyright (C) 2006-2011 Lasse Mikkel Reinhold +// lar@quicklz.com +// +// QuickLZ can be used for free under the GPL 1, 2 or 3 license (where anything +// released into public must be open source) or under a commercial license if such +// has been acquired (see http://www.quicklz.com/order.html). The commercial license +// does not cover derived or ported versions created by third parties under GPL. + +// 1.5.0 final + +#include "quicklz.h" + +#if QLZ_VERSION_MAJOR != 1 || QLZ_VERSION_MINOR != 5 || QLZ_VERSION_REVISION != 0 + #error quicklz.c and quicklz.h have different versions +#endif + +#define MINOFFSET 2 +#define UNCONDITIONAL_MATCHLEN 6 +#define UNCOMPRESSED_END 4 +#define CWORD_LEN 4 + +#if QLZ_COMPRESSION_LEVEL == 1 && defined QLZ_PTR_64 && QLZ_STREAMING_BUFFER == 0 + #define OFFSET_BASE source + #define CAST (ui32)(size_t) +#else + #define OFFSET_BASE 0 + #define CAST +#endif + +int qlz_get_setting(int setting) +{ + switch (setting) + { + case 0: return QLZ_COMPRESSION_LEVEL; + case 1: return sizeof(qlz_state_compress); + case 2: return sizeof(qlz_state_decompress); + case 3: return QLZ_STREAMING_BUFFER; +#ifdef QLZ_MEMORY_SAFE + case 6: return 1; +#else + case 6: return 0; +#endif + case 7: return QLZ_VERSION_MAJOR; + case 8: return QLZ_VERSION_MINOR; + case 9: return QLZ_VERSION_REVISION; + } + return -1; +} + +#if QLZ_COMPRESSION_LEVEL == 1 +static int same(const unsigned char *src, size_t n) +{ + while(n > 0 && *(src + n) == *src) + n--; + return n == 0 ? 1 : 0; +} +#endif + +static void reset_table_compress(qlz_state_compress *state) +{ + int i; + for(i = 0; i < QLZ_HASH_VALUES; i++) + { +#if QLZ_COMPRESSION_LEVEL == 1 + state->hash[i].offset = 0; +#else + state->hash_counter[i] = 0; +#endif + } +} + +static void reset_table_decompress(qlz_state_decompress *state) +{ + int i; + (void)state; + (void)i; +#if QLZ_COMPRESSION_LEVEL == 2 + for(i = 0; i < QLZ_HASH_VALUES; i++) + { + state->hash_counter[i] = 0; + } +#endif +} + +static __inline ui32 hash_func(ui32 i) +{ +#if QLZ_COMPRESSION_LEVEL == 2 + return ((i >> 9) ^ (i >> 13) ^ i) & (QLZ_HASH_VALUES - 1); +#else + return ((i >> 12) ^ i) & (QLZ_HASH_VALUES - 1); +#endif +} + +static __inline ui32 fast_read(void const *src, ui32 bytes) +{ + uint32_t ret = 0; + if (bytes >= 1 && bytes <= 4) { + for (uint32_t i = 0; i < bytes; i ++) { + ret |= ((uint8_t*)src)[i] << (i * 8); + } + } + return ret; +} + +static __inline ui32 hashat(const unsigned char *src) +{ + ui32 fetch, hash; + fetch = fast_read(src, 3); + hash = hash_func(fetch); + return hash; +} + +static __inline void fast_write(ui32 f, void *dst, size_t bytes) +{ + for (size_t i = 0; i != bytes; i ++) { + ((char*)dst)[i] = ((char*)&f)[i]; + } +} + + +size_t qlz_size_decompressed(const char *source) +{ + ui32 n, r; + n = (((*source) & 2) == 2) ? 4 : 1; + r = fast_read(source + 1 + n, n); + r = r & (0xffffffff >> ((4 - n)*8)); + return r; +} + +size_t qlz_size_compressed(const char *source) +{ + ui32 n, r; + n = (((*source) & 2) == 2) ? 4 : 1; + r = fast_read(source + 1, n); + r = r & (0xffffffff >> ((4 - n)*8)); + return r; +} + +size_t qlz_size_header(const char *source) +{ + size_t n = 2*((((*source) & 2) == 2) ? 4 : 1) + 1; + return n; +} + + +static __inline void memcpy_up(unsigned char *dst, const unsigned char *src, ui32 n) +{ + assert(0); // unaligned memory access +} + +static __inline void update_hash(qlz_state_decompress *state, const unsigned char *s) +{ +#if QLZ_COMPRESSION_LEVEL == 1 + ui32 hash; + hash = hashat(s); + state->hash[hash].offset = s; + state->hash_counter[hash] = 1; +#elif QLZ_COMPRESSION_LEVEL == 2 + ui32 hash; + unsigned char c; + hash = hashat(s); + c = state->hash_counter[hash]; + state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = s; + c++; + state->hash_counter[hash] = c; +#endif + (void)state; + (void)s; +} + +#if QLZ_COMPRESSION_LEVEL <= 2 +static void update_hash_upto(qlz_state_decompress *state, unsigned char **lh, const unsigned char *max) +{ + while(*lh < max) + { + (*lh)++; + update_hash(state, *lh); + } +} +#endif + +static size_t qlz_compress_core(const unsigned char *source, unsigned char *destination, size_t size, qlz_state_compress *state) +{ + const unsigned char *last_byte = source + size - 1; + const unsigned char *src = source; + unsigned char *cword_ptr = destination; + unsigned char *dst = destination + CWORD_LEN; + ui32 cword_val = 1U << 31; + const unsigned char *last_matchstart = last_byte - UNCONDITIONAL_MATCHLEN - UNCOMPRESSED_END; + ui32 fetch = 0; + unsigned int lits = 0; + + (void) lits; + + if(src <= last_matchstart) + fetch = fast_read(src, 3); + + while(src <= last_matchstart) + { + if ((cword_val & 1) == 1) + { + // store uncompressed if compression ratio is too low + if (src > source + (size >> 1) && dst - destination > src - source - ((src - source) >> 5)) + return 0; + + fast_write((cword_val >> 1) | (1U << 31), cword_ptr, CWORD_LEN); + + cword_ptr = dst; + dst += CWORD_LEN; + cword_val = 1U << 31; + fetch = fast_read(src, 3); + } +#if QLZ_COMPRESSION_LEVEL == 1 + { + const unsigned char *o; + ui32 hash, cached; + + hash = hash_func(fetch); + cached = fetch ^ state->hash[hash].cache; + state->hash[hash].cache = fetch; + + o = state->hash[hash].offset + OFFSET_BASE; + state->hash[hash].offset = CAST(src - OFFSET_BASE); + + if (cached == 0 && o != OFFSET_BASE && (src - o > MINOFFSET || (src == o + 1 && lits >= 3 && src > source + 3 && same(src - 3, 6)))) + { + if (*(o + 3) != *(src + 3)) + { + hash <<= 4; + cword_val = (cword_val >> 1) | (1U << 31); + fast_write((3 - 2) | hash, dst, 2); + src += 3; + dst += 2; + } + else + { + const unsigned char *old_src = src; + size_t matchlen; + hash <<= 4; + + cword_val = (cword_val >> 1) | (1U << 31); + src += 4; + + if(*(o + (src - old_src)) == *src) + { + src++; + if(*(o + (src - old_src)) == *src) + { + size_t q = last_byte - UNCOMPRESSED_END - (src - 5) + 1; + size_t remaining = q > 255 ? 255 : q; + src++; + while(*(o + (src - old_src)) == *src && (size_t)(src - old_src) < remaining) + src++; + } + } + + matchlen = src - old_src; + if (matchlen < 18) + { + fast_write((ui32)(matchlen - 2) | hash, dst, 2); + dst += 2; + } + else + { + fast_write((ui32)(matchlen << 16) | hash, dst, 3); + dst += 3; + } + } + fetch = fast_read(src, 3); + lits = 0; + } + else + { + lits++; + *dst = *src; + src++; + dst++; + cword_val = (cword_val >> 1); + fetch = (fetch >> 8 & 0xffff) | (*(src + 2) << 16); + } + } +#elif QLZ_COMPRESSION_LEVEL >= 2 + { + const unsigned char *o, *offset2; + ui32 hash, matchlen, k, m, best_k = 0; + unsigned char c; + size_t remaining = (last_byte - UNCOMPRESSED_END - src + 1) > 255 ? 255 : (last_byte - UNCOMPRESSED_END - src + 1); + (void)best_k; + + + //hash = hashat(src); + fetch = fast_read(src, 3); + hash = hash_func(fetch); + + c = state->hash_counter[hash]; + + offset2 = state->hash[hash].offset[0]; + if(offset2 < src - MINOFFSET && c > 0 && ((fast_read(offset2, 3) ^ fetch) & 0xffffff) == 0) + { + matchlen = 3; + if(*(offset2 + matchlen) == *(src + matchlen)) + { + matchlen = 4; + while(*(offset2 + matchlen) == *(src + matchlen) && matchlen < remaining) + matchlen++; + } + } + else + matchlen = 0; + for(k = 1; k < QLZ_POINTERS && c > k; k++) + { + o = state->hash[hash].offset[k]; +#if QLZ_COMPRESSION_LEVEL == 3 + if(((fast_read(o, 3) ^ fetch) & 0xffffff) == 0 && o < src - MINOFFSET) +#elif QLZ_COMPRESSION_LEVEL == 2 + if(*(src + matchlen) == *(o + matchlen) && ((fast_read(o, 3) ^ fetch) & 0xffffff) == 0 && o < src - MINOFFSET) +#endif + { + m = 3; + while(*(o + m) == *(src + m) && m < remaining) + m++; +#if QLZ_COMPRESSION_LEVEL == 3 + if ((m > matchlen) || (m == matchlen && o > offset2)) +#elif QLZ_COMPRESSION_LEVEL == 2 + if (m > matchlen) +#endif + { + offset2 = o; + matchlen = m; + best_k = k; + } + } + } + o = offset2; + state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = src; + c++; + state->hash_counter[hash] = c; + +#if QLZ_COMPRESSION_LEVEL == 3 + if(matchlen > 2 && src - o < 131071) + { + ui32 u; + size_t offset = src - o; + + for(u = 1; u < matchlen; u++) + { + hash = hashat(src + u); + c = state->hash_counter[hash]++; + state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = src + u; + } + + cword_val = (cword_val >> 1) | (1U << 31); + src += matchlen; + + if(matchlen == 3 && offset <= 63) + { + *dst = (unsigned char)(offset << 2); + dst++; + } + else if (matchlen == 3 && offset <= 16383) + { + ui32 f = (ui32)((offset << 2) | 1); + fast_write(f, dst, 2); + dst += 2; + } + else if (matchlen <= 18 && offset <= 1023) + { + ui32 f = ((matchlen - 3) << 2) | ((ui32)offset << 6) | 2; + fast_write(f, dst, 2); + dst += 2; + } + + else if(matchlen <= 33) + { + ui32 f = ((matchlen - 2) << 2) | ((ui32)offset << 7) | 3; + fast_write(f, dst, 3); + dst += 3; + } + else + { + ui32 f = ((matchlen - 3) << 7) | ((ui32)offset << 15) | 3; + fast_write(f, dst, 4); + dst += 4; + } + } + else + { + *dst = *src; + src++; + dst++; + cword_val = (cword_val >> 1); + } +#elif QLZ_COMPRESSION_LEVEL == 2 + + if(matchlen > 2) + { + cword_val = (cword_val >> 1) | (1U << 31); + src += matchlen; + + if (matchlen < 10) + { + ui32 f = best_k | ((matchlen - 2) << 2) | (hash << 5); + fast_write(f, dst, 2); + dst += 2; + } + else + { + ui32 f = best_k | (matchlen << 16) | (hash << 5); + fast_write(f, dst, 3); + dst += 3; + } + } + else + { + *dst = *src; + src++; + dst++; + cword_val = (cword_val >> 1); + } +#endif + } +#endif + } + while (src <= last_byte) + { + if ((cword_val & 1) == 1) + { + fast_write((cword_val >> 1) | (1U << 31), cword_ptr, CWORD_LEN); + cword_ptr = dst; + dst += CWORD_LEN; + cword_val = 1U << 31; + } +#if QLZ_COMPRESSION_LEVEL < 3 + if (src <= last_byte - 3) + { +#if QLZ_COMPRESSION_LEVEL == 1 + ui32 hash, fetch; + fetch = fast_read(src, 3); + hash = hash_func(fetch); + state->hash[hash].offset = CAST(src - OFFSET_BASE); + state->hash[hash].cache = fetch; +#elif QLZ_COMPRESSION_LEVEL == 2 + ui32 hash; + unsigned char c; + hash = hashat(src); + c = state->hash_counter[hash]; + state->hash[hash].offset[c & (QLZ_POINTERS - 1)] = src; + c++; + state->hash_counter[hash] = c; +#endif + } +#endif + *dst = *src; + src++; + dst++; + cword_val = (cword_val >> 1); + } + + while((cword_val & 1) != 1) + cword_val = (cword_val >> 1); + + fast_write((cword_val >> 1) | (1U << 31), cword_ptr, CWORD_LEN); + + // min. size must be 9 bytes so that the qlz_size functions can take 9 bytes as argument + return dst - destination < 9 ? 9 : dst - destination; +} + +static size_t qlz_decompress_core(const unsigned char *source, unsigned char *destination, size_t size, qlz_state_decompress *state, const unsigned char *history) +{ + const unsigned char *src = source + qlz_size_header((const char *)source); + unsigned char *dst = destination; + const unsigned char *last_destination_byte = destination + size - 1; + ui32 cword_val = 1; + const unsigned char *last_matchstart = last_destination_byte - UNCONDITIONAL_MATCHLEN - UNCOMPRESSED_END; + unsigned char *last_hashed = destination - 1; + const unsigned char *last_source_byte = source + qlz_size_compressed((const char *)source) - 1; + static const ui32 bitlut[16] = {4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0}; + + (void) last_source_byte; + (void) last_hashed; + (void) state; + (void) history; + + for(;;) + { + ui32 fetch; + + if (cword_val == 1) + { +#ifdef QLZ_MEMORY_SAFE + if(src + CWORD_LEN - 1 > last_source_byte) + return 0; +#endif + cword_val = fast_read(src, CWORD_LEN); + src += CWORD_LEN; + } + +#ifdef QLZ_MEMORY_SAFE + if(src + 4 - 1 > last_source_byte) + return 0; +#endif + + fetch = fast_read(src, 4); + + if ((cword_val & 1) == 1) + { + ui32 matchlen; + const unsigned char *offset2; + +#if QLZ_COMPRESSION_LEVEL == 1 + ui32 hash; + cword_val = cword_val >> 1; + hash = (fetch >> 4) & 0xfff; + offset2 = (const unsigned char *)(size_t)state->hash[hash].offset; + + if((fetch & 0xf) != 0) + { + matchlen = (fetch & 0xf) + 2; + src += 2; + } + else + { + matchlen = *(src + 2); + src += 3; + } + +#elif QLZ_COMPRESSION_LEVEL == 2 + ui32 hash; + unsigned char c; + cword_val = cword_val >> 1; + hash = (fetch >> 5) & 0x7ff; + c = (unsigned char)(fetch & 0x3); + offset2 = state->hash[hash].offset[c]; + + if((fetch & (28)) != 0) + { + matchlen = ((fetch >> 2) & 0x7) + 2; + src += 2; + } + else + { + matchlen = *(src + 2); + src += 3; + } + +#elif QLZ_COMPRESSION_LEVEL == 3 + ui32 offset; + cword_val = cword_val >> 1; + if ((fetch & 3) == 0) + { + offset = (fetch & 0xff) >> 2; + matchlen = 3; + src++; + } + else if ((fetch & 2) == 0) + { + offset = (fetch & 0xffff) >> 2; + matchlen = 3; + src += 2; + } + else if ((fetch & 1) == 0) + { + offset = (fetch & 0xffff) >> 6; + matchlen = ((fetch >> 2) & 15) + 3; + src += 2; + } + else if ((fetch & 127) != 3) + { + offset = (fetch >> 7) & 0x1ffff; + matchlen = ((fetch >> 2) & 0x1f) + 2; + src += 3; + } + else + { + offset = (fetch >> 15); + matchlen = ((fetch >> 7) & 255) + 3; + src += 4; + } + + offset2 = dst - offset; +#endif + +#ifdef QLZ_MEMORY_SAFE + if(offset2 < history || offset2 > dst - MINOFFSET - 1) + return 0; + + if(matchlen > (ui32)(last_destination_byte - dst - UNCOMPRESSED_END + 1)) + return 0; +#endif + + memcpy_up(dst, offset2, matchlen); + dst += matchlen; + +#if QLZ_COMPRESSION_LEVEL <= 2 + update_hash_upto(state, &last_hashed, dst - matchlen); + last_hashed = dst - 1; +#endif + } + else + { + if (dst < last_matchstart) + { + unsigned int n = bitlut[cword_val & 0xf]; + memcpy_up(dst, src, 4); + cword_val = cword_val >> n; + dst += n; + src += n; +#if QLZ_COMPRESSION_LEVEL <= 2 + update_hash_upto(state, &last_hashed, dst - 3); +#endif + } + else + { + while(dst <= last_destination_byte) + { + if (cword_val == 1) + { + src += CWORD_LEN; + cword_val = 1U << 31; + } +#ifdef QLZ_MEMORY_SAFE + if(src >= last_source_byte + 1) + return 0; +#endif + *dst = *src; + dst++; + src++; + cword_val = cword_val >> 1; + } + +#if QLZ_COMPRESSION_LEVEL <= 2 + update_hash_upto(state, &last_hashed, last_destination_byte - 3); // todo, use constant +#endif + return size; + } + + } + } +} + +size_t qlz_compress(const void *source, char *destination, size_t size, qlz_state_compress *state) +{ + size_t r; + ui32 compressed; + size_t base; + + if(size == 0 || size > 0xffffffff - 400) + return 0; + + if(size < 216) + base = 3; + else + base = 9; + +#if QLZ_STREAMING_BUFFER > 0 + if (state->stream_counter + size - 1 >= QLZ_STREAMING_BUFFER) +#endif + { + reset_table_compress(state); + r = base + qlz_compress_core((const unsigned char *)source, (unsigned char*)destination + base, size, state); +#if QLZ_STREAMING_BUFFER > 0 + reset_table_compress(state); +#endif + if(r == base) + { + bench_memcpy(destination + base, source, size); + r = size + base; + compressed = 0; + } + else + { + compressed = 1; + } + state->stream_counter = 0; + } +#if QLZ_STREAMING_BUFFER > 0 + else + { + unsigned char *src = state->stream_buffer + state->stream_counter; + + bench_memcpy(src, source, size); + r = base + qlz_compress_core(src, (unsigned char*)destination + base, size, state); + + if(r == base) + { + bench_memcpy(destination + base, src, size); + r = size + base; + compressed = 0; + reset_table_compress(state); + } + else + { + compressed = 1; + } + state->stream_counter += size; + } +#endif + if(base == 3) + { + *destination = (unsigned char)(0 | compressed); + *(destination + 1) = (unsigned char)r; + *(destination + 2) = (unsigned char)size; + } + else + { + *destination = (unsigned char)(2 | compressed); + fast_write((ui32)r, destination + 1, 4); + fast_write((ui32)size, destination + 5, 4); + } + + *destination |= (QLZ_COMPRESSION_LEVEL << 2); + *destination |= (1 << 6); + *destination |= ((QLZ_STREAMING_BUFFER == 0 ? 0 : (QLZ_STREAMING_BUFFER == 100000 ? 1 : (QLZ_STREAMING_BUFFER == 1000000 ? 2 : 3))) << 4); + +// 76543210 +// 01SSLLHC + + return r; +} + +size_t qlz_decompress(const char *source, void *destination, qlz_state_decompress *state) +{ + size_t dsiz = qlz_size_decompressed(source); + +#if QLZ_STREAMING_BUFFER > 0 + if (state->stream_counter + qlz_size_decompressed(source) - 1 >= QLZ_STREAMING_BUFFER) +#endif + { + if((*source & 1) == 1) + { + reset_table_decompress(state); + dsiz = qlz_decompress_core((const unsigned char *)source, (unsigned char *)destination, dsiz, state, (const unsigned char *)destination); + } + else + { + bench_memcpy(destination, source + qlz_size_header(source), dsiz); + } + state->stream_counter = 0; + reset_table_decompress(state); + } +#if QLZ_STREAMING_BUFFER > 0 + else + { + unsigned char *dst = state->stream_buffer + state->stream_counter; + if((*source & 1) == 1) + { + dsiz = qlz_decompress_core((const unsigned char *)source, dst, dsiz, state, (const unsigned char *)state->stream_buffer); + } + else + { + bench_memcpy(dst, source + qlz_size_header(source), dsiz); + reset_table_decompress(state); + } + bench_memcpy(destination, dst, dsiz); + state->stream_counter += dsiz; + } +#endif + return dsiz; +} + diff --git a/am-kernels/benchmarks/microbench/src/lzip/quicklz.h b/am-kernels/benchmarks/microbench/src/lzip/quicklz.h new file mode 100644 index 0000000..bb87ee6 --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/lzip/quicklz.h @@ -0,0 +1,164 @@ +#ifndef QLZ_HEADER +#define QLZ_HEADER + +#include +#include + +static inline void* bench_memcpy(void* dst, const void* src, size_t n){ + assert(dst&&src); + const char* s; + char* d; + if(src+n>dst&&src0)*--d=*--s; + } + else{ + s=src; + d=dst; + while(n-->0)*d++=*s++; + } + return dst; +} + + +// Fast data compression library +// Copyright (C) 2006-2011 Lasse Mikkel Reinhold +// lar@quicklz.com +// +// QuickLZ can be used for free under the GPL 1, 2 or 3 license (where anything +// released into public must be open source) or under a commercial license if such +// has been acquired (see http://www.quicklz.com/order.html). The commercial license +// does not cover derived or ported versions created by third parties under GPL. + +// You can edit following user settings. Data must be decompressed with the same +// setting of QLZ_COMPRESSION_LEVEL and QLZ_STREAMING_BUFFER as it was compressed +// (see manual). If QLZ_STREAMING_BUFFER > 0, scratch buffers must be initially +// zeroed out (see manual). First #ifndef makes it possible to define settings from +// the outside like the compiler command line. + +// 1.5.0 final + +#ifndef QLZ_COMPRESSION_LEVEL + + // 1 gives fastest compression speed. 3 gives fastest decompression speed and best + // compression ratio. + //#define QLZ_COMPRESSION_LEVEL 1 + //#define QLZ_COMPRESSION_LEVEL 2 + //#define QLZ_COMPRESSION_LEVEL 3 + #define QLZ_COMPRESSION_LEVEL 2 + + // If > 0, zero out both states prior to first call to qlz_compress() or qlz_decompress() + // and decompress packets in the same order as they were compressed + #define QLZ_STREAMING_BUFFER 0 + //#define QLZ_STREAMING_BUFFER 100000 + //#define QLZ_STREAMING_BUFFER 1000000 + + // Guarantees that decompression of corrupted data cannot crash. Decreases decompression + // speed 10-20%. Compression speed not affected. + //#define QLZ_MEMORY_SAFE +#endif + +#define QLZ_VERSION_MAJOR 1 +#define QLZ_VERSION_MINOR 5 +#define QLZ_VERSION_REVISION 0 + +// Verify compression level +#if QLZ_COMPRESSION_LEVEL != 1 && QLZ_COMPRESSION_LEVEL != 2 && QLZ_COMPRESSION_LEVEL != 3 +#error QLZ_COMPRESSION_LEVEL must be 1, 2 or 3 +#endif + +typedef unsigned int ui32; +typedef unsigned short int ui16; + +// Decrease QLZ_POINTERS for level 3 to increase compression speed. Do not touch any other values! +#if QLZ_COMPRESSION_LEVEL == 1 +#define QLZ_POINTERS 1 +#define QLZ_HASH_VALUES 4096 +#elif QLZ_COMPRESSION_LEVEL == 2 +#define QLZ_POINTERS 4 +#define QLZ_HASH_VALUES 2048 +#elif QLZ_COMPRESSION_LEVEL == 3 +#define QLZ_POINTERS 16 +#define QLZ_HASH_VALUES 4096 +#endif + +// hash entry +typedef struct +{ +#if QLZ_COMPRESSION_LEVEL == 1 + ui32 cache; +#if defined QLZ_PTR_64 && QLZ_STREAMING_BUFFER == 0 + unsigned int offset; +#else + const unsigned char *offset; +#endif +#else + const unsigned char *offset[QLZ_POINTERS]; +#endif + +} qlz_hash_compress; + +typedef struct +{ +#if QLZ_COMPRESSION_LEVEL == 1 + const unsigned char *offset; +#else + const unsigned char *offset[QLZ_POINTERS]; +#endif +} qlz_hash_decompress; + + +// states +typedef struct +{ + #if QLZ_STREAMING_BUFFER > 0 + unsigned char stream_buffer[QLZ_STREAMING_BUFFER]; + #endif + size_t stream_counter; + qlz_hash_compress hash[QLZ_HASH_VALUES]; + unsigned char hash_counter[QLZ_HASH_VALUES]; +} qlz_state_compress; + + +#if QLZ_COMPRESSION_LEVEL == 1 || QLZ_COMPRESSION_LEVEL == 2 + typedef struct + { +#if QLZ_STREAMING_BUFFER > 0 + unsigned char stream_buffer[QLZ_STREAMING_BUFFER]; +#endif + qlz_hash_decompress hash[QLZ_HASH_VALUES]; + unsigned char hash_counter[QLZ_HASH_VALUES]; + size_t stream_counter; + } qlz_state_decompress; +#elif QLZ_COMPRESSION_LEVEL == 3 + typedef struct + { +#if QLZ_STREAMING_BUFFER > 0 + unsigned char stream_buffer[QLZ_STREAMING_BUFFER]; +#endif +#if QLZ_COMPRESSION_LEVEL <= 2 + qlz_hash_decompress hash[QLZ_HASH_VALUES]; +#endif + size_t stream_counter; + } qlz_state_decompress; +#endif + + +#if defined (__cplusplus) +extern "C" { +#endif + +// Public functions of QuickLZ +size_t qlz_size_decompressed(const char *source); +size_t qlz_size_compressed(const char *source); +size_t qlz_compress(const void *source, char *destination, size_t size, qlz_state_compress *state); +size_t qlz_decompress(const char *source, void *destination, qlz_state_decompress *state); +int qlz_get_setting(int setting); + +#if defined (__cplusplus) +} +#endif + +#endif + diff --git a/am-kernels/benchmarks/microbench/src/md5/md5.c b/am-kernels/benchmarks/microbench/src/md5/md5.c new file mode 100644 index 0000000..5ce3d65 --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/md5/md5.c @@ -0,0 +1,159 @@ +/* + * Simple MD5 implementation (github.com/pod32g/md5) + * + */ + +#include + +static int N; + +// Constants are the integer part of the sines of integers (in radians) * 2^32. +const uint32_t k[64] = { +0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee , +0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501 , +0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be , +0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821 , +0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa , +0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8 , +0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed , +0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a , +0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c , +0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70 , +0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05 , +0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665 , +0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039 , +0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1 , +0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1 , +0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 }; + +// r specifies the per-round shift amounts +static const uint32_t r[] = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, + 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, + 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, + 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21}; + +// leftrotate function definition +#define LEFTROTATE(x, c) (((x) << (c)) | ((x) >> (32 - (c)))) + +static void to_bytes(uint32_t val, uint8_t *bytes) +{ + bytes[0] = (uint8_t) val; + bytes[1] = (uint8_t) (val >> 8); + bytes[2] = (uint8_t) (val >> 16); + bytes[3] = (uint8_t) (val >> 24); +} + +static uint32_t to_int32(const uint8_t *bytes) +{ + return (uint32_t) bytes[0] + | ((uint32_t) bytes[1] << 8) + | ((uint32_t) bytes[2] << 16) + | ((uint32_t) bytes[3] << 24); +} + +static void md5(uint8_t *msg, size_t initial_len, uint8_t *digest) { + + // These vars will contain the hash + uint32_t h0, h1, h2, h3; + + size_t new_len, offset; + uint32_t w[16]; + uint32_t a, b, c, d, i, f, g, temp; + + // Initialize variables - simple count in nibbles: + h0 = 0x67452301; + h1 = 0xefcdab89; + h2 = 0x98badcfe; + h3 = 0x10325476; + + //Pre-processing: + //append "1" bit to message + //append "0" bits until message length in bits ≡ 448 (mod 512) + //append length mod (2^64) to message + + for (new_len = initial_len + 1; new_len % (512/8) != 448/8; new_len++) + ; + + msg[initial_len] = 0x80; // append the "1" bit; most significant bit is "first" + for (offset = initial_len + 1; offset < new_len; offset++) + msg[offset] = 0; // append "0" bits + + // append the len in bits at the end of the buffer. + to_bytes(initial_len*8, msg + new_len); + // initial_len>>29 == initial_len*8>>32, but avoids overflow. + to_bytes(initial_len>>29, msg + new_len + 4); + + // Process the message in successive 512-bit chunks: + //for each 512-bit chunk of message: + for(offset=0; offsetsize; + bench_srand(1); + str = bench_alloc(N); + for (int i = 0; i < N; i ++) { + str[i] = bench_rand(); + } + digest = bench_alloc(16); +} + +void bench_md5_run() { + md5(str, N, digest); +} + +int bench_md5_validate() { + return checksum(digest, digest + 16) == setting->checksum; +} diff --git a/am-kernels/benchmarks/microbench/src/qsort/qsort.c b/am-kernels/benchmarks/microbench/src/qsort/qsort.c new file mode 100644 index 0000000..da9c593 --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/qsort/qsort.c @@ -0,0 +1,44 @@ +#include + +static int N, *data; + +void bench_qsort_prepare() { + bench_srand(1); + + N = setting->size; + + data = bench_alloc(N * sizeof(int)); + for (int i = 0; i < N; i ++) { + int a = bench_rand(); + int b = bench_rand(); + data[i] = (a << 16) | b; + } +} + +static void swap(int *a, int *b) { + int t = *a; + *a = *b; + *b = t; +} + +static void myqsort(int *a, int l, int r) { + if (l < r) { + int p = a[l], pivot = l, j; + for (j = l + 1; j < r; j ++) { + if (a[j] < p) { + swap(&a[++pivot], &a[j]); + } + } + swap(&a[pivot], &a[l]); + myqsort(a, l, pivot); + myqsort(a, pivot + 1, r); + } +} + +void bench_qsort_run() { + myqsort(data, 0, N); +} + +int bench_qsort_validate() { + return checksum(data, data + N) == setting->checksum; +} diff --git a/am-kernels/benchmarks/microbench/src/queen/queen.c b/am-kernels/benchmarks/microbench/src/queen/queen.c new file mode 100644 index 0000000..91c0f32 --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/queen/queen.c @@ -0,0 +1,32 @@ +#include + +static unsigned int FULL; + +static unsigned int dfs(unsigned int row, unsigned int ld, unsigned int rd) { + if (row == FULL) { + return 1; + } else { + unsigned int pos = FULL & (~(row | ld | rd)), ans = 0; + while (pos) { + unsigned int p = (pos & (~pos + 1)); + pos -= p; + ans += dfs(row | p, (ld | p) << 1, (rd | p) >> 1); + } + return ans; + } +} + +static unsigned int ans; + +void bench_queen_prepare() { + ans = 0; + FULL = (1 << setting->size) - 1; +} + +void bench_queen_run() { + ans = dfs(0, 0, 0); +} + +int bench_queen_validate() { + return ans == setting->checksum; +} diff --git a/am-kernels/benchmarks/microbench/src/sieve/sieve.c b/am-kernels/benchmarks/microbench/src/sieve/sieve.c new file mode 100644 index 0000000..01755f9 --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/sieve/sieve.c @@ -0,0 +1,42 @@ +#include + +static int N; + +static int ans; +static uint32_t *primes; + +static inline int get(int n) { + return (primes[n >> 5] >> (n & 31)) & 1; +} + +static inline void clear(int n) { + primes[n >> 5] &= ~(1ul << (n & 31)); +} + +void bench_sieve_prepare() { + N = setting->size; + primes = (uint32_t*)bench_alloc(N / 8 + 128); + for (int i = 0; i <= N / 32; i ++) { + primes[i] = 0xffffffff; + } +} + +void bench_sieve_run() { + for (int i = 1; i <= N; i ++) + if (!get(i)) return; + for (int i = 2; i * i <= N; i ++) { + if (get(i)) { + for (int j = i + i; j <= N; j += i) + clear(j); + } + } + ans = 0; + for (int i = 2; i <= N; i ++) + if (get(i)) { + ans ++; + } +} + +int bench_sieve_validate() { + return ans == setting->checksum; +} diff --git a/am-kernels/benchmarks/microbench/src/ssort/ssort.cc b/am-kernels/benchmarks/microbench/src/ssort/ssort.cc new file mode 100644 index 0000000..12b8f24 --- /dev/null +++ b/am-kernels/benchmarks/microbench/src/ssort/ssort.cc @@ -0,0 +1,111 @@ +// This is the Skew algorithm's reference implementation. + +#include + +static int N; + +inline bool leq(int a1, int a2, int b1, int b2) { // lexic. order for pairs + return(a1 < b1 || (a1 == b1 && a2 <= b2)); +} // and triples +inline bool leq(int a1, int a2, int a3, int b1, int b2, int b3) { + return(a1 < b1 || (a1 == b1 && leq(a2,a3, b2,b3))); +} +// stably sort a[0..n-1] to b[0..n-1] with keys in 0..K from r +static void radixPass(int* a, int* b, int* r, int n, int K) +{ // count occurrences + int* c = (int*)bench_alloc(sizeof(int)*(K+1)); + for (int i = 0; i <= K; i++) c[i] = 0; // reset counters + for (int i = 0; i < n; i++) c[r[a[i]]]++; // count occurences + for (int i = 0, sum = 0; i <= K; i++) { // exclusive prefix sums + int t = c[i]; c[i] = sum; sum += t; + } + for (int i = 0; i < n; i++) b[c[r[a[i]]]++] = a[i]; // sort +} + +// find the suffix array SA of s[0..n-1] in {1..K}^n +// require s[n]=s[n+1]=s[n+2]=0, n>=2 +void suffixArray(int* s, int* SA, int n, int K) { + int n0=(n+2)/3, n1=(n+1)/3, n2=n/3, n02=n0+n2; + int* s12 = (int*)bench_alloc(sizeof(int)*(n02+3)); s12[n02]= s12[n02+1]= s12[n02+2]=0; + int* SA12 = (int*)bench_alloc(sizeof(int)*(n02+3)); SA12[n02]=SA12[n02+1]=SA12[n02+2]=0; + int* s0 = (int*)bench_alloc(sizeof(int)*n0); + int* SA0 = (int*)bench_alloc(sizeof(int)*n0); + + // generate positions of mod 1 and mod 2 suffixes + // the "+(n0-n1)" adds a dummy mod 1 suffix if n%3 == 1 + for (int i=0, j=0; i < n+(n0-n1); i++) if (i%3 != 0) s12[j++] = i; + + // lsb radix sort the mod 1 and mod 2 triples + radixPass(s12 , SA12, s+2, n02, K); + radixPass(SA12, s12 , s+1, n02, K); + radixPass(s12 , SA12, s , n02, K); + + // find lexicographic names of triples + int name = 0, c0 = -1, c1 = -1, c2 = -1; + for (int i = 0; i < n02; i++) { + if (s[SA12[i]] != c0 || s[SA12[i]+1] != c1 || s[SA12[i]+2] != c2) { + name++; c0 = s[SA12[i]]; c1 = s[SA12[i]+1]; c2 = s[SA12[i]+2]; + } + if (SA12[i] % 3 == 1) { s12[SA12[i]/3] = name; } // left half + else { s12[SA12[i]/3 + n0] = name; } // right half + } + + // recurse if names are not yet unique + if (name < n02) { + suffixArray(s12, SA12, n02, name); + // store unique names in s12 using the suffix array + for (int i = 0; i < n02; i++) s12[SA12[i]] = i + 1; + } else // generate the suffix array of s12 directly + for (int i = 0; i < n02; i++) SA12[s12[i] - 1] = i; + + // stably sort the mod 0 suffixes from SA12 by their first character + for (int i=0, j=0; i < n02; i++) if (SA12[i] < n0) s0[j++] = 3*SA12[i]; + radixPass(s0, SA0, s, n0, K); + + // merge sorted SA0 suffixes and sorted SA12 suffixes + for (int p=0, t=n0-n1, k=0; k < n; k++) { +#define GetI() (SA12[t] < n0 ? SA12[t] * 3 + 1 : (SA12[t] - n0) * 3 + 2) + int i = GetI(); // pos of current offset 12 suffix + int j = SA0[p]; // pos of current offset 0 suffix + if (SA12[t] < n0 ? + leq(s[i], s12[SA12[t] + n0], s[j], s12[j/3]) : + leq(s[i],s[i+1],s12[SA12[t]-n0+1], s[j],s[j+1],s12[j/3+n0])) + { // suffix from SA12 is smaller + SA[k] = i; t++; + if (t == n02) { // done --- only SA0 suffixes left + for (k++; p < n0; p++, k++) SA[k] = SA0[p]; + } + } else { + SA[k] = j; p++; + if (p == n0) { // done --- only SA12 suffixes left + for (k++; t < n02; t++, k++) SA[k] = GetI(); + } + } + } +} + +extern "C" { + +static int *s, *sa; + +void bench_ssort_prepare() { + N = setting->size; + bench_srand(1); + s = (int*)bench_alloc(sizeof(int)*(N+10)); + sa = (int*)bench_alloc(sizeof(int)*(N+10)); + + for (int i = 0; i < N; i ++) { + s[i] = bench_rand() % 26; + } +} + +void bench_ssort_run() { + suffixArray(s, sa, N, 26); +} + +int bench_ssort_validate() { + return checksum(sa, sa + N) == setting->checksum; +} + +} + diff --git a/am-kernels/kernels/bad-apple/Makefile b/am-kernels/kernels/bad-apple/Makefile new file mode 100644 index 0000000..671827e --- /dev/null +++ b/am-kernels/kernels/bad-apple/Makefile @@ -0,0 +1,23 @@ +VIDEO_ROW = 25 +VIDEO_COL = 80 +AUDIO_FREQ = 44100 +AUDIO_CHANNEL = 1 + +VIDEO_SRC = bad-apple.mp4 +VIDEO = build/video.frame +AUDIO = build/audio.pcm + +NAME = bad-apple +SRCS = bad-apple.c resources.S +include $(AM_HOME)/Makefile + +CFLAGS += -DVIDEO_ROW=$(VIDEO_ROW) -DVIDEO_COL=$(VIDEO_COL) \ + -DAUDIO_FREQ=$(AUDIO_FREQ) -DAUDIO_CHANNEL=$(AUDIO_CHANNEL) +ASFLAGS += -DVIDEO_FILE=\"$(abspath $(VIDEO))\" -DAUDIO_FILE=\"$(abspath $(AUDIO))\" +$(VIDEO): + ffmpeg -i $(VIDEO_SRC) -f image2pipe -s $(VIDEO_COL)x$(VIDEO_ROW) -vcodec rawvideo -pix_fmt monow $@ + +$(AUDIO): + ffmpeg -i $(VIDEO_SRC) -vn -acodec pcm_s16le -f s16le -ac $(AUDIO_CHANNEL) -ar $(AUDIO_FREQ) $@ + +resources.S: $(VIDEO) $(AUDIO) diff --git a/am-kernels/kernels/bad-apple/bad-apple.c b/am-kernels/kernels/bad-apple/bad-apple.c new file mode 100644 index 0000000..06a8c60 --- /dev/null +++ b/am-kernels/kernels/bad-apple/bad-apple.c @@ -0,0 +1,74 @@ +#include +#include +#include + +#define FPS 30 +#define CHAR_WHITE '.' +#define CHAR_BLACK 'X' + +typedef struct { + uint8_t pixel[VIDEO_ROW * VIDEO_COL / 8]; +} frame_t; + +static void sleep_until(uint64_t next) { + while (io_read(AM_TIMER_UPTIME).us < next) ; +} + +static uint8_t getbit(uint8_t *p, int idx) { + int byte_idx = idx / 8; + int bit_idx = idx % 8; + bit_idx = 7 - bit_idx; + uint8_t byte = p[byte_idx]; + uint8_t bit = (byte >> bit_idx) & 1; + return bit; +} + +int main() { + extern uint8_t video_payload, video_payload_end; + extern uint8_t audio_payload, audio_payload_end; + int audio_len = 0, audio_left = 0; + Area sbuf; + + ioe_init(); + + frame_t *f = (void *)&video_payload; + frame_t *fend = (void *)&video_payload_end; + printf("\033[H\033[J"); // screan_clear + + bool has_audio = io_read(AM_AUDIO_CONFIG).present; + if (has_audio) { + io_write(AM_AUDIO_CTRL, AUDIO_FREQ, AUDIO_CHANNEL, 1024); + audio_left = audio_len = &audio_payload_end - &audio_payload; + sbuf.start = &audio_payload; + } + + uint64_t now = io_read(AM_TIMER_UPTIME).us; + for (; f < fend; f ++) { + printf("\033[0;0H"); // reset cursor + for (int y = 0; y < VIDEO_ROW; y++) { + for (int x = 0; x < VIDEO_COL; x++) { + uint8_t p = getbit(f->pixel, y * VIDEO_COL + x); + putch(p ? CHAR_BLACK : CHAR_WHITE); + } + putch('\n'); + } + + if (has_audio) { + int should_play = (AUDIO_FREQ / FPS) * sizeof(int16_t); + if (should_play > audio_left) should_play = audio_left; + while (should_play > 0) { + int len = (should_play > 4096 ? 4096 : should_play); + sbuf.end = sbuf.start + len; + io_write(AM_AUDIO_PLAY, sbuf); + sbuf.start += len; + should_play -= len; + } + audio_left -= should_play; + } + + uint64_t next = now + (1000 * 1000 / FPS); + sleep_until(next); + now = next; + } + return 0; +} diff --git a/am-kernels/kernels/bad-apple/bad-apple.mp4 b/am-kernels/kernels/bad-apple/bad-apple.mp4 new file mode 100644 index 0000000..c96449a Binary files /dev/null and b/am-kernels/kernels/bad-apple/bad-apple.mp4 differ diff --git a/am-kernels/kernels/bad-apple/resources.S b/am-kernels/kernels/bad-apple/resources.S new file mode 100644 index 0000000..7332567 --- /dev/null +++ b/am-kernels/kernels/bad-apple/resources.S @@ -0,0 +1,12 @@ +.section .data +.global video_payload, video_payload_end +.p2align 3 +video_payload: +.incbin VIDEO_FILE +video_payload_end: + +.global audio_payload, audio_payload_end +.p2align 3 +audio_payload: +.incbin AUDIO_FILE +audio_payload_end: diff --git a/am-kernels/kernels/demo/Makefile b/am-kernels/kernels/demo/Makefile new file mode 100644 index 0000000..61835c5 --- /dev/null +++ b/am-kernels/kernels/demo/Makefile @@ -0,0 +1,3 @@ +NAME = demo +SRCS = $(shell find src -name "*.c") +include $(AM_HOME)/Makefile diff --git a/am-kernels/kernels/demo/include/io.h b/am-kernels/kernels/demo/include/io.h new file mode 100644 index 0000000..9ed6b50 --- /dev/null +++ b/am-kernels/kernels/demo/include/io.h @@ -0,0 +1,97 @@ +#ifndef __DRAW_H__ + +#define HAS_GUI + +#include +#include +#include +#include + +#define ANSI_COLOR_RED 31 +#define ANSI_COLOR_GREEN 32 +#define ANSI_COLOR_WHITE 37 +#define ANSI_COLOR_RESET 0 + +#ifdef HAS_GUI +#define TILE_W 4 +#define SCREEN_W 320 +#define SCREEN_H 200 +static inline void set_color(int c) { +} + +static inline void print_char(char c, int y, int x) { + static char last_c = 0xff; + static uint32_t buf[TILE_W * TILE_W]; + if (last_c != c) { + last_c = c; + uint32_t color = 0x0; + if (c != ' ') { // convert different character to different color + uint8_t r = c / 25; + c -= r * 25; + uint8_t g = c / 5; + c -= g * 5; + uint8_t b = c; + r = r * 0x100 / 5; + g = g * 0x100 / 5; + b = b * 0x100 / 5; + color = (r << 16) | (g << 8) | b; + } + int i; + for (i = 0; i < TILE_W * TILE_W; i ++) { + buf[i] = color; + } + } + io_write(AM_GPU_FBDRAW, x * TILE_W, y * TILE_W, buf, TILE_W, TILE_W, false); +} + +static inline void screen_clear() { + static uint32_t buf[SCREEN_W]; + int i; + for (i = 0; i < SCREEN_H; i ++) { + io_write(AM_GPU_FBDRAW, 0, i, buf, SCREEN_W, 1, false); + } +} + +static inline void screen_refresh() { + io_write(AM_GPU_FBDRAW, 0, 0, NULL, 0, 0, true); +} + +static inline int screen_tile_height() { + return io_read(AM_GPU_CONFIG).height / TILE_W; +} + +static inline int screen_tile_width() { + return io_read(AM_GPU_CONFIG).width / TILE_W; +} +#else +static inline void set_color(int c) { + printf("\033[%dm", c); +} + +static inline void print_char(char c, int y, int x) { + printf("\033[%d;%dH%c", y + 1, x + 1, c); +} + +static inline void screen_clear() { + printf("\033[H\033[J"); +} + +static inline void screen_refresh() { +} + +static inline int screen_tile_height() { + return 24; +} + +static inline int screen_tile_width() { + return 80; +} +#endif + +static inline void usleep(int us) { + uint64_t now = io_read(AM_TIMER_UPTIME).us; + uint64_t next = now + us; + while (io_read(AM_TIMER_UPTIME).us < next) ; +} + +#endif diff --git a/am-kernels/kernels/demo/src/aclock/aclock.c b/am-kernels/kernels/demo/src/aclock/aclock.c new file mode 100644 index 0000000..4e74ff5 --- /dev/null +++ b/am-kernels/kernels/demo/src/aclock/aclock.c @@ -0,0 +1,219 @@ +/* + * aclock - ascii clock for vt100 terminals + * failsafe mode: + * > no curses / termcap required + * > no floating point required + * > no ANSI C compiler required + * + * Copyright (c) 2002 Antoni Sawicki + * Version 1.8 (knr-nofloat-vt100); Dublin, June 2002 + * + * Compilation: cc aclock-vt100.c -o aclock + * + * https://github.com/tenox7/aclock/blob/master/sources/aclock-vt100.c + * + * 2021-03-26 Meco Man port to RT-Thread + * + */ + +#include +#include +#include +#include + +static const int minute[60][8][2] = { + { { 39,11 },{ 39,10 },{ 39,9 },{ 39,8 },{ 39,7 },{ 39,6 },{ 39,5 },{ 39,4 } }, + { { 40,11 },{ 40,10 },{ 40,9 },{ 40,8 },{ 41,7 },{ 41,6 },{ 41,5 },{ 41,4 } }, + { { 40,11 },{ 40,10 },{ 41,9 },{ 41,8 },{ 42,7 },{ 42,6 },{ 42,5 },{ 43,4 } }, + { { 40,11 },{ 41,10 },{ 41,9 },{ 42,8 },{ 43,7 },{ 43,6 },{ 44,5 },{ 44,4 } }, + { { 40,11 },{ 41,10 },{ 42,9 },{ 43,8 },{ 44,7 },{ 44,6 },{ 45,5 },{ 46,4 } }, + { { 40,11 },{ 41,10 },{ 42,9 },{ 43,8 },{ 44,7 },{ 45,6 },{ 46,5 },{ 47,5 } }, + { { 41,11 },{ 42,10 },{ 43,9 },{ 44,8 },{ 45,7 },{ 47,7 },{ 48,6 },{ 49,5 } }, + { { 41,11 },{ 42,10 },{ 44,9 },{ 45,9 },{ 46,8 },{ 48,7 },{ 49,6 },{ 50,6 } }, + { { 41,11 },{ 42,10 },{ 44,9 },{ 45,9 },{ 47,8 },{ 48,7 },{ 50,7 },{ 51,6 } }, + { { 41,11 },{ 43,10 },{ 44,10 },{ 46,9 },{ 48,9 },{ 49,8 },{ 51,7 },{ 52,7 } }, + { { 41,11 },{ 43,10 },{ 45,10 },{ 46,9 },{ 48,9 },{ 50,8 },{ 52,8 },{ 53,7 } }, + { { 41,11 },{ 43,11 },{ 45,10 },{ 47,10 },{ 49,9 },{ 50,9 },{ 52,9 },{ 54,8 } }, + { { 41,11 },{ 43,11 },{ 45,11 },{ 47,10 },{ 49,10 },{ 51,10 },{ 53,9 },{ 55,9 } }, + { { 41,11 },{ 43,11 },{ 45,11 },{ 47,11 },{ 49,10 },{ 51,10 },{ 53,10 },{ 55,10 } }, + { { 41,11 },{ 43,11 },{ 45,11 },{ 47,11 },{ 49,11 },{ 51,11 },{ 53,11 },{ 55,11 } }, + { { 42,12 },{ 44,12 },{ 46,12 },{ 48,12 },{ 50,12 },{ 52,12 },{ 54,12 },{ 56,12 } }, + { { 41,12 },{ 43,12 },{ 45,12 },{ 47,12 },{ 49,12 },{ 51,12 },{ 53,12 },{ 55,12 } }, + { { 41,12 },{ 43,12 },{ 45,12 },{ 47,12 },{ 49,13 },{ 51,13 },{ 53,13 },{ 55,13 } }, + { { 41,12 },{ 43,12 },{ 45,12 },{ 47,13 },{ 49,13 },{ 51,13 },{ 53,14 },{ 55,14 } }, + { { 41,12 },{ 43,12 },{ 45,13 },{ 47,13 },{ 49,14 },{ 50,14 },{ 52,14 },{ 54,15 } }, + { { 41,12 },{ 43,13 },{ 45,13 },{ 46,14 },{ 48,14 },{ 50,15 },{ 52,15 },{ 53,16 } }, + { { 41,12 },{ 43,13 },{ 44,13 },{ 46,14 },{ 48,14 },{ 49,15 },{ 51,16 },{ 52,16 } }, + { { 41,12 },{ 42,13 },{ 44,14 },{ 45,14 },{ 47,15 },{ 48,16 },{ 50,16 },{ 51,17 } }, + { { 41,12 },{ 42,13 },{ 44,14 },{ 45,14 },{ 46,15 },{ 48,16 },{ 49,17 },{ 50,17 } }, + { { 41,12 },{ 42,13 },{ 43,14 },{ 44,15 },{ 45,16 },{ 47,16 },{ 48,17 },{ 49,18 } }, + { { 40,12 },{ 41,13 },{ 42,14 },{ 43,15 },{ 44,16 },{ 45,17 },{ 46,18 },{ 47,18 } }, + { { 40,12 },{ 41,13 },{ 42,14 },{ 43,15 },{ 44,16 },{ 44,17 },{ 45,18 },{ 46,19 } }, + { { 40,12 },{ 41,13 },{ 41,14 },{ 42,15 },{ 43,16 },{ 43,17 },{ 44,18 },{ 44,19 } }, + { { 40,12 },{ 40,13 },{ 41,14 },{ 41,15 },{ 42,16 },{ 42,17 },{ 42,18 },{ 43,19 } }, + { { 40,12 },{ 40,13 },{ 40,14 },{ 40,15 },{ 41,16 },{ 41,17 },{ 41,18 },{ 41,19 } }, + { { 39,12 },{ 39,13 },{ 39,14 },{ 39,15 },{ 39,16 },{ 39,17 },{ 39,18 },{ 39,19 } }, + { { 39,12 },{ 39,13 },{ 39,14 },{ 39,15 },{ 38,16 },{ 38,17 },{ 38,18 },{ 38,19 } }, + { { 39,12 },{ 39,13 },{ 38,14 },{ 38,15 },{ 37,16 },{ 37,17 },{ 37,18 },{ 36,19 } }, + { { 39,12 },{ 38,13 },{ 38,14 },{ 37,15 },{ 36,16 },{ 36,17 },{ 35,18 },{ 35,19 } }, + { { 39,12 },{ 38,13 },{ 37,14 },{ 36,15 },{ 35,16 },{ 35,17 },{ 34,18 },{ 33,19 } }, + { { 38,12 },{ 37,13 },{ 36,14 },{ 35,15 },{ 34,16 },{ 33,17 },{ 32,18 },{ 31,18 } }, + { { 38,12 },{ 37,13 },{ 36,14 },{ 35,15 },{ 34,16 },{ 32,16 },{ 31,17 },{ 30,18 } }, + { { 38,12 },{ 37,13 },{ 35,14 },{ 34,14 },{ 33,15 },{ 31,16 },{ 30,17 },{ 29,17 } }, + { { 38,12 },{ 37,13 },{ 35,14 },{ 34,14 },{ 32,15 },{ 31,16 },{ 29,16 },{ 28,17 } }, + { { 38,12 },{ 36,13 },{ 35,13 },{ 33,14 },{ 31,14 },{ 30,15 },{ 28,16 },{ 27,16 } }, + { { 38,12 },{ 36,13 },{ 34,13 },{ 33,14 },{ 31,14 },{ 29,15 },{ 27,15 },{ 26,16 } }, + { { 38,12 },{ 36,12 },{ 34,13 },{ 32,13 },{ 30,14 },{ 29,14 },{ 27,14 },{ 25,15 } }, + { { 38,12 },{ 36,12 },{ 34,12 },{ 32,13 },{ 30,13 },{ 28,13 },{ 26,14 },{ 24,14 } }, + { { 38,12 },{ 36,12 },{ 34,12 },{ 32,12 },{ 30,13 },{ 28,13 },{ 26,13 },{ 24,13 } }, + { { 38,12 },{ 36,12 },{ 34,12 },{ 32,12 },{ 30,12 },{ 28,12 },{ 26,12 },{ 24,12 } }, + { { 38,11 },{ 36,11 },{ 34,11 },{ 32,11 },{ 30,11 },{ 28,11 },{ 26,11 },{ 24,11 } }, + { { 38,11 },{ 36,11 },{ 34,11 },{ 32,11 },{ 30,11 },{ 28,11 },{ 26,11 },{ 24,11 } }, + { { 38,11 },{ 36,11 },{ 34,11 },{ 32,11 },{ 30,10 },{ 28,10 },{ 26,10 },{ 24,10 } }, + { { 38,11 },{ 36,11 },{ 34,11 },{ 32,10 },{ 30,10 },{ 28,10 },{ 26,9 },{ 24,9 } }, + { { 38,11 },{ 36,11 },{ 34,10 },{ 32,10 },{ 30,9 },{ 29,9 },{ 27,9 },{ 25,8 } }, + { { 38,11 },{ 36,11 },{ 34,10 },{ 33,10 },{ 31,9 },{ 29,9 },{ 27,8 },{ 26,8 } }, + { { 38,11 },{ 36,10 },{ 35,10 },{ 33,9 },{ 31,9 },{ 30,8 },{ 28,7 },{ 27,7 } }, + { { 38,11 },{ 37,10 },{ 35,9 },{ 34,9 },{ 32,8 },{ 31,7 },{ 29,7 },{ 28,6 } }, + { { 38,11 },{ 37,10 },{ 35,9 },{ 34,9 },{ 33,8 },{ 31,7 },{ 30,6 },{ 29,6 } }, + { { 38,11 },{ 37,10 },{ 36,9 },{ 35,8 },{ 34,7 },{ 32,7 },{ 31,6 },{ 30,5 } }, + { { 39,11 },{ 38,10 },{ 37,9 },{ 36,8 },{ 35,7 },{ 34,6 },{ 33,5 },{ 32,5 } }, + { { 39,11 },{ 38,10 },{ 37,9 },{ 36,8 },{ 35,7 },{ 35,6 },{ 34,5 },{ 33,4 } }, + { { 39,11 },{ 38,10 },{ 38,9 },{ 37,8 },{ 36,7 },{ 36,6 },{ 35,5 },{ 35,4 } }, + { { 39,11 },{ 39,10 },{ 38,9 },{ 38,8 },{ 37,7 },{ 37,6 },{ 37,5 },{ 36,4 } }, + { { 39,11 },{ 39,10 },{ 39,9 },{ 39,8 },{ 38,7 },{ 38,6 },{ 38,5 },{ 38,4 } } +}; + +static const int hour[60][6][2] = { + { { 39,11 },{ 39,10 },{ 39,9 },{ 39,8 },{ 39,7 },{ 39,6 } }, + { { 40,11 },{ 40,10 },{ 40,9 },{ 40,8 },{ 41,7 },{ 41,6 } }, + { { 40,11 },{ 40,10 },{ 41,9 },{ 41,8 },{ 42,7 },{ 42,6 } }, + { { 40,11 },{ 41,10 },{ 41,9 },{ 42,8 },{ 43,7 },{ 43,6 } }, + { { 40,11 },{ 41,10 },{ 42,9 },{ 43,8 },{ 44,7 },{ 44,6 } }, + { { 40,11 },{ 41,10 },{ 42,9 },{ 43,8 },{ 44,7 },{ 45,6 } }, + { { 41,11 },{ 42,10 },{ 43,9 },{ 44,8 },{ 45,7 },{ 47,7 } }, + { { 41,11 },{ 42,10 },{ 44,9 },{ 45,9 },{ 46,8 },{ 48,7 } }, + { { 41,11 },{ 42,10 },{ 44,9 },{ 45,9 },{ 47,8 },{ 48,7 } }, + { { 41,11 },{ 43,10 },{ 44,10 },{ 46,9 },{ 48,9 },{ 49,8 } }, + { { 41,11 },{ 43,10 },{ 45,10 },{ 46,9 },{ 48,9 },{ 50,8 } }, + { { 41,11 },{ 43,11 },{ 45,10 },{ 47,10 },{ 49,9 },{ 50,9 } }, + { { 41,11 },{ 43,11 },{ 45,11 },{ 47,10 },{ 49,10 },{ 51,10 } }, + { { 41,11 },{ 43,11 },{ 45,11 },{ 47,11 },{ 49,10 },{ 51,10 } }, + { { 41,11 },{ 43,11 },{ 45,11 },{ 47,11 },{ 49,11 },{ 51,11 } }, + { { 42,12 },{ 44,12 },{ 46,12 },{ 48,12 },{ 50,12 },{ 52,12 } }, + { { 41,12 },{ 43,12 },{ 45,12 },{ 47,12 },{ 49,12 },{ 51,12 } }, + { { 41,12 },{ 43,12 },{ 45,12 },{ 47,12 },{ 49,13 },{ 51,13 } }, + { { 41,12 },{ 43,12 },{ 45,12 },{ 47,13 },{ 49,13 },{ 51,13 } }, + { { 41,12 },{ 43,12 },{ 45,13 },{ 47,13 },{ 49,14 },{ 50,14 } }, + { { 41,12 },{ 43,13 },{ 45,13 },{ 46,14 },{ 48,14 },{ 50,15 } }, + { { 41,12 },{ 43,13 },{ 44,13 },{ 46,14 },{ 48,14 },{ 49,15 } }, + { { 41,12 },{ 42,13 },{ 44,14 },{ 45,14 },{ 47,15 },{ 48,16 } }, + { { 41,12 },{ 42,13 },{ 44,14 },{ 45,14 },{ 46,15 },{ 48,16 } }, + { { 41,12 },{ 42,13 },{ 43,14 },{ 44,15 },{ 45,16 },{ 47,16 } }, + { { 40,12 },{ 41,13 },{ 42,14 },{ 43,15 },{ 44,16 },{ 45,17 } }, + { { 40,12 },{ 41,13 },{ 42,14 },{ 43,15 },{ 44,16 },{ 44,17 } }, + { { 40,12 },{ 41,13 },{ 41,14 },{ 42,15 },{ 43,16 },{ 43,17 } }, + { { 40,12 },{ 40,13 },{ 41,14 },{ 41,15 },{ 42,16 },{ 42,17 } }, + { { 40,12 },{ 40,13 },{ 40,14 },{ 40,15 },{ 41,16 },{ 41,17 } }, + { { 39,12 },{ 39,13 },{ 39,14 },{ 39,15 },{ 39,16 },{ 39,17 } }, + { { 39,12 },{ 39,13 },{ 39,14 },{ 39,15 },{ 38,16 },{ 38,17 } }, + { { 39,12 },{ 39,13 },{ 38,14 },{ 38,15 },{ 37,16 },{ 37,17 } }, + { { 39,12 },{ 38,13 },{ 38,14 },{ 37,15 },{ 36,16 },{ 36,17 } }, + { { 39,12 },{ 38,13 },{ 37,14 },{ 36,15 },{ 35,16 },{ 35,17 } }, + { { 38,12 },{ 37,13 },{ 36,14 },{ 35,15 },{ 34,16 },{ 33,17 } }, + { { 38,12 },{ 37,13 },{ 36,14 },{ 35,15 },{ 34,16 },{ 32,16 } }, + { { 38,12 },{ 37,13 },{ 35,14 },{ 34,14 },{ 33,15 },{ 31,16 } }, + { { 38,12 },{ 37,13 },{ 35,14 },{ 34,14 },{ 32,15 },{ 31,16 } }, + { { 38,12 },{ 36,13 },{ 35,13 },{ 33,14 },{ 31,14 },{ 30,15 } }, + { { 38,12 },{ 36,13 },{ 34,13 },{ 33,14 },{ 31,14 },{ 29,15 } }, + { { 38,12 },{ 36,12 },{ 34,13 },{ 32,13 },{ 30,14 },{ 29,14 } }, + { { 38,12 },{ 36,12 },{ 34,12 },{ 32,13 },{ 30,13 },{ 28,13 } }, + { { 38,12 },{ 36,12 },{ 34,12 },{ 32,12 },{ 30,13 },{ 28,13 } }, + { { 38,12 },{ 36,12 },{ 34,12 },{ 32,12 },{ 30,12 },{ 28,12 } }, + { { 38,11 },{ 36,11 },{ 34,11 },{ 32,11 },{ 30,11 },{ 28,11 } }, + { { 38,11 },{ 36,11 },{ 34,11 },{ 32,11 },{ 30,11 },{ 28,11 } }, + { { 38,11 },{ 36,11 },{ 34,11 },{ 32,11 },{ 30,10 },{ 28,10 } }, + { { 38,11 },{ 36,11 },{ 34,11 },{ 32,10 },{ 30,10 },{ 28,10 } }, + { { 38,11 },{ 36,11 },{ 34,10 },{ 32,10 },{ 30,9 },{ 29,9 } }, + { { 38,11 },{ 36,11 },{ 34,10 },{ 33,10 },{ 31,9 },{ 29,9 } }, + { { 38,11 },{ 36,10 },{ 35,10 },{ 33,9 },{ 31,9 },{ 30,8 } }, + { { 38,11 },{ 37,10 },{ 35,9 },{ 34,9 },{ 32,8 },{ 31,7 } }, + { { 38,11 },{ 37,10 },{ 35,9 },{ 34,9 },{ 33,8 },{ 31,7 } }, + { { 38,11 },{ 37,10 },{ 36,9 },{ 35,8 },{ 34,7 },{ 32,7 } }, + { { 39,11 },{ 38,10 },{ 37,9 },{ 36,8 },{ 35,7 },{ 34,6 } }, + { { 39,11 },{ 38,10 },{ 37,9 },{ 36,8 },{ 35,7 },{ 35,6 } }, + { { 39,11 },{ 38,10 },{ 38,9 },{ 37,8 },{ 36,7 },{ 36,6 } }, + { { 39,11 },{ 39,10 },{ 38,9 },{ 38,8 },{ 37,7 },{ 37,6 } }, + { { 39,11 },{ 39,10 },{ 39,9 },{ 39,8 },{ 38,7 },{ 38,6 } } +}; + +static const int circle[60][3] = { + { 62,12,111 }, { 61,13,46 }, { 61,14,46 }, { 60,15,46 }, + { 60,16,46 }, { 59,17,111 }, { 57,18,46 }, { 56,19,46 }, + { 54,20,46 }, { 52,20,46 }, { 51,21,111 }, { 48,22,46 }, + { 46,22,46 }, { 44,22,46 }, { 42,22,46 }, { 40,23,111 }, + { 37,22,46 }, { 35,22,46 }, { 33,22,46 }, { 31,22,46 }, + { 29,21,111 }, { 27,20,46 }, { 25,20,46 }, { 23,19,46 }, + { 22,18,46 }, { 20,17,111 }, { 19,16,46 }, { 19,15,46 }, + { 18,14,46 }, { 18,13,46 }, { 18,12,111 }, { 18,10,46 }, + { 18,9,46 }, { 19,8,46 }, { 19,7,46 }, { 20,6,111 }, + { 22,5,46 }, { 23,4,46 }, { 25,3,46 }, { 27,3,46 }, + { 28,2,111 }, { 31,1,46 }, { 33,1,46 }, { 35,1,46 }, + { 37,1,46 }, { 39,1,111 }, { 42,1,46 }, { 44,1,46 }, + { 46,1,46 }, { 48,1,46 }, { 51,2,111 }, { 52,3,46 }, + { 54,3,46 }, { 56,4,46 }, { 57,5,46 }, { 59,6,111 }, + { 60,7,46 }, { 60,8,46 }, { 61,9,46 }, { 61,10,46 } +}; + + +static void draw_point(int x, int y, int c) { + int xx = x - 16; +#ifdef HAS_GUI + xx /= 2; +#endif + print_char(c, y, xx); +} + +//void draw_text(int x, int y, char *string) { +// rt_kprintf("\033[%d;%dH%s", y, x, string); +//} + +static void draw_circle(void) { + int n; + for(n=0;n<60;n++) + draw_point(circle[n][0], circle[n][1], circle[n][2]); +} + +static void draw_hour(int n) { + int m; + for(m=0;m<6;m++) + draw_point(hour[n][m][0], hour[n][m][1], 'h'); +} + +static void draw_minute(int n) { + int m; + for(m=0;m<8;m++) + draw_point(minute[n][m][0], minute[n][m][1], 'M'); +} + +static void draw_seconds(int n) { + int m; + for(m=0;m<8;m++) + draw_point(minute[n][m][0], minute[n][m][1], '.'); +} + +void aclock(void) { + while(1) { + AM_TIMER_RTC_T rtc = io_read(AM_TIMER_RTC); + screen_clear(); + draw_circle(); + draw_hour(((rtc.hour > 12 ? rtc.hour - 12 : rtc.hour) * 5) + (rtc.minute / 10)); + draw_minute(rtc.minute); + draw_seconds(rtc.second); + screen_refresh(); + //draw_text(35, 6, ".:ACLOCK:."); + //rt_sprintf(digital_time, "[%02d:%02d:%02d]", ltime->tm_hour, ltime->tm_min, ltime->tm_sec); + //draw_text(35, 19, digital_time); + usleep(1000000); + } +} diff --git a/am-kernels/kernels/demo/src/ant/ant.c b/am-kernels/kernels/demo/src/ant/ant.c new file mode 100644 index 0000000..e355b30 --- /dev/null +++ b/am-kernels/kernels/demo/src/ant/ant.c @@ -0,0 +1,70 @@ +/* from http://rosettacode.org/wiki/Langton%27s_ant#C */ + +#include +#include +#include + +static int w = 40, h = 25; + +static unsigned char *pix = NULL; + +static void refresh(int x, int y) { + int i, j, k; + screen_clear(); + for (i = k = 0; i < h; i++) + for (j = 0; j < w; j++, k++) + print_char(pix[k] ? '#' : ' ', i, j); +} + +void ant() { + w = screen_tile_width(); + h = screen_tile_height(); + + int dx = 0, dy = 1, i, k; + int x = w / 2, y = h / 2; + + pix = malloc(w * h); + memset(pix, 0, w * h); + screen_clear(); + + while (1) { + i = (y * w + x); + if (pix[i]) k = dx, dx = -dy, dy = k; + else k = dy, dy = -dx, dx = k; + + pix[i] = !pix[i]; + print_char(pix[i] ? 'o' : ' ', y + 1, x + 1); + + x += dx, y += dy; + + k = 0; + if (x < 0) { + memmove(pix + 1, pix, w * h - 1); + for (i = 0; i < w * h; i += w) pix[i] = 0; + x++, k = 1; + } + else if (x >= w) { + memmove(pix, pix + 1, w * h - 1); + for (i = w-1; i < w * h; i += w) pix[i] = 0; + x--, k = 1; + } + + if (y >= h) { + memmove(pix, pix + w, w * (h - 1)); + memset(pix + w * (h - 1), 0, w); + y--, k = 1; + } + else if (y < 0) { + memmove(pix + w, pix, w * (h - 1)); + memset(pix, 0, w); + y++, k = 1; + } + if (k) refresh(x, y); + set_color(ANSI_COLOR_RED); + print_char('+', y + 1, x + 1); + set_color(ANSI_COLOR_RESET); + screen_refresh(); + + usleep(10000); + } +} diff --git a/am-kernels/kernels/demo/src/bf/bf.c b/am-kernels/kernels/demo/src/bf/bf.c new file mode 100644 index 0000000..0fe5bd2 --- /dev/null +++ b/am-kernels/kernels/demo/src/bf/bf.c @@ -0,0 +1,98 @@ +/* from http://rosettacode.org/wiki/Execute_Brain****#C */ +/* This is the Neutron brainfuck interpreter. + * It's rather small and dense, but still readable, more or less. + * + * Robert de Bath -- 2013. + */ +#include +#include +#include + +static const char *prog = +#include "mandelbrot.h" +; + +struct bfi { char cmd; struct bfi *next, *jmp; }; +struct mem { char val; struct mem *next, *prev; }; + +static inline void putch2(char c) { + static int x = 0, y = 0; + if (c == '\n') { + y ++; + x = 0; + } else { + if (x % 2 == 0) { + print_char(c, y, x / 2); + screen_refresh(); + } + x ++; + } +} + +void bf() { + int ch; + struct bfi *p=0, *n=0, *j=0, *pgm = 0; + struct mem *m = malloc(sizeof(*m)); + memset(m, 0, sizeof(*m)); + screen_clear(); + + /* + * For each character, if it's a valid BF command add it onto the + * end of the program. If the input is stdin use the '!' character + * to mark the end of the program and the start of the data, but + * only if we have a complete program. The 'j' variable points + * at the list of currently open '[' commands, one is matched off + * by each ']'. A ']' without a matching '[' is not a legal BF + * command and so is ignored. If there are any '[' commands left + * over at the end they are not valid BF commands and so are ignored. + */ + const char *s = prog; + while((ch = *(s ++)) != '\0') { + if (ch == '<' || ch == '>' || ch == '+' || ch == '-' || + ch == ',' || ch == '.' || ch == '[' || (ch == ']' && j)) { + if ((n = malloc(sizeof(*n))) == NULL) { + printf("malloc failed! exiting...\n"); + halt(1); + } + memset(n, 0, sizeof(*n)); + if (p) p->next = n; else pgm = n; + n->cmd = ch; p = n; + if (n->cmd == '[') { n->jmp=j; j = n; } + else if (n->cmd == ']') { + n->jmp = j; j = j->jmp; n->jmp->jmp = n; + } + } + } + + /* Ignore any left over '[' commands */ + while(j) { p = j; j = j->jmp; p->jmp = 0; p->cmd = ' '; } + + /* Execute the loaded BF program */ + for(n=pgm; n; n=n->next) { + switch(n->cmd) { + case '+': m->val++; break; + case '-': m->val--; break; + case '.': putch2(m->val); break; + case ',': if((ch=*(s ++))!='\0') m->val=ch; break; + case '[': if (m->val == 0) n=n->jmp; break; + case ']': if (m->val != 0) n=n->jmp; break; + case '<': + if (!(m=m->prev)) { + printf("Hit start of tape\n"); + halt(1); + } + break; + case '>': + if (m->next == 0) { + if ((m->next = malloc(sizeof(*m))) == NULL) { + printf("malloc failed! exiting...\n"); + halt(1); + } + memset(m->next, 0, sizeof(*m)); + m->next->prev = m; + } + m=m->next; + break; + } + } +} diff --git a/am-kernels/kernels/demo/src/bf/mandelbrot.h b/am-kernels/kernels/demo/src/bf/mandelbrot.h new file mode 100644 index 0000000..0b211a8 --- /dev/null +++ b/am-kernels/kernels/demo/src/bf/mandelbrot.h @@ -0,0 +1,146 @@ +"\ + A mandelbrot set fractal viewer in brainf*** written by Erik Bosman \ ++++++++++++++[->++>>>+++++>++>+<<<<<<]>>>>>++++++>--->>>>>>>>>>+++++++++++++++[[ \ +>>>>>>>>>]+[<<<<<<<<<]>>>>>>>>>-]+[>>>>>>>>[-]>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>[-]+ \ +<<<<<<<+++++[-[->>>>>>>>>+<<<<<<<<<]>>>>>>>>>]>>>>>>>+>>>>>>>>>>>>>>>>>>>>>>>>>> \ +>+<<<<<<<<<<<<<<<<<[<<<<<<<<<]>>>[-]+[>>>>>>[>>>>>>>[-]>>]<<<<<<<<<[<<<<<<<<<]>> \ +>>>>>[-]+<<<<<<++++[-[->>>>>>>>>+<<<<<<<<<]>>>>>>>>>]>>>>>>+<<<<<<+++++++[-[->>> \ +>>>>>>+<<<<<<<<<]>>>>>>>>>]>>>>>>+<<<<<<<<<<<<<<<<[<<<<<<<<<]>>>[[-]>>>>>>[>>>>> \ +>>[-<<<<<<+>>>>>>]<<<<<<[->>>>>>+<<+<<<+<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>> \ +[>>>>>>>>[-<<<<<<<+>>>>>>>]<<<<<<<[->>>>>>>+<<+<<<+<<]>>>>>>>>]<<<<<<<<<[<<<<<<< \ +<<]>>>>>>>[-<<<<<<<+>>>>>>>]<<<<<<<[->>>>>>>+<<+<<<<<]>>>>>>>>>+++++++++++++++[[ \ +>>>>>>>>>]+>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>-]+[ \ +>+>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>->>>>[-<<<<+>>>>]<<<<[->>>>+<<<<<[->>[ \ +-<<+>>]<<[->>+>>+<<<<]+>>>>>>>>>]<<<<<<<<[<<<<<<<<<]]>>>>>>>>>[>>>>>>>>>]<<<<<<< \ +<<[>[->>>>>>>>>+<<<<<<<<<]<<<<<<<<<<]>[->>>>>>>>>+<<<<<<<<<]<+>>>>>>>>]<<<<<<<<< \ +[>[-]<->>>>[-<<<<+>[<->-<<<<<<+>>>>>>]<[->+<]>>>>]<<<[->>>+<<<]<+<<<<<<<<<]>>>>> \ +>>>>[>+>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>->>>>>[-<<<<<+>>>>>]<<<<<[->>>>>+ \ +<<<<<<[->>>[-<<<+>>>]<<<[->>>+>+<<<<]+>>>>>>>>>]<<<<<<<<[<<<<<<<<<]]>>>>>>>>>[>> \ +>>>>>>>]<<<<<<<<<[>>[->>>>>>>>>+<<<<<<<<<]<<<<<<<<<<<]>>[->>>>>>>>>+<<<<<<<<<]<< \ ++>>>>>>>>]<<<<<<<<<[>[-]<->>>>[-<<<<+>[<->-<<<<<<+>>>>>>]<[->+<]>>>>]<<<[->>>+<< \ +<]<+<<<<<<<<<]>>>>>>>>>[>>>>[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>> \ +>>>>>>>>>>>>>>>>>>>>>>>]>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>+++++++++++++++[[>>>> \ +>>>>>]<<<<<<<<<-<<<<<<<<<[<<<<<<<<<]>>>>>>>>>-]+>>>>>>>>>>>>>>>>>>>>>+<<<[<<<<<< \ +<<<]>>>>>>>>>[>>>[-<<<->>>]+<<<[->>>->[-<<<<+>>>>]<<<<[->>>>+<<<<<<<<<<<<<[<<<<< \ +<<<<]>>>>[-]+>>>>>[>>>>>>>>>]>+<]]+>>>>[-<<<<->>>>]+<<<<[->>>>-<[-<<<+>>>]<<<[-> \ +>>+<<<<<<<<<<<<[<<<<<<<<<]>>>[-]+>>>>>>[>>>>>>>>>]>[-]+<]]+>[-<[>>>>>>>>>]<<<<<< \ +<<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]<<<<<<<[->+>>>-<<<<]>>>>>>>>>+++++++++++++++++++ \ ++++++++>>[-<<<<+>>>>]<<<<[->>>>+<<[-]<<]>>[<<<<<<<+<[-<+>>>>+<<[-]]>[-<<[->+>>>- \ +<<<<]>>>]>>>>>>>>>>>>>[>>[-]>[-]>[-]>>>>>]<<<<<<<<<[<<<<<<<<<]>>>[-]>>>>>>[>>>>> \ +[-<<<<+>>>>]<<<<[->>>>+<<<+<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>>[-<<<<<<<< \ +<+>>>>>>>>>]>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>+++++++++++++++[[>>>>>>>>>]+>[- \ +]>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>-]+[>+>>>>>>>>]<<< \ +<<<<<<[<<<<<<<<<]>>>>>>>>>[>->>>>>[-<<<<<+>>>>>]<<<<<[->>>>>+<<<<<<[->>[-<<+>>]< \ +<[->>+>+<<<]+>>>>>>>>>]<<<<<<<<[<<<<<<<<<]]>>>>>>>>>[>>>>>>>>>]<<<<<<<<<[>[->>>> \ +>>>>>+<<<<<<<<<]<<<<<<<<<<]>[->>>>>>>>>+<<<<<<<<<]<+>>>>>>>>]<<<<<<<<<[>[-]<->>> \ +[-<<<+>[<->-<<<<<<<+>>>>>>>]<[->+<]>>>]<<[->>+<<]<+<<<<<<<<<]>>>>>>>>>[>>>>>>[-< \ +<<<<+>>>>>]<<<<<[->>>>>+<<<<+<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>+>>>>>>>> \ +]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>->>>>>[-<<<<<+>>>>>]<<<<<[->>>>>+<<<<<<[->>[-<<+ \ +>>]<<[->>+>>+<<<<]+>>>>>>>>>]<<<<<<<<[<<<<<<<<<]]>>>>>>>>>[>>>>>>>>>]<<<<<<<<<[> \ +[->>>>>>>>>+<<<<<<<<<]<<<<<<<<<<]>[->>>>>>>>>+<<<<<<<<<]<+>>>>>>>>]<<<<<<<<<[>[- \ +]<->>>>[-<<<<+>[<->-<<<<<<+>>>>>>]<[->+<]>>>>]<<<[->>>+<<<]<+<<<<<<<<<]>>>>>>>>> \ +[>>>>[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> \ +]>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>>>[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<+> \ +>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>++++++++ \ ++++++++[[>>>>>>>>>]<<<<<<<<<-<<<<<<<<<[<<<<<<<<<]>>>>>>>>>-]+[>>>>>>>>[-<<<<<<<+ \ +>>>>>>>]<<<<<<<[->>>>>>>+<<<<<<+<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>>>>>>[ \ +-]>>>]<<<<<<<<<[<<<<<<<<<]>>>>+>[-<-<<<<+>>>>>]>[-<<<<<<[->>>>>+<++<<<<]>>>>>[-< \ +<<<<+>>>>>]<->+>]<[->+<]<<<<<[->>>>>+<<<<<]>>>>>>[-]<<<<<<+>>>>[-<<<<->>>>]+<<<< \ +[->>>>->>>>>[>>[-<<->>]+<<[->>->[-<<<+>>>]<<<[->>>+<<<<<<<<<<<<[<<<<<<<<<]>>>[-] \ ++>>>>>>[>>>>>>>>>]>+<]]+>>>[-<<<->>>]+<<<[->>>-<[-<<+>>]<<[->>+<<<<<<<<<<<[<<<<< \ +<<<<]>>>>[-]+>>>>>[>>>>>>>>>]>[-]+<]]+>[-<[>>>>>>>>>]<<<<<<<<]>>>>>>>>]<<<<<<<<< \ +[<<<<<<<<<]>>>>[-<<<<+>>>>]<<<<[->>>>+>>>>>[>+>>[-<<->>]<<[->>+<<]>>>>>>>>]<<<<< \ +<<<+<[>[->>>>>+<<<<[->>>>-<<<<<<<<<<<<<<+>>>>>>>>>>>[->>>+<<<]<]>[->>>-<<<<<<<<< \ +<<<<<+>>>>>>>>>>>]<<]>[->>>>+<<<[->>>-<<<<<<<<<<<<<<+>>>>>>>>>>>]<]>[->>>+<<<]<< \ +<<<<<<<<<<]>>>>[-]<<<<]>>>[-<<<+>>>]<<<[->>>+>>>>>>[>+>[-<->]<[->+<]>>>>>>>>]<<< \ +<<<<<+<[>[->>>>>+<<<[->>>-<<<<<<<<<<<<<<+>>>>>>>>>>[->>>>+<<<<]>]<[->>>>-<<<<<<< \ +<<<<<<<+>>>>>>>>>>]<]>>[->>>+<<<<[->>>>-<<<<<<<<<<<<<<+>>>>>>>>>>]>]<[->>>>+<<<< \ +]<<<<<<<<<<<]>>>>>>+<<<<<<]]>>>>[-<<<<+>>>>]<<<<[->>>>+>>>>>[>>>>>>>>>]<<<<<<<<< \ +[>[->>>>>+<<<<[->>>>-<<<<<<<<<<<<<<+>>>>>>>>>>>[->>>+<<<]<]>[->>>-<<<<<<<<<<<<<< \ ++>>>>>>>>>>>]<<]>[->>>>+<<<[->>>-<<<<<<<<<<<<<<+>>>>>>>>>>>]<]>[->>>+<<<]<<<<<<< \ +<<<<<]]>[-]>>[-]>[-]>>>>>[>>[-]>[-]>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>>>>>[-< \ +<<<+>>>>]<<<<[->>>>+<<<+<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>+++++++++++++++[ \ +[>>>>>>>>>]+>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>-]+ \ +[>+>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>->>>>[-<<<<+>>>>]<<<<[->>>>+<<<<<[->> \ +[-<<+>>]<<[->>+>+<<<]+>>>>>>>>>]<<<<<<<<[<<<<<<<<<]]>>>>>>>>>[>>>>>>>>>]<<<<<<<< \ +<[>[->>>>>>>>>+<<<<<<<<<]<<<<<<<<<<]>[->>>>>>>>>+<<<<<<<<<]<+>>>>>>>>]<<<<<<<<<[ \ +>[-]<->>>[-<<<+>[<->-<<<<<<<+>>>>>>>]<[->+<]>>>]<<[->>+<<]<+<<<<<<<<<]>>>>>>>>>[ \ +>>>[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>]> \ +>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>[-]>>>>+++++++++++++++[[>>>>>>>>>]<<<<<<<<<-<<<<< \ +<<<<[<<<<<<<<<]>>>>>>>>>-]+[>>>[-<<<->>>]+<<<[->>>->[-<<<<+>>>>]<<<<[->>>>+<<<<< \ +<<<<<<<<[<<<<<<<<<]>>>>[-]+>>>>>[>>>>>>>>>]>+<]]+>>>>[-<<<<->>>>]+<<<<[->>>>-<[- \ +<<<+>>>]<<<[->>>+<<<<<<<<<<<<[<<<<<<<<<]>>>[-]+>>>>>>[>>>>>>>>>]>[-]+<]]+>[-<[>> \ +>>>>>>>]<<<<<<<<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>[-<<<+>>>]<<<[->>>+>>>>>>[>+>>> \ +[-<<<->>>]<<<[->>>+<<<]>>>>>>>>]<<<<<<<<+<[>[->+>[-<-<<<<<<<<<<+>>>>>>>>>>>>[-<< \ ++>>]<]>[-<<-<<<<<<<<<<+>>>>>>>>>>>>]<<<]>>[-<+>>[-<<-<<<<<<<<<<+>>>>>>>>>>>>]<]> \ +[-<<+>>]<<<<<<<<<<<<<]]>>>>[-<<<<+>>>>]<<<<[->>>>+>>>>>[>+>>[-<<->>]<<[->>+<<]>> \ +>>>>>>]<<<<<<<<+<[>[->+>>[-<<-<<<<<<<<<<+>>>>>>>>>>>[-<+>]>]<[-<-<<<<<<<<<<+>>>> \ +>>>>>>>]<<]>>>[-<<+>[-<-<<<<<<<<<<+>>>>>>>>>>>]>]<[-<+>]<<<<<<<<<<<<]>>>>>+<<<<< \ +]>>>>>>>>>[>>>[-]>[-]>[-]>>>>]<<<<<<<<<[<<<<<<<<<]>>>[-]>[-]>>>>>[>>>>>>>[-<<<<< \ +<+>>>>>>]<<<<<<[->>>>>>+<<<<+<<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>+>[-<-<<<<+>>>> \ +>]>>[-<<<<<<<[->>>>>+<++<<<<]>>>>>[-<<<<<+>>>>>]<->+>>]<<[->>+<<]<<<<<[->>>>>+<< \ +<<<]+>>>>[-<<<<->>>>]+<<<<[->>>>->>>>>[>>>[-<<<->>>]+<<<[->>>-<[-<<+>>]<<[->>+<< \ +<<<<<<<<<[<<<<<<<<<]>>>>[-]+>>>>>[>>>>>>>>>]>+<]]+>>[-<<->>]+<<[->>->[-<<<+>>>]< \ +<<[->>>+<<<<<<<<<<<<[<<<<<<<<<]>>>[-]+>>>>>>[>>>>>>>>>]>[-]+<]]+>[-<[>>>>>>>>>]< \ +<<<<<<<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>[-<<<+>>>]<<<[->>>+>>>>>>[>+>[-<->]<[->+ \ +<]>>>>>>>>]<<<<<<<<+<[>[->>>>+<<[->>-<<<<<<<<<<<<<+>>>>>>>>>>[->>>+<<<]>]<[->>>- \ +<<<<<<<<<<<<<+>>>>>>>>>>]<]>>[->>+<<<[->>>-<<<<<<<<<<<<<+>>>>>>>>>>]>]<[->>>+<<< \ +]<<<<<<<<<<<]>>>>>[-]>>[-<<<<<<<+>>>>>>>]<<<<<<<[->>>>>>>+<<+<<<<<]]>>>>[-<<<<+> \ +>>>]<<<<[->>>>+>>>>>[>+>>[-<<->>]<<[->>+<<]>>>>>>>>]<<<<<<<<+<[>[->>>>+<<<[->>>- \ +<<<<<<<<<<<<<+>>>>>>>>>>>[->>+<<]<]>[->>-<<<<<<<<<<<<<+>>>>>>>>>>>]<<]>[->>>+<<[ \ +->>-<<<<<<<<<<<<<+>>>>>>>>>>>]<]>[->>+<<]<<<<<<<<<<<<]]>>>>[-]<<<<]>>>>[-<<<<+>> \ +>>]<<<<[->>>>+>[-]>>[-<<<<<<<+>>>>>>>]<<<<<<<[->>>>>>>+<<+<<<<<]>>>>>>>>>[>>>>>> \ +>>>]<<<<<<<<<[>[->>>>+<<<[->>>-<<<<<<<<<<<<<+>>>>>>>>>>>[->>+<<]<]>[->>-<<<<<<<< \ +<<<<<+>>>>>>>>>>>]<<]>[->>>+<<[->>-<<<<<<<<<<<<<+>>>>>>>>>>>]<]>[->>+<<]<<<<<<<< \ +<<<<]]>>>>>>>>>[>>[-]>[-]>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>[-]>[-]>>>>>[>>>>>[-<<<<+ \ +>>>>]<<<<[->>>>+<<<+<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>>>>>>[-<<<<<+>>>>> \ +]<<<<<[->>>>>+<<<+<<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>+++++++++++++++[[>>>> \ +>>>>>]+>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]>[-]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>-]+[>+>> \ +>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>->>>>[-<<<<+>>>>]<<<<[->>>>+<<<<<[->>[-<<+ \ +>>]<<[->>+>>+<<<<]+>>>>>>>>>]<<<<<<<<[<<<<<<<<<]]>>>>>>>>>[>>>>>>>>>]<<<<<<<<<[> \ +[->>>>>>>>>+<<<<<<<<<]<<<<<<<<<<]>[->>>>>>>>>+<<<<<<<<<]<+>>>>>>>>]<<<<<<<<<[>[- \ +]<->>>>[-<<<<+>[<->-<<<<<<+>>>>>>]<[->+<]>>>>]<<<[->>>+<<<]<+<<<<<<<<<]>>>>>>>>> \ +[>+>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>->>>>>[-<<<<<+>>>>>]<<<<<[->>>>>+<<<< \ +<<[->>>[-<<<+>>>]<<<[->>>+>+<<<<]+>>>>>>>>>]<<<<<<<<[<<<<<<<<<]]>>>>>>>>>[>>>>>> \ +>>>]<<<<<<<<<[>>[->>>>>>>>>+<<<<<<<<<]<<<<<<<<<<<]>>[->>>>>>>>>+<<<<<<<<<]<<+>>> \ +>>>>>]<<<<<<<<<[>[-]<->>>>[-<<<<+>[<->-<<<<<<+>>>>>>]<[->+<]>>>>]<<<[->>>+<<<]<+ \ +<<<<<<<<<]>>>>>>>>>[>>>>[-<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>> \ +>>>>>>>>>>>>>>>>>>>]>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>+++++++++++++++[[>>>>>>>> \ +>]<<<<<<<<<-<<<<<<<<<[<<<<<<<<<]>>>>>>>>>-]+>>>>>>>>>>>>>>>>>>>>>+<<<[<<<<<<<<<] \ +>>>>>>>>>[>>>[-<<<->>>]+<<<[->>>->[-<<<<+>>>>]<<<<[->>>>+<<<<<<<<<<<<<[<<<<<<<<< \ +]>>>>[-]+>>>>>[>>>>>>>>>]>+<]]+>>>>[-<<<<->>>>]+<<<<[->>>>-<[-<<<+>>>]<<<[->>>+< \ +<<<<<<<<<<<[<<<<<<<<<]>>>[-]+>>>>>>[>>>>>>>>>]>[-]+<]]+>[-<[>>>>>>>>>]<<<<<<<<]> \ +>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>->>[-<<<<+>>>>]<<<<[->>>>+<<[-]<<]>>]<<+>>>>[-<<<< \ +->>>>]+<<<<[->>>>-<<<<<<.>>]>>>>[-<<<<<<<.>>>>>>>]<<<[-]>[-]>[-]>[-]>[-]>[-]>>>[ \ +>[-]>[-]>[-]>[-]>[-]>[-]>>>]<<<<<<<<<[<<<<<<<<<]>>>>>>>>>[>>>>>[-]>>>>]<<<<<<<<< \ +[<<<<<<<<<]>+++++++++++[-[->>>>>>>>>+<<<<<<<<<]>>>>>>>>>]>>>>+>>>>>>>>>+<<<<<<<< \ +<<<<<<[<<<<<<<<<]>>>>>>>[-<<<<<<<+>>>>>>>]<<<<<<<[->>>>>>>+[-]>>[>>>>>>>>>]<<<<< \ +<<<<[>>>>>>>[-<<<<<<+>>>>>>]<<<<<<[->>>>>>+<<<<<<<[<<<<<<<<<]>>>>>>>[-]+>>>]<<<< \ +<<<<<<]]>>>>>>>[-<<<<<<<+>>>>>>>]<<<<<<<[->>>>>>>+>>[>+>>>>[-<<<<->>>>]<<<<[->>> \ +>+<<<<]>>>>>>>>]<<+<<<<<<<[>>>>>[->>+<<]<<<<<<<<<<<<<<]>>>>>>>>>[>>>>>>>>>]<<<<< \ +<<<<[>[-]<->>>>>>>[-<<<<<<<+>[<->-<<<+>>>]<[->+<]>>>>>>>]<<<<<<[->>>>>>+<<<<<<]< \ ++<<<<<<<<<]>>>>>>>-<<<<[-]+<<<]+>>>>>>>[-<<<<<<<->>>>>>>]+<<<<<<<[->>>>>>>->>[>> \ +>>>[->>+<<]>>>>]<<<<<<<<<[>[-]<->>>>>>>[-<<<<<<<+>[<->-<<<+>>>]<[->+<]>>>>>>>]<< \ +<<<<[->>>>>>+<<<<<<]<+<<<<<<<<<]>+++++[-[->>>>>>>>>+<<<<<<<<<]>>>>>>>>>]>>>>+<<< \ +<<[<<<<<<<<<]>>>>>>>>>[>>>>>[-<<<<<->>>>>]+<<<<<[->>>>>->>[-<<<<<<<+>>>>>>>]<<<< \ +<<<[->>>>>>>+<<<<<<<<<<<<<<<<[<<<<<<<<<]>>>>[-]+>>>>>[>>>>>>>>>]>+<]]+>>>>>>>[-< \ +<<<<<<->>>>>>>]+<<<<<<<[->>>>>>>-<<[-<<<<<+>>>>>]<<<<<[->>>>>+<<<<<<<<<<<<<<[<<< \ +<<<<<<]>>>[-]+>>>>>>[>>>>>>>>>]>[-]+<]]+>[-<[>>>>>>>>>]<<<<<<<<]>>>>>>>>]<<<<<<< \ +<<[<<<<<<<<<]>>>>[-]<<<+++++[-[->>>>>>>>>+<<<<<<<<<]>>>>>>>>>]>>>>-<<<<<[<<<<<<< \ +<<]]>>>]<<<<.>>>>>>>>>>[>>>>>>[-]>>>]<<<<<<<<<[<<<<<<<<<]>++++++++++[-[->>>>>>>> \ +>+<<<<<<<<<]>>>>>>>>>]>>>>>+>>>>>>>>>+<<<<<<<<<<<<<<<[<<<<<<<<<]>>>>>>>>[-<<<<<< \ +<<+>>>>>>>>]<<<<<<<<[->>>>>>>>+[-]>[>>>>>>>>>]<<<<<<<<<[>>>>>>>>[-<<<<<<<+>>>>>> \ +>]<<<<<<<[->>>>>>>+<<<<<<<<[<<<<<<<<<]>>>>>>>>[-]+>>]<<<<<<<<<<]]>>>>>>>>[-<<<<< \ +<<<+>>>>>>>>]<<<<<<<<[->>>>>>>>+>[>+>>>>>[-<<<<<->>>>>]<<<<<[->>>>>+<<<<<]>>>>>> \ +>>]<+<<<<<<<<[>>>>>>[->>+<<]<<<<<<<<<<<<<<<]>>>>>>>>>[>>>>>>>>>]<<<<<<<<<[>[-]<- \ +>>>>>>>>[-<<<<<<<<+>[<->-<<+>>]<[->+<]>>>>>>>>]<<<<<<<[->>>>>>>+<<<<<<<]<+<<<<<< \ +<<<]>>>>>>>>-<<<<<[-]+<<<]+>>>>>>>>[-<<<<<<<<->>>>>>>>]+<<<<<<<<[->>>>>>>>->[>>> \ +>>>[->>+<<]>>>]<<<<<<<<<[>[-]<->>>>>>>>[-<<<<<<<<+>[<->-<<+>>]<[->+<]>>>>>>>>]<< \ +<<<<<[->>>>>>>+<<<<<<<]<+<<<<<<<<<]>+++++[-[->>>>>>>>>+<<<<<<<<<]>>>>>>>>>]>>>>> \ ++>>>>>>>>>>>>>>>>>>>>>>>>>>>+<<<<<<[<<<<<<<<<]>>>>>>>>>[>>>>>>[-<<<<<<->>>>>>]+< \ +<<<<<[->>>>>>->>[-<<<<<<<<+>>>>>>>>]<<<<<<<<[->>>>>>>>+<<<<<<<<<<<<<<<<<[<<<<<<< \ +<<]>>>>[-]+>>>>>[>>>>>>>>>]>+<]]+>>>>>>>>[-<<<<<<<<->>>>>>>>]+<<<<<<<<[->>>>>>>> \ +-<<[-<<<<<<+>>>>>>]<<<<<<[->>>>>>+<<<<<<<<<<<<<<<[<<<<<<<<<]>>>[-]+>>>>>>[>>>>>> \ +>>>]>[-]+<]]+>[-<[>>>>>>>>>]<<<<<<<<]>>>>>>>>]<<<<<<<<<[<<<<<<<<<]>>>>[-]<<<++++ \ ++[-[->>>>>>>>>+<<<<<<<<<]>>>>>>>>>]>>>>>->>>>>>>>>>>>>>>>>>>>>>>>>>>-<<<<<<[<<<< \ +<<<<<]]>>>]" diff --git a/am-kernels/kernels/demo/src/cmatrix/LICENSE b/am-kernels/kernels/demo/src/cmatrix/LICENSE new file mode 100644 index 0000000..358821f --- /dev/null +++ b/am-kernels/kernels/demo/src/cmatrix/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2018 Fontaine Hugo a.k.a "Usiten" + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/am-kernels/kernels/demo/src/cmatrix/cmatrix.c b/am-kernels/kernels/demo/src/cmatrix/cmatrix.c new file mode 100644 index 0000000..5f22fef --- /dev/null +++ b/am-kernels/kernels/demo/src/cmatrix/cmatrix.c @@ -0,0 +1,72 @@ +/************************************************************************ + + The Matrix Rain Screen Saver + + This code is converted from QBASIC to C. + + QBasic Code from +http://codegolf.stackexchange.com/questions/17285/make-the-matrix-digital-rain-using-the-shortest-amount-of-code + + ************************************************************************/ + +#include +#include +#include + +#define W 80 +#define H 24 + +static int t[W]; + +static void sub_d(int p, int s, int x, int y) { + uint8_t r = (p % 16) * 16; + uint8_t g = 180 - p; + if (r < 10) { +// set_color(ANSI_COLOR_RESET); + } + else { + if (g > 170) { + set_color(ANSI_COLOR_WHITE); + } + else if (g < 170) { + set_color(ANSI_COLOR_GREEN); + } + } + + if ((y >= 0) && (y < H) && (x < W)) { + char c = (r < 10 ? ' ' : 33 + (x * y) % 94); + print_char(c, y, x); + //)vt_draw_char_at(y, x, c); + } +} + +void cmatrix() { + int i, x, y, k; + screen_clear(); + + x = rand(); + for (i = 0; i < W; i++) { + t[i] = - rand() % 50; + } + + sub_d(1,1,10,10); + + while (1) { + for (k = 1; k < W; k++) { + i = rand() % (W-1); + if (t[i] > 28)t[i] = 0; + t[i] = t[i] + 1; + y = t[i]; + sub_d( 0 , 0, i, y - 6); + sub_d( 2 + x, 0, i, y - 5); + sub_d( 2 + x, 0, i, y - 4); + sub_d( 10 + x, 0, i, y - 3); + sub_d( 10 + x, 0, i, y - 2); + sub_d( 11 + x, 0, i, y - 1); + sub_d( 0 , 2 + x, i, y); + } + + screen_refresh(); + usleep(100000); + } +} diff --git a/am-kernels/kernels/demo/src/donut/donut.c b/am-kernels/kernels/demo/src/donut/donut.c new file mode 100644 index 0000000..0326d62 --- /dev/null +++ b/am-kernels/kernels/demo/src/donut/donut.c @@ -0,0 +1,82 @@ +/** + * Original author: + * https://twitter.com/a1k0n + * https://www.a1k0n.net/2021/01/13/optimizing-donut.html + * + * Change Logs: + * Date Author Notes + * 2006-09-15 Andy Sloane First version + * 2011-07-20 Andy Sloane Second version + * 2021-01-13 Andy Sloane Third version + * 2021-03-25 Meco Man Port to RT-Thread RTOS + */ + +#include +#include +#include +#include + +#define R(mul,shift,x,y) \ + _=x; \ + x -= mul*y>>shift; \ + y += mul*_>>shift; \ + _ = (3145728-x*x-y*y)>>11; \ + x = x*_>>10; \ + y = y*_>>10; + +static char b[1760]; +static signed char z[1760]; + +void donut(void) { + int sA = 1024, cA = 0, sB = 1024, cB = 0, _; + + while(1) { + memset(b, 32, 1760); // text buffer + memset(z, 127, 1760); // z buffer + int sj = 0, cj = 1024; + for (int j = 0; j < 90; j++) { + int si = 0, ci = 1024; // sine and cosine of angle i + for (int i = 0; i < 324; i++) { + int R1 = 1, R2 = 2048, K2 = 5120*1024; + + int x0 = R1*cj + R2, + x1 = ci*x0 >> 10, + x2 = cA*sj >> 10, + x3 = si*x0 >> 10, + x4 = R1*x2 - (sA*x3 >> 10), + x5 = sA*sj >> 10, + x6 = K2 + R1*1024*x5 + cA*x3, + x7 = cj*si >> 10, + x = 25 + 30*(cB*x1 - sB*x4)/x6, + y = 12 + 15*(cB*x4 + sB*x1)/x6, + N = (((-cA*x7 - cB*((-sA*x7>>10) + x2) - ci*(cj*sB >> 10)) >> 10) - x5) >> 7; + + int o = x + 80 * y; + signed char zz = (x6-K2)>>15; + if (22 > y && y > 0 && x > 0 && 80 > x && zz < z[o]) { + z[o] = zz; + b[o] = ".,-~:;=!*#$@"[N > 0 ? N : 0]; + } + R(5, 8, ci, si) // rotate i + } + R(9, 7, cj, sj) // rotate j + } + R(5, 7, cA, sA); + R(5, 8, cB, sB); + + screen_clear(); + int y = 0, x = 0; + for (int k = 0; 1761 > k; k++) { + if (k % 80) { + if (x < 50) print_char(b[k], y, x); + x ++; + } else { + y ++; + x = 1; + } + } + + screen_refresh(); + usleep(100000); + } +} diff --git a/am-kernels/kernels/demo/src/galton/galton.c b/am-kernels/kernels/demo/src/galton/galton.c new file mode 100644 index 0000000..3522a89 --- /dev/null +++ b/am-kernels/kernels/demo/src/galton/galton.c @@ -0,0 +1,96 @@ +/* from http://rosettacode.org/wiki/Galton_box_animation#C */ + +#include +#include +#include +#include + +#define BALLS 1024 +#define N 8 +#define W (N * 2 + 1) +#define H_MAX 50 +#define H_MIN 30 +static int h = 0; +static int *x = NULL, *y = NULL, cnt = 0; +static char *b = NULL; + +#define B(y, x) b[(y)*W + x] +#define C(y, x) ' ' == b[(y)*W + x] +#define V(i) B(y[i], x[i]) +static int rnd(int a) { return rand() % a; } + +static void show_board() { + int i, j; + for (i = 0; i < h; i++) + for (j = 0; j < W; j++) { + if (B(i, j) == '*') { + set_color(C(i - 1, j) ? ANSI_COLOR_GREEN : ANSI_COLOR_RED); + print_char(B(i, j), i, 2 * j); + set_color(ANSI_COLOR_RESET); + } else { + print_char(B(i, j), i, 2 * j); + } + print_char(' ', i, 2 * j + 1); + } + screen_refresh(); +} + +static void init() { + int i, j; + screen_clear(); + b = malloc(W * h); + memset(b, ' ', W * h); + + x = malloc(sizeof(int) * BALLS * 2); + y = x + BALLS; + + for (i = 0; i < N; i++) + for (j = -i; j <= i; j += 2) + B(2 * i+2, j + W/2) = '*'; +} + +static void move(int idx) { + int xx = x[idx], yy = y[idx], c, kill = 0, sl = 3, o = 0; + + if (yy < 0) return; + if (yy == h - 1) { y[idx] = -1; return; } + + switch(c = B(yy + 1, xx)) { + case ' ': yy++; break; + case '*': sl = 1; + default: if (xx < W - 1 && C(yy, xx + 1) && C(yy + 1, xx + 1)) + if (!rnd(sl++)) o = 1; + if (xx && C(yy, xx - 1) && C(yy + 1, xx - 1)) + if (!rnd(sl++)) o = -1; + if (!o) kill = 1; + xx += o; + } + + c = V(idx); V(idx) = ' '; + idx[y] = yy, idx[x] = xx; + B(yy, xx) = c; + if (kill) idx[y] = -1; +} + +static int run(void) { + static int step = 0; + int i; + for (i = 0; i < cnt; i++) move(i); + if (2 == ++step && cnt < BALLS) { + step = 0; + x[cnt] = W/2; + y[cnt] = 0; + if (V(cnt) != ' ') return 0; + V(cnt) = rnd(80) + 43; + cnt++; + } + return 1; +} + +void galton() { + h = screen_tile_height() - 2; + if (h > H_MAX) h = H_MAX; + if (h < H_MIN) h = H_MIN; + init(); + do { show_board(), usleep(6000); } while (run()); +} diff --git a/am-kernels/kernels/demo/src/hanoi/hanoi.c b/am-kernels/kernels/demo/src/hanoi/hanoi.c new file mode 100644 index 0000000..b0ec23e --- /dev/null +++ b/am-kernels/kernels/demo/src/hanoi/hanoi.c @@ -0,0 +1,60 @@ +/* from http://rosettacode.org/wiki/Towers_of_Hanoi#C */ + +#include +#include +#include +#include + +#define H 7 + +typedef struct { int *x, n; } tower; +static tower *new_tower(int cap) { + int size = sizeof(tower) + sizeof(int) * cap; + tower *t = malloc(size); + memset(t, 0, size); + t->x = (int*)(t + 1); + return t; +} + +static tower *t[3]; + +static void text(int y, int i, int d, const char *s) { + int yy = H - y + 1; + int xx = (H + 1) * (2 * i + 1) - d; + while (d--) { + for (const char *p = s; *p; p ++) { + print_char(*p, yy, xx ++); + } + } +} + +static void add_disk(int i, int d) { + t[i]->x[t[i]->n++] = d; + text(t[i]->n, i, d, "=="); + screen_refresh(); + usleep(100000); +} + +int remove_disk(int i) { + int d = t[i]->x[--t[i]->n]; + text(t[i]->n + 1, i, d, " "); + return d; +} + +void move(int n, int from, int to, int via) { + if (!n) return; + + move(n - 1, from, via, to); + add_disk(to, remove_disk(from)); + move(n - 1, via, to, from); +} + +void hanoi() { + screen_clear(); + + int c; + for (c = 0; c < 3; c++) t[c] = new_tower(H); + for (c = H; c; c--) add_disk(0, c); + + move(H, 0, 2, 1); +} diff --git a/am-kernels/kernels/demo/src/life/life.c b/am-kernels/kernels/demo/src/life/life.c new file mode 100644 index 0000000..b1ecc5b --- /dev/null +++ b/am-kernels/kernels/demo/src/life/life.c @@ -0,0 +1,56 @@ +/* adapted from http://rosettacode.org/wiki/Conway%27s_Game_of_Life */ + +#include +#include +#include + +static int w = 40, h = 25; +static unsigned *new_array = NULL; +static unsigned *univ_array = NULL; + +void show(void *u) { + int x,y; + int (*univ)[w] = u; + screen_clear(); + for (y=0;y +#include +#include + +void ant(); +void galton(); +void hanoi(); +void game_of_life(); +void aclock(); +void cmatrix(); +void donut(); +void bf(); + +int main(const char *args) { + ioe_init(); + + switch (args[0]) { + case '1': ant(); break; + case '2': galton(); break; + case '3': hanoi(); break; + case '4': game_of_life(); break; + case '5': aclock(); break; + case '6': cmatrix(); break; + case '7': donut(); break; + case '8': bf(); break; + default: + printf("Usage: make run mainargs=*\n"); + printf(" 1: ant\n"); + printf(" 2: galton\n"); + printf(" 3: hanoi\n"); + printf(" 4: game of life\n"); + printf(" 5: aclock\n"); + printf(" 6: cmatrix\n"); + printf(" 7: donut\n"); + printf(" 8: bf\n"); + } + + printf("Press Q to Exit\n"); + while (1) { + AM_INPUT_KEYBRD_T ev = io_read(AM_INPUT_KEYBRD); + if (ev.keydown && ev.keycode == AM_KEY_Q) break; + } + return 0; +} diff --git a/am-kernels/kernels/hello/Makefile b/am-kernels/kernels/hello/Makefile new file mode 100644 index 0000000..db9464c --- /dev/null +++ b/am-kernels/kernels/hello/Makefile @@ -0,0 +1,3 @@ +NAME = hello +SRCS = hello.c +include $(AM_HOME)/Makefile diff --git a/am-kernels/kernels/hello/hello.c b/am-kernels/kernels/hello/hello.c new file mode 100644 index 0000000..0515155 --- /dev/null +++ b/am-kernels/kernels/hello/hello.c @@ -0,0 +1,13 @@ +#include +#include + +int main(const char *args) { + const char *fmt = + "Hello, AbstractMachine!\n" + "mainargs = '%'.\n"; + + for (const char *p = fmt; *p; p++) { + (*p == '%') ? putstr(args) : putch(*p); + } + return 0; +} diff --git a/am-kernels/kernels/litenes/Makefile b/am-kernels/kernels/litenes/Makefile new file mode 100644 index 0000000..831e8b7 --- /dev/null +++ b/am-kernels/kernels/litenes/Makefile @@ -0,0 +1,3 @@ +NAME = litenes +SRCS = $(shell find src/ -name "*.c") +include $(AM_HOME)/Makefile diff --git a/am-kernels/kernels/litenes/README b/am-kernels/kernels/litenes/README new file mode 100644 index 0000000..cf45a4d --- /dev/null +++ b/am-kernels/kernels/litenes/README @@ -0,0 +1,2 @@ +This is the AbstractMachine port of mynes (https://github.com/yaglo/mynes). +Emulates "Super Mario Bros" on NES (CPU, PPU, and peripherals). diff --git a/am-kernels/kernels/litenes/src/common.c b/am-kernels/kernels/litenes/src/common.c new file mode 100644 index 0000000..2fe48ee --- /dev/null +++ b/am-kernels/kernels/litenes/src/common.c @@ -0,0 +1,16 @@ +#include "common.h" + +bool common_bit_set(long long value, byte position) { return value & (1L << position); } + +// I could do this through non-void methods with returns in one copy, +// but this variant is slightly faster, and needs less typing in client code +#define M_common(SUFFIX, TYPE) \ + void common_set_bit##SUFFIX(TYPE *variable, byte position) { *variable |= 1L << position; } \ + void common_unset_bit##SUFFIX(TYPE *variable, byte position) { *variable &= ~(1L << position); } \ + void common_toggle_bit##SUFFIX(TYPE *variable, byte position) { *variable ^= 1L << position; } \ + void common_modify_bit##SUFFIX(TYPE *variable, byte position, bool set) \ + { set ? common_set_bit##SUFFIX(variable, position) : common_unset_bit##SUFFIX(variable, position); } + +M_common(b, byte) +M_common(w, word) +M_common(d, dword) diff --git a/am-kernels/kernels/litenes/src/common.h b/am-kernels/kernels/litenes/src/common.h new file mode 100644 index 0000000..9599dd5 --- /dev/null +++ b/am-kernels/kernels/litenes/src/common.h @@ -0,0 +1,33 @@ +#ifndef COMMON_H +#define COMMON_H + +#include +#include +#include + +typedef uint8_t byte; +typedef uint16_t word; +typedef uint32_t dword; + +// Binary Operations +bool common_bit_set(long long value, byte position); + +// Byte Bit Operations +void common_set_bitb(byte *variable, byte position); +void common_unset_bitb(byte *variable, byte position); +void common_toggle_bitb(byte *variable, byte position); +void common_modify_bitb(byte *variable, byte position, bool set); + +// Word Bit Operations +void common_set_bitw(word *variable, byte position); +void common_unset_bitw(word *variable, byte position); +void common_toggle_bitw(word *variable, byte position); +void common_modify_bitw(word *variable, byte position, bool set); + +// Double Word Bit Operations +void common_set_bitd(dword *variable, byte position); +void common_unset_bitd(dword *variable, byte position); +void common_toggle_bitd(dword *variable, byte position); +void common_modify_bitd(dword *variable, byte position, bool set); + +#endif diff --git a/am-kernels/kernels/litenes/src/cpu-addressing.c b/am-kernels/kernels/litenes/src/cpu-addressing.c new file mode 100644 index 0000000..858bc94 --- /dev/null +++ b/am-kernels/kernels/litenes/src/cpu-addressing.c @@ -0,0 +1,101 @@ +#include "cpu.h" +#include "cpu-internal.h" +#include "memory.h" + +// CPU Addressing Modes + +void cpu_address_implied() { } + +void cpu_address_immediate() { + op_value = memory_readb(cpu.PC); + cpu.PC++; +} + +void cpu_address_zero_page() { + op_address = memory_readb(cpu.PC); + op_value = CPU_RAM[op_address]; + cpu.PC++; +} + +void cpu_address_zero_page_x() { + op_address = (memory_readb(cpu.PC) + cpu.X) & 0xFF; + op_value = CPU_RAM[op_address]; + cpu.PC++; +} + +void cpu_address_zero_page_y() { + op_address = (memory_readb(cpu.PC) + cpu.Y) & 0xFF; + op_value = CPU_RAM[op_address]; + cpu.PC++; +} + +void cpu_address_absolute() { + op_address = memory_readw(cpu.PC); + op_value = memory_readb(op_address); + cpu.PC += 2; +} + +void cpu_address_absolute_x() { + op_address = memory_readw(cpu.PC) + cpu.X; + op_value = memory_readb(op_address); + cpu.PC += 2; + + if ((op_address >> 8) != (cpu.PC >> 8)) { + op_cycles++; + } +} + +void cpu_address_absolute_y() { + op_address = (memory_readw(cpu.PC) + cpu.Y) & 0xFFFF; + op_value = memory_readb(op_address); + cpu.PC += 2; + + if ((op_address >> 8) != (cpu.PC >> 8)) { + op_cycles++; + } +} + +void cpu_address_relative() { + op_address = memory_readb(cpu.PC); + cpu.PC++; + if (op_address & 0x80) + op_address -= 0x100; + op_address += cpu.PC; + + if ((op_address >> 8) != (cpu.PC >> 8)) { + op_cycles++; + } +} + +void cpu_address_indirect() { + word arg_addr = memory_readw(cpu.PC); + + // The famous 6502 bug when instead of reading from $C0FF/$C100 it reads from $C0FF/$C000 + if ((arg_addr & 0xFF) == 0xFF) { + // Buggy code + op_address = (memory_readb(arg_addr & 0xFF00) << 8) + memory_readb(arg_addr); + } + else { + // Normal code + op_address = memory_readw(arg_addr); + } + cpu.PC += 2; +} + +void cpu_address_indirect_x() { + byte arg_addr = memory_readb(cpu.PC); + op_address = (memory_readb((arg_addr + cpu.X + 1) & 0xFF) << 8) | memory_readb((arg_addr + cpu.X) & 0xFF); + op_value = memory_readb(op_address); + cpu.PC++; +} + +void cpu_address_indirect_y() { + byte arg_addr = memory_readb(cpu.PC); + op_address = (((memory_readb((arg_addr + 1) & 0xFF) << 8) | memory_readb(arg_addr)) + cpu.Y) & 0xFFFF; + op_value = memory_readb(op_address); + cpu.PC++; + + if ((op_address >> 8) != (cpu.PC >> 8)) { + op_cycles++; + } +} diff --git a/am-kernels/kernels/litenes/src/cpu-internal.h b/am-kernels/kernels/litenes/src/cpu-internal.h new file mode 100644 index 0000000..6bfc6ee --- /dev/null +++ b/am-kernels/kernels/litenes/src/cpu-internal.h @@ -0,0 +1,63 @@ +#ifndef CPU_INTERNAL_H +#define CPU_INTERNAL_H + +#include "common.h" + +typedef enum { + carry_flag = 0x01, + zero_flag = 0x02, + interrupt_flag = 0x04, + decimal_flag = 0x08, + break_flag = 0x10, + unused_flag = 0x20, + overflow_flag = 0x40, + negative_flag = 0x80 +} cpu_p_flag; + +typedef enum { + carry_bp = 0, + zero_bp = 1, + interrupt_bp = 2, + decimal_bp = 3, + break_bp = 4, + unused_bp = 5, + overflow_bp = 6, + negative_bp = 7 +} cpu_p_bp; + +typedef struct { + word PC; // Program Counter, + byte SP; // Stack Pointer, + byte A, X, Y; // Registers + byte P; // Flag Register +} CPU_STATE; + +extern CPU_STATE cpu; + +extern byte CPU_RAM[0x8000]; +extern int op_value, op_address; // Arguments for current instruction +extern int op_cycles; // Additional instruction cycles used (e.g. when paging occurs) + +byte cpu_ram_read(word address); +void cpu_ram_write(word address, byte data); + +// Interrupt Addresses +word cpu_nmi_interrupt_address(); +word cpu_reset_interrupt_address(); +word cpu_irq_interrupt_address(); + +// CPU Adressing Modes +void cpu_address_implied(); +void cpu_address_immediate(); +void cpu_address_zero_page(); +void cpu_address_zero_page_x(); +void cpu_address_zero_page_y(); +void cpu_address_absolute(); +void cpu_address_absolute_x(); +void cpu_address_absolute_y(); +void cpu_address_relative(); +void cpu_address_indirect(); +void cpu_address_indirect_x(); +void cpu_address_indirect_y(); + +#endif diff --git a/am-kernels/kernels/litenes/src/cpu.c b/am-kernels/kernels/litenes/src/cpu.c new file mode 100644 index 0000000..73fba76 --- /dev/null +++ b/am-kernels/kernels/litenes/src/cpu.c @@ -0,0 +1,606 @@ +#include "cpu.h" +#include "cpu-internal.h" +#include "memory.h" +#include "ppu.h" +#include "common.h" + +CPU_STATE cpu; + +// CPU Memory + +byte CPU_RAM[0x8000]; + +byte cpu_ram_read(word address) { + return CPU_RAM[address & 0x7FF]; +} + +void cpu_ram_write(word address, byte data) { + CPU_RAM[address & 0x7FF] = data; +} + +static byte op_code; // Current instruction code +int op_value, op_address; // Arguments for current instruction +int op_cycles; // Additional instruction cycles used (e.g. when paging occurs) +static unsigned long long cpu_cycles; // Total CPU Cycles Since Power Up (wraps) + +static void (*cpu_op_address_mode[256])(); // Array of address modes +static void (*cpu_op_handler[256])(); // Array of instruction function pointers +static bool cpu_op_in_base_instruction_set[256]; // true if instruction is in base 6502 instruction set +static char *cpu_op_name[256]; // Instruction names +static int cpu_op_cycles[256]; // CPU cycles used by instructions + +static const byte cpu_zn_flag_table[256] = { + zero_flag,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, + negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag,negative_flag, +}; + +// Interrupt Addresses + +word cpu_nmi_interrupt_address() { return memory_readw(0xFFFA); } +word cpu_reset_interrupt_address() { return memory_readw(0xFFFC); } +word cpu_irq_interrupt_address() { return memory_readw(0xFFFE); } + +// Stack Routines + +void cpu_stack_pushb(byte data) { memory_writeb(0x100 + cpu.SP--, data); } +void cpu_stack_pushw(word data) { memory_writew(0xFF + cpu.SP, data); cpu.SP -= 2; } +byte cpu_stack_popb() { return memory_readb(0x100 + ++cpu.SP); } +word cpu_stack_popw() { cpu.SP += 2; return memory_readw(0xFF + cpu.SP); } + +// CPU Instructions + +void ____FE____() { /* Instruction for future Extension */ } + +#define cpu_flag_set(flag) common_bit_set(cpu.P, flag) +#define cpu_modify_flag(flag, value) common_modify_bitb(&cpu.P, flag, value) +#define cpu_set_flag(flag) common_set_bitb(&cpu.P, flag) +#define cpu_unset_flag(flag) common_unset_bitb(&cpu.P, flag) + +#define cpu_update_zn_flags(value) cpu.P = (cpu.P & ~(zero_flag | negative_flag)) | cpu_zn_flag_table[value] + +#define cpu_branch(flag) if (flag) cpu.PC = op_address; +#define cpu_compare(reg) \ + int result = reg - op_value; \ + cpu_modify_flag(carry_bp, result >= 0); \ + cpu_modify_flag(zero_bp, result == 0); \ + cpu_modify_flag(negative_bp, (result >> 7) & 1); + + +// CPU Instructions + +// NOP + +void cpu_op_nop() {} + +// Addition + +void cpu_op_adc() { + int result = cpu.A + op_value + (cpu_flag_set(carry_bp) ? 1 : 0); + cpu_modify_flag(carry_bp, !!(result & 0x100)); + cpu_modify_flag(overflow_bp, !!(~(cpu.A ^ op_value) & (cpu.A ^ result) & 0x80)); + cpu.A = result & 0xFF; + cpu_update_zn_flags(cpu.A); +} + +// Subtraction + +void cpu_op_sbc() { + int result = cpu.A - op_value - (cpu_flag_set(carry_bp) ? 0 : 1); + cpu_modify_flag(carry_bp, !(result & 0x100)); + cpu_modify_flag(overflow_bp, !!((cpu.A ^ op_value) & (cpu.A ^ result) & 0x80)); + cpu.A = result & 0xFF; + cpu_update_zn_flags(cpu.A); +} + +// Bit Manipulation Operations + +void cpu_op_and() { cpu_update_zn_flags(cpu.A &= op_value); } +void cpu_op_bit() { + cpu_modify_flag(zero_bp, !(cpu.A & op_value)); + cpu.P = (cpu.P & 0x3F) | (0xC0 & op_value); +} +void cpu_op_eor() { cpu_update_zn_flags(cpu.A ^= op_value); } +void cpu_op_ora() { cpu_update_zn_flags(cpu.A |= op_value); } +void cpu_op_asla() { + cpu_modify_flag(carry_bp, cpu.A & 0x80); + cpu.A <<= 1; + cpu_update_zn_flags(cpu.A); +} +void cpu_op_asl() { + cpu_modify_flag(carry_bp, op_value & 0x80); + op_value <<= 1; + op_value &= 0xFF; + cpu_update_zn_flags(op_value); + memory_writeb(op_address, op_value); +} +void cpu_op_lsra() { + int value = cpu.A >> 1; + cpu_modify_flag(carry_bp, cpu.A & 0x01); + cpu.A = value & 0xFF; + cpu_update_zn_flags(value); +} +void cpu_op_lsr() { + cpu_modify_flag(carry_bp, op_value & 0x01); + op_value >>= 1; + op_value &= 0xFF; + memory_writeb(op_address, op_value); + cpu_update_zn_flags(op_value); +} + +void cpu_op_rola() { + int value = cpu.A << 1; + value |= cpu_flag_set(carry_bp) ? 1 : 0; + cpu_modify_flag(carry_bp, value > 0xFF); + cpu.A = value & 0xFF; + cpu_update_zn_flags(cpu.A); +} +void cpu_op_rol() { + op_value <<= 1; + op_value |= cpu_flag_set(carry_bp) ? 1 : 0; + cpu_modify_flag(carry_bp, op_value > 0xFF); + op_value &= 0xFF; + memory_writeb(op_address, op_value); + cpu_update_zn_flags(op_value); +} +void cpu_op_rora() { + unsigned char carry = cpu_flag_set(carry_bp); + cpu_modify_flag(carry_bp, cpu.A & 0x01); + cpu.A = (cpu.A >> 1) | (carry << 7); + cpu_modify_flag(zero_bp, cpu.A == 0); + cpu_modify_flag(negative_bp, !!carry); +} +void cpu_op_ror() { + unsigned char carry = cpu_flag_set(carry_bp); + cpu_modify_flag(carry_bp, op_value & 0x01); + op_value = ((op_value >> 1) | (carry << 7)) & 0xFF; + cpu_modify_flag(zero_bp, op_value == 0); + cpu_modify_flag(negative_bp, !!carry); + memory_writeb(op_address, op_value); +} + +// Loading + +void cpu_op_lda() { cpu_update_zn_flags(cpu.A = op_value); } +void cpu_op_ldx() { cpu_update_zn_flags(cpu.X = op_value); } +void cpu_op_ldy() { cpu_update_zn_flags(cpu.Y = op_value); } + +// Storing + +void cpu_op_sta() { memory_writeb(op_address, cpu.A); } +void cpu_op_stx() { memory_writeb(op_address, cpu.X); } +void cpu_op_sty() { memory_writeb(op_address, cpu.Y); } + +// Transfering + +void cpu_op_tax() { cpu_update_zn_flags(cpu.X = cpu.A); } +void cpu_op_txa() { cpu_update_zn_flags(cpu.A = cpu.X); } +void cpu_op_tay() { cpu_update_zn_flags(cpu.Y = cpu.A); } +void cpu_op_tya() { cpu_update_zn_flags(cpu.A = cpu.Y); } +void cpu_op_tsx() { cpu_update_zn_flags(cpu.X = cpu.SP); } +void cpu_op_txs() { cpu.SP = cpu.X; } + +// Branching Positive + +void cpu_op_bcs() { cpu_branch(cpu_flag_set(carry_bp)); } +void cpu_op_beq() { cpu_branch(cpu_flag_set(zero_bp)); } +void cpu_op_bmi() { cpu_branch(cpu_flag_set(negative_bp)); } +void cpu_op_bvs() { cpu_branch(cpu_flag_set(overflow_bp)); } + +// Branching Negative + +void cpu_op_bne() { cpu_branch(!cpu_flag_set(zero_bp)); } +void cpu_op_bcc() { cpu_branch(!cpu_flag_set(carry_bp)); } +void cpu_op_bpl() { cpu_branch(!cpu_flag_set(negative_bp)); } +void cpu_op_bvc() { cpu_branch(!cpu_flag_set(overflow_bp)); } + +// Jumping + +void cpu_op_jmp() { cpu.PC = op_address; } + +// Subroutines + +void cpu_op_jsr() { cpu_stack_pushw(cpu.PC - 1); cpu.PC = op_address; } +void cpu_op_rts() { cpu.PC = cpu_stack_popw() + 1; } + +// Interruptions + +void cpu_op_brk() { + cpu_stack_pushw(cpu.PC - 1); + cpu_stack_pushb(cpu.P); + cpu.P |= unused_flag | break_flag; + cpu.PC = cpu_nmi_interrupt_address(); +} +void cpu_op_rti() { cpu.P = cpu_stack_popb() | unused_flag; cpu.PC = cpu_stack_popw(); } + +// Flags + +void cpu_op_clc() { cpu_unset_flag(carry_bp); } +void cpu_op_cld() { cpu_unset_flag(decimal_bp); } +void cpu_op_cli() { cpu_unset_flag(interrupt_bp); } +void cpu_op_clv() { cpu_unset_flag(overflow_bp); } +void cpu_op_sec() { cpu_set_flag(carry_bp); } +void cpu_op_sed() { cpu_set_flag(decimal_bp); } +void cpu_op_sei() { cpu_set_flag(interrupt_bp); } + +// Comparison + +void cpu_op_cmp() { cpu_compare(cpu.A); } +void cpu_op_cpx() { cpu_compare(cpu.X); } +void cpu_op_cpy() { cpu_compare(cpu.Y); } + +// Increment + +void cpu_op_inc() { + byte result = op_value + 1; + memory_writeb(op_address, result); + cpu_update_zn_flags(result); +} +void cpu_op_inx() { cpu_update_zn_flags(++cpu.X); } +void cpu_op_iny() { cpu_update_zn_flags(++cpu.Y); } + +// Decrement + +void cpu_op_dec() { + byte result = op_value - 1; + memory_writeb(op_address, result); + cpu_update_zn_flags(result); +} +void cpu_op_dex() { cpu_update_zn_flags(--cpu.X); } +void cpu_op_dey() { cpu_update_zn_flags(--cpu.Y); } + +// Stack + +void cpu_op_php() { cpu_stack_pushb(cpu.P | 0x30); } +void cpu_op_pha() { cpu_stack_pushb(cpu.A); } +void cpu_op_pla() { cpu.A = cpu_stack_popb(); cpu_update_zn_flags(cpu.A); } +void cpu_op_plp() { cpu.P = (cpu_stack_popb() & 0xEF) | 0x20; } + + +// Extended Instruction Set + +void cpu_op_aso() { cpu_op_asl(); cpu_op_ora(); } +void cpu_op_axa() { memory_writeb(op_address, cpu.A & cpu.X & (op_address >> 8)); } +void cpu_op_axs() { memory_writeb(op_address, cpu.A & cpu.X); } +void cpu_op_dcm() +{ + op_value--; + op_value &= 0xFF; + memory_writeb(op_address, op_value); + cpu_op_cmp(); +} +void cpu_op_ins() +{ + op_value = (op_value + 1) & 0xFF; + memory_writeb(op_address, op_value); + cpu_op_sbc(); +} +void cpu_op_lax() { cpu_update_zn_flags(cpu.A = cpu.X = op_value); } +void cpu_op_lse() { cpu_op_lsr(); cpu_op_eor(); } +void cpu_op_rla() { cpu_op_rol(); cpu_op_and(); } +void cpu_op_rra() { cpu_op_ror(); cpu_op_adc(); } + + +// Base 6502 instruction set + +#define CPU_OP_BIS(o, c, f, n, a) \ + cpu_op_cycles[0x##o] = c; \ + cpu_op_handler[0x##o] = cpu_op_##f; \ + cpu_op_name[0x##o] = n; \ + cpu_op_address_mode[0x##o] = cpu_address_##a; \ + cpu_op_in_base_instruction_set[0x##o] = true; + +// Not implemented instructions + +#define CPU_OP_NII(o, a) \ + cpu_op_cycles[0x##o] = 1; \ + cpu_op_handler[0x##o] = ____FE____; \ + cpu_op_name[0x##o] = "NOP"; \ + cpu_op_address_mode[0x##o] = cpu_address_##a; \ + cpu_op_in_base_instruction_set[0x##o] = false; + +// Extended instruction set found in other CPUs and implemented for compatibility + +#define CPU_OP_EIS(o, c, f, n, a) \ + cpu_op_cycles[0x##o] = c; \ + cpu_op_handler[0x##o] = cpu_op_##f; \ + cpu_op_name[0x##o] = n; \ + cpu_op_address_mode[0x##o] = cpu_address_##a; \ + cpu_op_in_base_instruction_set[0x##o] = false; + +// CPU Lifecycle + +void cpu_init() { + CPU_OP_BIS(00, 7, brk, "BRK", implied) + CPU_OP_BIS(01, 6, ora, "ORA", indirect_x) + CPU_OP_BIS(05, 3, ora, "ORA", zero_page) + CPU_OP_BIS(06, 5, asl, "ASL", zero_page) + CPU_OP_BIS(08, 3, php, "PHP", implied) + CPU_OP_BIS(09, 2, ora, "ORA", immediate) + CPU_OP_BIS(0A, 2, asla,"ASL", implied) + CPU_OP_BIS(0D, 4, ora, "ORA", absolute) + CPU_OP_BIS(0E, 6, asl, "ASL", absolute) + CPU_OP_BIS(10, 2, bpl, "BPL", relative) + CPU_OP_BIS(11, 5, ora, "ORA", indirect_y) + CPU_OP_BIS(15, 4, ora, "ORA", zero_page_x) + CPU_OP_BIS(16, 6, asl, "ASL", zero_page_x) + CPU_OP_BIS(18, 2, clc, "CLC", implied) + CPU_OP_BIS(19, 4, ora, "ORA", absolute_y) + CPU_OP_BIS(1D, 4, ora, "ORA", absolute_x) + CPU_OP_BIS(1E, 7, asl, "ASL", absolute_x) + CPU_OP_BIS(20, 6, jsr, "JSR", absolute) + CPU_OP_BIS(21, 6, and, "AND", indirect_x) + CPU_OP_BIS(24, 3, bit, "BIT", zero_page) + CPU_OP_BIS(25, 3, and, "AND", zero_page) + CPU_OP_BIS(26, 5, rol, "ROL", zero_page) + CPU_OP_BIS(28, 4, plp, "PLP", implied) + CPU_OP_BIS(29, 2, and, "AND", immediate) + CPU_OP_BIS(2A, 2, rola,"ROL", implied) + CPU_OP_BIS(2C, 4, bit, "BIT", absolute) + CPU_OP_BIS(2D, 2, and, "AND", absolute) + CPU_OP_BIS(2E, 6, rol, "ROL", absolute) + CPU_OP_BIS(30, 2, bmi, "BMI", relative) + CPU_OP_BIS(31, 5, and, "AND", indirect_y) + CPU_OP_BIS(35, 4, and, "AND", zero_page_x) + CPU_OP_BIS(36, 6, rol, "ROL", zero_page_x) + CPU_OP_BIS(38, 2, sec, "SEC", implied) + CPU_OP_BIS(39, 4, and, "AND", absolute_y) + CPU_OP_BIS(3D, 4, and, "AND", absolute_x) + CPU_OP_BIS(3E, 7, rol, "ROL", absolute_x) + CPU_OP_BIS(40, 6, rti, "RTI", implied) + CPU_OP_BIS(41, 6, eor, "EOR", indirect_x) + CPU_OP_BIS(45, 3, eor, "EOR", zero_page) + CPU_OP_BIS(46, 5, lsr, "LSR", zero_page) + CPU_OP_BIS(48, 3, pha, "PHA", implied) + CPU_OP_BIS(49, 2, eor, "EOR", immediate) + CPU_OP_BIS(4A, 2, lsra,"LSR", implied) + CPU_OP_BIS(4C, 3, jmp, "JMP", absolute) + CPU_OP_BIS(4D, 4, eor, "EOR", absolute) + CPU_OP_BIS(4E, 6, lsr, "LSR", absolute) + CPU_OP_BIS(50, 2, bvc, "BVC", relative) + CPU_OP_BIS(51, 5, eor, "EOR", indirect_y) + CPU_OP_BIS(55, 4, eor, "EOR", zero_page_x) + CPU_OP_BIS(56, 6, lsr, "LSR", zero_page_x) + CPU_OP_BIS(58, 2, cli, "CLI", implied) + CPU_OP_BIS(59, 4, eor, "EOR", absolute_y) + CPU_OP_BIS(5D, 4, eor, "EOR", absolute_x) + CPU_OP_BIS(5E, 7, lsr, "LSR", absolute_x) + CPU_OP_BIS(60, 6, rts, "RTS", implied) + CPU_OP_BIS(61, 6, adc, "ADC", indirect_x) + CPU_OP_BIS(65, 3, adc, "ADC", zero_page) + CPU_OP_BIS(66, 5, ror, "ROR", zero_page) + CPU_OP_BIS(68, 4, pla, "PLA", implied) + CPU_OP_BIS(69, 2, adc, "ADC", immediate) + CPU_OP_BIS(6A, 2, rora,"ROR", implied) + CPU_OP_BIS(6C, 5, jmp, "JMP", indirect) + CPU_OP_BIS(6D, 4, adc, "ADC", absolute) + CPU_OP_BIS(6E, 6, ror, "ROR", absolute) + CPU_OP_BIS(70, 2, bvs, "BVS", relative) + CPU_OP_BIS(71, 5, adc, "ADC", indirect_y) + CPU_OP_BIS(75, 4, adc, "ADC", zero_page_x) + CPU_OP_BIS(76, 6, ror, "ROR", zero_page_x) + CPU_OP_BIS(78, 2, sei, "SEI", implied) + CPU_OP_BIS(79, 4, adc, "ADC", absolute_y) + CPU_OP_BIS(7D, 4, adc, "ADC", absolute_x) + CPU_OP_BIS(7E, 7, ror, "ROR", absolute_x) + CPU_OP_BIS(81, 6, sta, "STA", indirect_x) + CPU_OP_BIS(84, 3, sty, "STY", zero_page) + CPU_OP_BIS(85, 3, sta, "STA", zero_page) + CPU_OP_BIS(86, 3, stx, "STX", zero_page) + CPU_OP_BIS(88, 2, dey, "DEY", implied) + CPU_OP_BIS(8A, 2, txa, "TXA", implied) + CPU_OP_BIS(8C, 4, sty, "STY", absolute) + CPU_OP_BIS(8D, 4, sta, "STA", absolute) + CPU_OP_BIS(8E, 4, stx, "STX", absolute) + CPU_OP_BIS(90, 2, bcc, "BCC", relative) + CPU_OP_BIS(91, 6, sta, "STA", indirect_y) + CPU_OP_BIS(94, 4, sty, "STY", zero_page_x) + CPU_OP_BIS(95, 4, sta, "STA", zero_page_x) + CPU_OP_BIS(96, 4, stx, "STX", zero_page_y) + CPU_OP_BIS(98, 2, tya, "TYA", implied) + CPU_OP_BIS(99, 5, sta, "STA", absolute_y) + CPU_OP_BIS(9A, 2, txs, "TXS", implied) + CPU_OP_BIS(9D, 5, sta, "STA", absolute_x) + CPU_OP_BIS(A0, 2, ldy, "LDY", immediate) + CPU_OP_BIS(A1, 6, lda, "LDA", indirect_x) + CPU_OP_BIS(A2, 2, ldx, "LDX", immediate) + CPU_OP_BIS(A4, 3, ldy, "LDY", zero_page) + CPU_OP_BIS(A5, 3, lda, "LDA", zero_page) + CPU_OP_BIS(A6, 3, ldx, "LDX", zero_page) + CPU_OP_BIS(A8, 2, tay, "TAY", implied) + CPU_OP_BIS(A9, 2, lda, "LDA", immediate) + CPU_OP_BIS(AA, 2, tax, "TAX", implied) + CPU_OP_BIS(AC, 4, ldy, "LDY", absolute) + CPU_OP_BIS(AD, 4, lda, "LDA", absolute) + CPU_OP_BIS(AE, 4, ldx, "LDX", absolute) + CPU_OP_BIS(B0, 2, bcs, "BCS", relative) + CPU_OP_BIS(B1, 5, lda, "LDA", indirect_y) + CPU_OP_BIS(B4, 4, ldy, "LDY", zero_page_x) + CPU_OP_BIS(B5, 4, lda, "LDA", zero_page_x) + CPU_OP_BIS(B6, 4, ldx, "LDX", zero_page_y) + CPU_OP_BIS(B8, 2, clv, "CLV", implied) + CPU_OP_BIS(B9, 4, lda, "LDA", absolute_y) + CPU_OP_BIS(BA, 2, tsx, "TSX", implied) + CPU_OP_BIS(BC, 4, ldy, "LDY", absolute_x) + CPU_OP_BIS(BD, 4, lda, "LDA", absolute_x) + CPU_OP_BIS(BE, 4, ldx, "LDX", absolute_y) + CPU_OP_BIS(C0, 2, cpy, "CPY", immediate) + CPU_OP_BIS(C1, 6, cmp, "CMP", indirect_x) + CPU_OP_BIS(C4, 3, cpy, "CPY", zero_page) + CPU_OP_BIS(C5, 3, cmp, "CMP", zero_page) + CPU_OP_BIS(C6, 5, dec, "DEC", zero_page) + CPU_OP_BIS(C8, 2, iny, "INY", implied) + CPU_OP_BIS(C9, 2, cmp, "CMP", immediate) + CPU_OP_BIS(CA, 2, dex, "DEX", implied) + CPU_OP_BIS(CC, 4, cpy, "CPY", absolute) + CPU_OP_BIS(CD, 4, cmp, "CMP", absolute) + CPU_OP_BIS(CE, 6, dec, "DEC", absolute) + CPU_OP_BIS(D0, 2, bne, "BNE", relative) + CPU_OP_BIS(D1, 5, cmp, "CMP", indirect_y) + CPU_OP_BIS(D5, 4, cmp, "CMP", zero_page_x) + CPU_OP_BIS(D6, 6, dec, "DEC", zero_page_x) + CPU_OP_BIS(D8, 2, cld, "CLD", implied) + CPU_OP_BIS(D9, 4, cmp, "CMP", absolute_y) + CPU_OP_BIS(DD, 4, cmp, "CMP", absolute_x) + CPU_OP_BIS(DE, 7, dec, "DEC", absolute_x) + CPU_OP_BIS(E0, 2, cpx, "CPX", immediate) + CPU_OP_BIS(E1, 6, sbc, "SBC", indirect_x) + CPU_OP_BIS(E4, 3, cpx, "CPX", zero_page) + CPU_OP_BIS(E5, 3, sbc, "SBC", zero_page) + CPU_OP_BIS(E6, 5, inc, "INC", zero_page) + CPU_OP_BIS(E8, 2, inx, "INX", implied) + CPU_OP_BIS(E9, 2, sbc, "SBC", immediate) + CPU_OP_BIS(EA, 2, nop, "NOP", implied) + CPU_OP_BIS(EC, 4, cpx, "CPX", absolute) + CPU_OP_BIS(ED, 4, sbc, "SBC", absolute) + CPU_OP_BIS(EE, 6, inc, "INC", absolute) + CPU_OP_BIS(F0, 2, beq, "BEQ", relative) + CPU_OP_BIS(F1, 5, sbc, "SBC", indirect_y) + CPU_OP_BIS(F5, 4, sbc, "SBC", zero_page_x) + CPU_OP_BIS(F6, 6, inc, "INC", zero_page_x) + CPU_OP_BIS(F8, 2, sed, "SED", implied) + CPU_OP_BIS(F9, 4, sbc, "SBC", absolute_y) + CPU_OP_BIS(FD, 4, sbc, "SBC", absolute_x) + CPU_OP_BIS(FE, 7, inc, "INC", absolute_x) + + CPU_OP_EIS(03, 8, aso, "SLO", indirect_x) + CPU_OP_EIS(07, 5, aso, "SLO", zero_page) + CPU_OP_EIS(0F, 6, aso, "SLO", absolute) + CPU_OP_EIS(13, 8, aso, "SLO", indirect_y) + CPU_OP_EIS(17, 6, aso, "SLO", zero_page_x) + CPU_OP_EIS(1B, 7, aso, "SLO", absolute_y) + CPU_OP_EIS(1F, 7, aso, "SLO", absolute_x) + CPU_OP_EIS(23, 8, rla, "RLA", indirect_x) + CPU_OP_EIS(27, 5, rla, "RLA", zero_page) + CPU_OP_EIS(2F, 6, rla, "RLA", absolute) + CPU_OP_EIS(33, 8, rla, "RLA", indirect_y) + CPU_OP_EIS(37, 6, rla, "RLA", zero_page_x) + CPU_OP_EIS(3B, 7, rla, "RLA", absolute_y) + CPU_OP_EIS(3F, 7, rla, "RLA", absolute_x) + CPU_OP_EIS(43, 8, lse, "SRE", indirect_x) + CPU_OP_EIS(47, 5, lse, "SRE", zero_page) + CPU_OP_EIS(4F, 6, lse, "SRE", absolute) + CPU_OP_EIS(53, 8, lse, "SRE", indirect_y) + CPU_OP_EIS(57, 6, lse, "SRE", zero_page_x) + CPU_OP_EIS(5B, 7, lse, "SRE", absolute_y) + CPU_OP_EIS(5F, 7, lse, "SRE", absolute_x) + CPU_OP_EIS(63, 8, rra, "RRA", indirect_x) + CPU_OP_EIS(67, 5, rra, "RRA", zero_page) + CPU_OP_EIS(6F, 6, rra, "RRA", absolute) + CPU_OP_EIS(73, 8, rra, "RRA", indirect_y) + CPU_OP_EIS(77, 6, rra, "RRA", zero_page_x) + CPU_OP_EIS(7B, 7, rra, "RRA", absolute_y) + CPU_OP_EIS(7F, 7, rra, "RRA", absolute_x) + CPU_OP_EIS(83, 6, axs, "SAX", indirect_x) + CPU_OP_EIS(87, 3, axs, "SAX", zero_page) + CPU_OP_EIS(8F, 4, axs, "SAX", absolute) + CPU_OP_EIS(93, 6, axa, "SAX", indirect_y) + CPU_OP_EIS(97, 4, axs, "SAX", zero_page_y) + CPU_OP_EIS(9F, 5, axa, "SAX", absolute_y) + CPU_OP_EIS(A3, 6, lax, "LAX", indirect_x) + CPU_OP_EIS(A7, 3, lax, "LAX", zero_page) + CPU_OP_EIS(AF, 4, lax, "LAX", absolute) + CPU_OP_EIS(B3, 5, lax, "LAX", indirect_y) + CPU_OP_EIS(B7, 4, lax, "LAX", zero_page_y) + CPU_OP_EIS(BF, 4, lax, "LAX", absolute_y) + CPU_OP_EIS(C3, 8, dcm, "DCP", indirect_x) + CPU_OP_EIS(C7, 5, dcm, "DCP", zero_page) + CPU_OP_EIS(CF, 6, dcm, "DCP", absolute) + CPU_OP_EIS(D3, 8, dcm, "DCP", indirect_y) + CPU_OP_EIS(D7, 6, dcm, "DCP", zero_page_x) + CPU_OP_EIS(DB, 7, dcm, "DCP", absolute_y) + CPU_OP_EIS(DF, 7, dcm, "DCP", absolute_x) + CPU_OP_EIS(E3, 8, ins, "ISB", indirect_x) + CPU_OP_EIS(E7, 5, ins, "ISB", zero_page) + CPU_OP_EIS(EB, 2, sbc, "SBC", immediate) + CPU_OP_EIS(EF, 6, ins, "ISB", absolute) + CPU_OP_EIS(F3, 8, ins, "ISB", indirect_y) + CPU_OP_EIS(F7, 6, ins, "ISB", zero_page_x) + CPU_OP_EIS(FB, 7, ins, "ISB", absolute_y) + CPU_OP_EIS(FF, 7, ins, "ISB", absolute_x) + + CPU_OP_NII(04, zero_page) + CPU_OP_NII(0C, absolute) + CPU_OP_NII(14, zero_page_x) + CPU_OP_NII(1A, implied) + CPU_OP_NII(1C, absolute_x) + CPU_OP_NII(34, zero_page_x) + CPU_OP_NII(3A, implied) + CPU_OP_NII(3C, absolute_x) + CPU_OP_NII(44, zero_page) + CPU_OP_NII(54, zero_page_x) + CPU_OP_NII(5A, implied) + CPU_OP_NII(5C, absolute_x) + CPU_OP_NII(64, zero_page) + CPU_OP_NII(74, zero_page_x) + CPU_OP_NII(7A, implied) + CPU_OP_NII(7C, absolute_x) + CPU_OP_NII(80, immediate) + CPU_OP_NII(D4, zero_page_x) + CPU_OP_NII(DA, implied) + CPU_OP_NII(DC, absolute_x) + CPU_OP_NII(F4, zero_page_x) + CPU_OP_NII(FA, implied) + CPU_OP_NII(FC, absolute_x) + + cpu.P = 0x24; + cpu.SP = 0x00; + cpu.A = cpu.X = cpu.Y = 0; +} + +void cpu_reset() { + cpu.PC = cpu_reset_interrupt_address(); + cpu.SP -= 3; + cpu.P |= interrupt_flag; +} + +void cpu_interrupt() { + if (ppu_generates_nmi()) { + cpu.P |= interrupt_flag; + cpu_unset_flag(unused_bp); + cpu_stack_pushw(cpu.PC); + cpu_stack_pushb(cpu.P); + cpu.PC = cpu_nmi_interrupt_address(); + } +} + +unsigned long long cpu_clock() { + return cpu_cycles; +} + +void cpu_run(long cycles) { + cycles /= 3; + while (cycles > 0) { + op_code = memory_readb(cpu.PC++); + if (cpu_op_address_mode[op_code] == NULL) { + } + else { + cpu_op_address_mode[op_code](); + cpu_op_handler[op_code](); + } + cycles -= cpu_op_cycles[op_code] + op_cycles; + cpu_cycles -= cpu_op_cycles[op_code] + op_cycles; + op_cycles = 0; + } +} diff --git a/am-kernels/kernels/litenes/src/cpu.h b/am-kernels/kernels/litenes/src/cpu.h new file mode 100644 index 0000000..270cba3 --- /dev/null +++ b/am-kernels/kernels/litenes/src/cpu.h @@ -0,0 +1,17 @@ +#include "common.h" + +#ifndef CPU_H +#define CPU_H + +byte cpu_ram_read(word address); +void cpu_ram_write(word address, byte data); + +void cpu_init(); +void cpu_reset(); +void cpu_interrupt(); +void cpu_run(long cycles); + +// CPU cycles that passed since power up +unsigned long long cpu_clock(); + +#endif diff --git a/am-kernels/kernels/litenes/src/fce.c b/am-kernels/kernels/litenes/src/fce.c new file mode 100644 index 0000000..b4ffac7 --- /dev/null +++ b/am-kernels/kernels/litenes/src/fce.c @@ -0,0 +1,140 @@ +#include "fce.h" +#include "cpu.h" +#include "memory.h" +#include "ppu.h" +#include "psg.h" +#include + +static int frame_cnt; +static inline bool candraw() { return frame_cnt % (1 + FRAME_SKIP) == 0; } + +static uint32_t canvas[SCR_W * SCR_H]; + +void draw(int x, int y, int idx) { + if (x >= 0 && x < SCR_W && y >= 0 && y < SCR_H && candraw()) { + canvas[y * SCR_W + x] = palette[idx]; + } +} + +typedef struct { + char signature[4]; + byte prg_block_count; + byte chr_block_count; + word rom_type; + byte reserved[8]; +} ines_header; + +static byte *buf; +static ines_header *fce_rom_header; + +byte *romread(int size) { + byte *ret = buf; + buf += size; + return ret; +} + +int fce_load_rom(char *rom) { + buf = (byte*)rom; + fce_rom_header = (ines_header*)romread(sizeof(ines_header)); + + if (memcmp(fce_rom_header->signature, "NES\x1A", 4)) { + return -1; + } + + mmc_id = ((fce_rom_header->rom_type & 0xF0) >> 4); + + int prg_size = fce_rom_header->prg_block_count * 0x4000; + + byte *blk = romread(prg_size); + + if (mmc_id == 0 || mmc_id == 3) { + // if there is only one PRG block, we must repeat it twice + if (fce_rom_header->prg_block_count == 1) { + mmc_copy(0x8000, blk, 0x4000); + mmc_copy(0xC000, blk, 0x4000); + } + else { + mmc_copy(0x8000, blk, 0x8000); + } + } + else { + return -1; + } + + // Copying CHR pages into MMC and PPU + int i; + for (i = 0; i < fce_rom_header->chr_block_count; i++) { + byte *blk = romread(0x2000); + mmc_append_chr_rom_page(blk); + + if (i == 0) { + ppu_copy(0x0000, blk, 0x2000); + } + } + + return 0; +} + +void fce_init() { + cpu_init(); + ppu_init(); + ppu_set_mirroring(fce_rom_header->rom_type & 1); + cpu_reset(); +} + +static int gtime; + +static inline int uptime_ms() { + return io_read(AM_TIMER_UPTIME).us / 1000; +} + +void wait_for_frame() { + int cur = uptime_ms(); + while (cur - gtime < 1000 / FPS) { + cur = uptime_ms(); + } + gtime = cur; +} + +// FCE Lifecycle + +void fce_run() { + gtime = uptime_ms(); + int nr_draw = 0; + uint32_t last = gtime; + while(1) { + wait_for_frame(); + int scanlines = 262; + + while (scanlines-- > 0) { + ppu_cycle(); + psg_detect_key(); + } + + nr_draw ++; + int upt = uptime_ms(); + if (upt - last > 1000) { + last = upt; + for (int i = 0; i < 80; i++) putch('\b'); + printf("(System time: %ds) FPS = %d", upt / 1000, nr_draw); + nr_draw = 0; + } + } +} + +void fce_update_screen() { + frame_cnt++; + if (!candraw()) return; + + int idx = ppu_ram_read(0x3F00); + uint32_t bgc = palette[idx]; + + AM_GPU_CONFIG_T cfg = io_read(AM_GPU_CONFIG); + int xpad = (cfg.width - SCR_W) / 2; + int ypad = (cfg.height - SCR_H) / 2; + panic_on(xpad < 0 || ypad < 0, "screen too small"); + + io_write(AM_GPU_FBDRAW, xpad, ypad, canvas, SCR_W, SCR_H, true); + + for (int i = 0; i < SCR_W * SCR_H; i ++) canvas[i] = bgc; +} diff --git a/am-kernels/kernels/litenes/src/fce.h b/am-kernels/kernels/litenes/src/fce.h new file mode 100644 index 0000000..4795874 --- /dev/null +++ b/am-kernels/kernels/litenes/src/fce.h @@ -0,0 +1,28 @@ +#ifndef FCE_H +#define FCE_H + +#include "common.h" + +#define FPS 60 +#define SCR_W 256 +#define SCR_H 240 +#define FRAME_SKIP 1 + +void fce_update_screen(); +int fce_load_rom(char *rom); +void fce_init(); +void fce_run(); +void draw(int x, int y, int idx); + +static const uint32_t palette[64] = { + 0x808080, 0x0000BB, 0x3700BF, 0x8400A6, 0xBB006A, 0xB7001E, 0xB30000, 0x912600, + 0x7B2B00, 0x003E00, 0x00480D, 0x003C22, 0x002F66, 0x000000, 0x050505, 0x050505, + 0xC8C8C8, 0x0059FF, 0x443CFF, 0xB733CC, 0xFF33AA, 0xFF375E, 0xFF371A, 0xD54B00, + 0xC46200, 0x3C7B00, 0x1E8415, 0x009566, 0x0084C4, 0x111111, 0x090909, 0x090909, + 0xFFFFFF, 0x0095FF, 0x6F84FF, 0xD56FFF, 0xFF77CC, 0xFF6F99, 0xFF7B59, 0xFF915F, + 0xFFA233, 0xA6BF00, 0x51D96A, 0x4DD5AE, 0x00D9FF, 0x666666, 0x0D0D0D, 0x0D0D0D, + 0xFFFFFF, 0x84BFFF, 0xBBBBFF, 0xD0BBFF, 0xFFBFEA, 0xFFBFCC, 0xFFC4B7, 0xFFCCAE, + 0xFFD9A2, 0xCCE199, 0xAEEEB7, 0xAAF7EE, 0xB3EEFF, 0xDDDDDD, 0x111111, 0x111111 +}; + +#endif diff --git a/am-kernels/kernels/litenes/src/main.c b/am-kernels/kernels/litenes/src/main.c new file mode 100644 index 0000000..491f155 --- /dev/null +++ b/am-kernels/kernels/litenes/src/main.c @@ -0,0 +1,22 @@ +#include "common.h" +#include "fce.h" +#include "psg.h" + +extern char rom_mario_nes[]; + +int main() { + ioe_init(); + + printf("==================== LiteNES Emulator ====================\n\n"); + printf("Control: [%s] SELECT [%s] START [%s]\n" + " [%s] [%s] [%s] A [%s] B [%s]\n\n", + TOSTRING(KEY_UP), TOSTRING(KEY_SELECT), TOSTRING(KEY_START), + TOSTRING(KEY_LEFT), TOSTRING(KEY_DOWN), TOSTRING(KEY_RIGHT), + TOSTRING(KEY_A), TOSTRING(KEY_B)); + printf("==========================================================\n"); + + fce_load_rom((void *)rom_mario_nes); + fce_init(); + fce_run(); + return 1; +} diff --git a/am-kernels/kernels/litenes/src/mario-rom.c b/am-kernels/kernels/litenes/src/mario-rom.c new file mode 100644 index 0000000..8ece2a7 --- /dev/null +++ b/am-kernels/kernels/litenes/src/mario-rom.c @@ -0,0 +1,3418 @@ +unsigned char rom_mario_nes[] = { + 0x4e, 0x45, 0x53, 0x1a, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x78, 0xd8, 0xa9, 0x10, 0x8d, 0x00, 0x20, 0xa2, + 0xff, 0x9a, 0xad, 0x02, 0x20, 0x10, 0xfb, 0xad, 0x02, 0x20, 0x10, 0xfb, + 0xa0, 0xfe, 0xa2, 0x05, 0xbd, 0xd7, 0x07, 0xc9, 0x0a, 0xb0, 0x0c, 0xca, + 0x10, 0xf6, 0xad, 0xff, 0x07, 0xc9, 0xa5, 0xd0, 0x02, 0xa0, 0xd6, 0x20, + 0xcc, 0x90, 0x8d, 0x11, 0x40, 0x8d, 0x70, 0x07, 0xa9, 0xa5, 0x8d, 0xff, + 0x07, 0x8d, 0xa7, 0x07, 0xa9, 0x0f, 0x8d, 0x15, 0x40, 0xa9, 0x06, 0x8d, + 0x01, 0x20, 0x20, 0x20, 0x82, 0x20, 0x19, 0x8e, 0xee, 0x74, 0x07, 0xad, + 0x78, 0x07, 0x09, 0x80, 0x20, 0xed, 0x8e, 0x4c, 0x57, 0x80, 0x01, 0xa4, + 0xc8, 0xec, 0x10, 0x00, 0x41, 0x41, 0x4c, 0x34, 0x3c, 0x44, 0x54, 0x68, + 0x7c, 0xa8, 0xbf, 0xde, 0xef, 0x03, 0x8c, 0x8c, 0x8c, 0x8d, 0x03, 0x03, + 0x03, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, 0x8d, + 0x00, 0x40, 0xad, 0x78, 0x07, 0x29, 0x7f, 0x8d, 0x78, 0x07, 0x29, 0x7e, + 0x8d, 0x00, 0x20, 0xad, 0x79, 0x07, 0x29, 0xe6, 0xac, 0x74, 0x07, 0xd0, + 0x05, 0xad, 0x79, 0x07, 0x09, 0x1e, 0x8d, 0x79, 0x07, 0x29, 0xe7, 0x8d, + 0x01, 0x20, 0xae, 0x02, 0x20, 0xa9, 0x00, 0x20, 0xe6, 0x8e, 0x8d, 0x03, + 0x20, 0xa9, 0x02, 0x8d, 0x14, 0x40, 0xae, 0x73, 0x07, 0xbd, 0x5a, 0x80, + 0x85, 0x00, 0xbd, 0x6d, 0x80, 0x85, 0x01, 0x20, 0xdd, 0x8e, 0xa0, 0x00, + 0xae, 0x73, 0x07, 0xe0, 0x06, 0xd0, 0x01, 0xc8, 0xbe, 0x80, 0x80, 0xa9, + 0x00, 0x9d, 0x00, 0x03, 0x9d, 0x01, 0x03, 0x8d, 0x73, 0x07, 0xad, 0x79, + 0x07, 0x8d, 0x01, 0x20, 0x20, 0xd0, 0xf2, 0x20, 0x5c, 0x8e, 0x20, 0x82, + 0x81, 0x20, 0x97, 0x8f, 0xad, 0x76, 0x07, 0x4a, 0xb0, 0x25, 0xad, 0x47, + 0x07, 0xf0, 0x05, 0xce, 0x47, 0x07, 0xd0, 0x19, 0xa2, 0x14, 0xce, 0x7f, + 0x07, 0x10, 0x07, 0xa9, 0x14, 0x8d, 0x7f, 0x07, 0xa2, 0x23, 0xbd, 0x80, + 0x07, 0xf0, 0x03, 0xde, 0x80, 0x07, 0xca, 0x10, 0xf5, 0xe6, 0x09, 0xa2, + 0x00, 0xa0, 0x07, 0xad, 0xa7, 0x07, 0x29, 0x02, 0x85, 0x00, 0xad, 0xa8, + 0x07, 0x29, 0x02, 0x45, 0x00, 0x18, 0xf0, 0x01, 0x38, 0x7e, 0xa7, 0x07, + 0xe8, 0x88, 0xd0, 0xf9, 0xad, 0x22, 0x07, 0xf0, 0x1f, 0xad, 0x02, 0x20, + 0x29, 0x40, 0xd0, 0xf9, 0xad, 0x76, 0x07, 0x4a, 0xb0, 0x06, 0x20, 0x23, + 0x82, 0x20, 0xc6, 0x81, 0xad, 0x02, 0x20, 0x29, 0x40, 0xf0, 0xf9, 0xa0, + 0x14, 0x88, 0xd0, 0xfd, 0xad, 0x3f, 0x07, 0x8d, 0x05, 0x20, 0xad, 0x40, + 0x07, 0x8d, 0x05, 0x20, 0xad, 0x78, 0x07, 0x48, 0x8d, 0x00, 0x20, 0xad, + 0x76, 0x07, 0x4a, 0xb0, 0x03, 0x20, 0x12, 0x82, 0xad, 0x02, 0x20, 0x68, + 0x09, 0x80, 0x8d, 0x00, 0x20, 0x40, 0xad, 0x70, 0x07, 0xc9, 0x02, 0xf0, + 0x0b, 0xc9, 0x01, 0xd0, 0x38, 0xad, 0x72, 0x07, 0xc9, 0x03, 0xd0, 0x31, + 0xad, 0x77, 0x07, 0xf0, 0x04, 0xce, 0x77, 0x07, 0x60, 0xad, 0xfc, 0x06, + 0x29, 0x10, 0xf0, 0x19, 0xad, 0x76, 0x07, 0x29, 0x80, 0xd0, 0x1a, 0xa9, + 0x2b, 0x8d, 0x77, 0x07, 0xad, 0x76, 0x07, 0xa8, 0xc8, 0x84, 0xfa, 0x49, + 0x01, 0x09, 0x80, 0xd0, 0x05, 0xad, 0x76, 0x07, 0x29, 0x7f, 0x8d, 0x76, + 0x07, 0x60, 0xac, 0x4e, 0x07, 0xa9, 0x28, 0x85, 0x00, 0xa2, 0x0e, 0xbd, + 0xe4, 0x06, 0xc5, 0x00, 0x90, 0x0f, 0xac, 0xe0, 0x06, 0x18, 0x79, 0xe1, + 0x06, 0x90, 0x03, 0x18, 0x65, 0x00, 0x9d, 0xe4, 0x06, 0xca, 0x10, 0xe7, + 0xae, 0xe0, 0x06, 0xe8, 0xe0, 0x03, 0xd0, 0x02, 0xa2, 0x00, 0x8e, 0xe0, + 0x06, 0xa2, 0x08, 0xa0, 0x02, 0xb9, 0xe9, 0x06, 0x9d, 0xf1, 0x06, 0x18, + 0x69, 0x08, 0x9d, 0xf2, 0x06, 0x18, 0x69, 0x08, 0x9d, 0xf3, 0x06, 0xca, + 0xca, 0xca, 0x88, 0x10, 0xe8, 0x60, 0xad, 0x70, 0x07, 0x20, 0x04, 0x8e, + 0x31, 0x82, 0xdc, 0xae, 0x8b, 0x83, 0x18, 0x92, 0xa0, 0x00, 0x2c, 0xa0, + 0x04, 0xa9, 0xf8, 0x99, 0x00, 0x02, 0xc8, 0xc8, 0xc8, 0xc8, 0xd0, 0xf7, + 0x60, 0xad, 0x72, 0x07, 0x20, 0x04, 0x8e, 0xcf, 0x8f, 0x67, 0x85, 0x61, + 0x90, 0x45, 0x82, 0x04, 0x20, 0x73, 0x01, 0x00, 0x00, 0xa0, 0x00, 0xad, + 0xfc, 0x06, 0x0d, 0xfd, 0x06, 0xc9, 0x10, 0xf0, 0x04, 0xc9, 0x90, 0xd0, + 0x03, 0x4c, 0xd8, 0x82, 0xc9, 0x20, 0xf0, 0x1a, 0xae, 0xa2, 0x07, 0xd0, + 0x0b, 0x8d, 0x80, 0x07, 0x20, 0x6b, 0x83, 0xb0, 0x60, 0x4c, 0xc0, 0x82, + 0xae, 0xfc, 0x07, 0xf0, 0x4a, 0xc9, 0x40, 0xd0, 0x46, 0xc8, 0xad, 0xa2, + 0x07, 0xf0, 0x4e, 0xa9, 0x18, 0x8d, 0xa2, 0x07, 0xad, 0x80, 0x07, 0xd0, + 0x36, 0xa9, 0x10, 0x8d, 0x80, 0x07, 0xc0, 0x01, 0xf0, 0x0e, 0xad, 0x7a, + 0x07, 0x49, 0x01, 0x8d, 0x7a, 0x07, 0x20, 0x25, 0x83, 0x4c, 0xbb, 0x82, + 0xae, 0x6b, 0x07, 0xe8, 0x8a, 0x29, 0x07, 0x8d, 0x6b, 0x07, 0x20, 0x0e, + 0x83, 0xbd, 0x3f, 0x82, 0x9d, 0x00, 0x03, 0xe8, 0xe0, 0x06, 0x30, 0xf5, + 0xac, 0x5f, 0x07, 0xc8, 0x8c, 0x04, 0x03, 0xa9, 0x00, 0x8d, 0xfc, 0x06, + 0x20, 0xea, 0xae, 0xa5, 0x0e, 0xc9, 0x06, 0xd0, 0x44, 0xa9, 0x00, 0x8d, + 0x70, 0x07, 0x8d, 0x72, 0x07, 0x8d, 0x22, 0x07, 0xee, 0x74, 0x07, 0x60, + 0xac, 0xa2, 0x07, 0xf0, 0xec, 0x0a, 0x90, 0x06, 0xad, 0xfd, 0x07, 0x20, + 0x0e, 0x83, 0x20, 0x03, 0x9c, 0xee, 0x5d, 0x07, 0xee, 0x64, 0x07, 0xee, + 0x57, 0x07, 0xee, 0x70, 0x07, 0xad, 0xfc, 0x07, 0x8d, 0x6a, 0x07, 0xa9, + 0x00, 0x8d, 0x72, 0x07, 0x8d, 0xa2, 0x07, 0xa2, 0x17, 0xa9, 0x00, 0x9d, + 0xdd, 0x07, 0xca, 0x10, 0xfa, 0x60, 0x8d, 0x5f, 0x07, 0x8d, 0x66, 0x07, + 0xa2, 0x00, 0x8e, 0x60, 0x07, 0x8e, 0x67, 0x07, 0x60, 0x07, 0x22, 0x49, + 0x83, 0xce, 0x24, 0x24, 0x00, 0xa0, 0x07, 0xb9, 0x1d, 0x83, 0x99, 0x00, + 0x03, 0x88, 0x10, 0xf7, 0xad, 0x7a, 0x07, 0xf0, 0x0a, 0xa9, 0x24, 0x8d, + 0x04, 0x03, 0xa9, 0xce, 0x8d, 0x06, 0x03, 0x60, 0x01, 0x80, 0x02, 0x81, + 0x41, 0x80, 0x01, 0x42, 0xc2, 0x02, 0x80, 0x41, 0xc1, 0x41, 0xc1, 0x01, + 0xc1, 0x01, 0x02, 0x80, 0x00, 0x9b, 0x10, 0x18, 0x05, 0x2c, 0x20, 0x24, + 0x15, 0x5a, 0x10, 0x20, 0x28, 0x30, 0x20, 0x10, 0x80, 0x20, 0x30, 0x30, + 0x01, 0xff, 0x00, 0xae, 0x17, 0x07, 0xad, 0x18, 0x07, 0xd0, 0x0d, 0xe8, + 0xee, 0x17, 0x07, 0x38, 0xbd, 0x54, 0x83, 0x8d, 0x18, 0x07, 0xf0, 0x0a, + 0xbd, 0x3f, 0x83, 0x8d, 0xfc, 0x06, 0xce, 0x18, 0x07, 0x18, 0x60, 0x20, + 0xa0, 0x83, 0xad, 0x72, 0x07, 0xf0, 0x07, 0xa2, 0x00, 0x86, 0x08, 0x20, + 0x47, 0xc0, 0x20, 0x2a, 0xf1, 0x4c, 0xe9, 0xee, 0xad, 0x72, 0x07, 0x20, + 0x04, 0x8e, 0xec, 0xcf, 0xb0, 0x83, 0xbd, 0x83, 0xf6, 0x83, 0x61, 0x84, + 0xae, 0x1b, 0x07, 0xe8, 0x86, 0x34, 0xa9, 0x08, 0x85, 0xfc, 0x4c, 0x4e, + 0x87, 0xa0, 0x00, 0x84, 0x35, 0xa5, 0x6d, 0xc5, 0x34, 0xd0, 0x06, 0xa5, + 0x86, 0xc9, 0x60, 0xb0, 0x03, 0xe6, 0x35, 0xc8, 0x98, 0x20, 0xe6, 0xb0, + 0xad, 0x1a, 0x07, 0xc5, 0x34, 0xf0, 0x16, 0xad, 0x68, 0x07, 0x18, 0x69, + 0x80, 0x8d, 0x68, 0x07, 0xa9, 0x01, 0x69, 0x00, 0xa8, 0x20, 0xc4, 0xaf, + 0x20, 0x6f, 0xaf, 0xe6, 0x35, 0xa5, 0x35, 0xf0, 0x68, 0x60, 0xad, 0x49, + 0x07, 0xd0, 0x48, 0xad, 0x19, 0x07, 0xf0, 0x18, 0xc9, 0x09, 0xb0, 0x3f, + 0xac, 0x5f, 0x07, 0xc0, 0x07, 0xd0, 0x09, 0xc9, 0x03, 0x90, 0x34, 0xe9, + 0x01, 0x4c, 0x18, 0x84, 0xc9, 0x02, 0x90, 0x2b, 0xa8, 0xd0, 0x08, 0xad, + 0x53, 0x07, 0xf0, 0x14, 0xc8, 0xd0, 0x11, 0xc8, 0xad, 0x5f, 0x07, 0xc9, + 0x07, 0xf0, 0x09, 0x88, 0xc0, 0x04, 0xb0, 0x26, 0xc0, 0x03, 0xb0, 0x0f, + 0xc0, 0x03, 0xd0, 0x04, 0xa9, 0x04, 0x85, 0xfc, 0x98, 0x18, 0x69, 0x0c, + 0x8d, 0x73, 0x07, 0xad, 0x49, 0x07, 0x18, 0x69, 0x04, 0x8d, 0x49, 0x07, + 0xad, 0x19, 0x07, 0x69, 0x00, 0x8d, 0x19, 0x07, 0xc9, 0x07, 0x90, 0x08, + 0xa9, 0x06, 0x8d, 0xa1, 0x07, 0xee, 0x72, 0x07, 0x60, 0xad, 0xa1, 0x07, + 0xd0, 0x20, 0xac, 0x5f, 0x07, 0xc0, 0x07, 0xb0, 0x1a, 0xa9, 0x00, 0x8d, + 0x60, 0x07, 0x8d, 0x5c, 0x07, 0x8d, 0x72, 0x07, 0xee, 0x5f, 0x07, 0x20, + 0x03, 0x9c, 0xee, 0x57, 0x07, 0xa9, 0x01, 0x8d, 0x70, 0x07, 0x60, 0xad, + 0xfc, 0x06, 0x0d, 0xfd, 0x06, 0x29, 0x40, 0xf0, 0x0d, 0xa9, 0x01, 0x8d, + 0xfc, 0x07, 0xa9, 0xff, 0x8d, 0x5a, 0x07, 0x20, 0x48, 0x92, 0x60, 0xff, + 0xff, 0xf6, 0xfb, 0xf7, 0xfb, 0xf8, 0xfb, 0xf9, 0xfb, 0xfa, 0xfb, 0xf6, + 0x50, 0xf7, 0x50, 0xf8, 0x50, 0xf9, 0x50, 0xfa, 0x50, 0xfd, 0xfe, 0xff, + 0x41, 0x42, 0x44, 0x45, 0x48, 0x31, 0x32, 0x34, 0x35, 0x38, 0x00, 0xbd, + 0x10, 0x01, 0xf0, 0xbe, 0xc9, 0x0b, 0x90, 0x05, 0xa9, 0x0b, 0x9d, 0x10, + 0x01, 0xa8, 0xbd, 0x2c, 0x01, 0xd0, 0x04, 0x9d, 0x10, 0x01, 0x60, 0xde, + 0x2c, 0x01, 0xc9, 0x2b, 0xd0, 0x1e, 0xc0, 0x0b, 0xd0, 0x07, 0xee, 0x5a, + 0x07, 0xa9, 0x40, 0x85, 0xfe, 0xb9, 0xb7, 0x84, 0x4a, 0x4a, 0x4a, 0x4a, + 0xaa, 0xb9, 0xb7, 0x84, 0x29, 0x0f, 0x9d, 0x34, 0x01, 0x20, 0x27, 0xbc, + 0xbc, 0xe5, 0x06, 0xb5, 0x16, 0xc9, 0x12, 0xf0, 0x22, 0xc9, 0x0d, 0xf0, + 0x1e, 0xc9, 0x05, 0xf0, 0x12, 0xc9, 0x0a, 0xf0, 0x16, 0xc9, 0x0b, 0xf0, + 0x12, 0xc9, 0x09, 0xb0, 0x06, 0xb5, 0x1e, 0xc9, 0x02, 0xb0, 0x08, 0xae, + 0xee, 0x03, 0xbc, 0xec, 0x06, 0xa6, 0x08, 0xbd, 0x1e, 0x01, 0xc9, 0x18, + 0x90, 0x05, 0xe9, 0x01, 0x9d, 0x1e, 0x01, 0xbd, 0x1e, 0x01, 0xe9, 0x08, + 0x20, 0xc1, 0xe5, 0xbd, 0x17, 0x01, 0x99, 0x03, 0x02, 0x18, 0x69, 0x08, + 0x99, 0x07, 0x02, 0xa9, 0x02, 0x99, 0x02, 0x02, 0x99, 0x06, 0x02, 0xbd, + 0x10, 0x01, 0x0a, 0xaa, 0xbd, 0x9f, 0x84, 0x99, 0x01, 0x02, 0xbd, 0xa0, + 0x84, 0x99, 0x05, 0x02, 0xa6, 0x08, 0x60, 0xad, 0x3c, 0x07, 0x20, 0x04, + 0x8e, 0x8b, 0x85, 0x9b, 0x85, 0x52, 0x86, 0x5a, 0x86, 0x93, 0x86, 0x9d, + 0x88, 0xa8, 0x86, 0x9d, 0x88, 0xe6, 0x86, 0xbf, 0x85, 0xe3, 0x85, 0x43, + 0x86, 0xff, 0x86, 0x32, 0x87, 0x49, 0x87, 0x20, 0x20, 0x82, 0x20, 0x19, + 0x8e, 0xad, 0x70, 0x07, 0xf0, 0x32, 0xa2, 0x03, 0x4c, 0xc5, 0x85, 0xad, + 0x44, 0x07, 0x48, 0xad, 0x56, 0x07, 0x48, 0xa9, 0x00, 0x8d, 0x56, 0x07, + 0xa9, 0x02, 0x8d, 0x44, 0x07, 0x20, 0xf1, 0x85, 0x68, 0x8d, 0x56, 0x07, + 0x68, 0x8d, 0x44, 0x07, 0x4c, 0x45, 0x87, 0x01, 0x02, 0x03, 0x04, 0xac, + 0x4e, 0x07, 0xbe, 0xbb, 0x85, 0x8e, 0x73, 0x07, 0x4c, 0x45, 0x87, 0x00, + 0x09, 0x0a, 0x04, 0x22, 0x22, 0x0f, 0x0f, 0x0f, 0x22, 0x0f, 0x0f, 0x22, + 0x16, 0x27, 0x18, 0x22, 0x30, 0x27, 0x19, 0x22, 0x37, 0x27, 0x16, 0xac, + 0x44, 0x07, 0xf0, 0x06, 0xb9, 0xc7, 0x85, 0x8d, 0x73, 0x07, 0xee, 0x3c, + 0x07, 0xae, 0x00, 0x03, 0xa0, 0x00, 0xad, 0x53, 0x07, 0xf0, 0x02, 0xa0, + 0x04, 0xad, 0x56, 0x07, 0xc9, 0x02, 0xd0, 0x02, 0xa0, 0x08, 0xa9, 0x03, + 0x85, 0x00, 0xb9, 0xd7, 0x85, 0x9d, 0x04, 0x03, 0xc8, 0xe8, 0xc6, 0x00, + 0x10, 0xf4, 0xae, 0x00, 0x03, 0xac, 0x44, 0x07, 0xd0, 0x03, 0xac, 0x4e, + 0x07, 0xb9, 0xcf, 0x85, 0x9d, 0x04, 0x03, 0xa9, 0x3f, 0x9d, 0x01, 0x03, + 0xa9, 0x10, 0x9d, 0x02, 0x03, 0xa9, 0x04, 0x9d, 0x03, 0x03, 0xa9, 0x00, + 0x9d, 0x08, 0x03, 0x8a, 0x18, 0x69, 0x07, 0x8d, 0x00, 0x03, 0x60, 0xad, + 0x33, 0x07, 0xc9, 0x01, 0xd0, 0x05, 0xa9, 0x0b, 0x8d, 0x73, 0x07, 0x4c, + 0x45, 0x87, 0xa9, 0x00, 0x20, 0x08, 0x88, 0x4c, 0x45, 0x87, 0x20, 0x30, + 0xbc, 0xae, 0x00, 0x03, 0xa9, 0x20, 0x9d, 0x01, 0x03, 0xa9, 0x73, 0x9d, + 0x02, 0x03, 0xa9, 0x03, 0x9d, 0x03, 0x03, 0xac, 0x5f, 0x07, 0xc8, 0x98, + 0x9d, 0x04, 0x03, 0xa9, 0x28, 0x9d, 0x05, 0x03, 0xac, 0x5c, 0x07, 0xc8, + 0x98, 0x9d, 0x06, 0x03, 0xa9, 0x00, 0x9d, 0x07, 0x03, 0x8a, 0x18, 0x69, + 0x06, 0x8d, 0x00, 0x03, 0x4c, 0x45, 0x87, 0xad, 0x59, 0x07, 0xf0, 0x0a, + 0xa9, 0x00, 0x8d, 0x59, 0x07, 0xa9, 0x02, 0x4c, 0xc7, 0x86, 0xee, 0x3c, + 0x07, 0x4c, 0x45, 0x87, 0xad, 0x70, 0x07, 0xf0, 0x33, 0xc9, 0x03, 0xf0, + 0x22, 0xad, 0x52, 0x07, 0xd0, 0x2a, 0xac, 0x4e, 0x07, 0xc0, 0x03, 0xf0, + 0x05, 0xad, 0x69, 0x07, 0xd0, 0x1e, 0x20, 0xa4, 0xef, 0xa9, 0x01, 0x20, + 0x08, 0x88, 0x20, 0xa5, 0x88, 0xa9, 0x00, 0x8d, 0x74, 0x07, 0x60, 0xa9, + 0x12, 0x8d, 0xa0, 0x07, 0xa9, 0x03, 0x20, 0x08, 0x88, 0x4c, 0x4e, 0x87, + 0xa9, 0x08, 0x8d, 0x3c, 0x07, 0x60, 0xee, 0x74, 0x07, 0x20, 0xb0, 0x92, + 0xad, 0x1f, 0x07, 0xd0, 0xf8, 0xce, 0x1e, 0x07, 0x10, 0x03, 0xee, 0x3c, + 0x07, 0xa9, 0x06, 0x8d, 0x73, 0x07, 0x60, 0xad, 0x70, 0x07, 0xd0, 0x4a, + 0xa9, 0x1e, 0x8d, 0x06, 0x20, 0xa9, 0xc0, 0x8d, 0x06, 0x20, 0xa9, 0x03, + 0x85, 0x01, 0xa0, 0x00, 0x84, 0x00, 0xad, 0x07, 0x20, 0xad, 0x07, 0x20, + 0x91, 0x00, 0xc8, 0xd0, 0x02, 0xe6, 0x01, 0xa5, 0x01, 0xc9, 0x04, 0xd0, + 0xf0, 0xc0, 0x3a, 0x90, 0xec, 0xa9, 0x05, 0x4c, 0x4c, 0x86, 0xad, 0x70, + 0x07, 0xd0, 0x17, 0xa2, 0x00, 0x9d, 0x00, 0x03, 0x9d, 0x00, 0x04, 0xca, + 0xd0, 0xf7, 0x20, 0x25, 0x83, 0xee, 0x3c, 0x07, 0x60, 0xa9, 0xfa, 0x20, + 0x36, 0xbc, 0xee, 0x72, 0x07, 0x60, 0x20, 0x43, 0x05, 0x16, 0x0a, 0x1b, + 0x12, 0x18, 0x20, 0x52, 0x0b, 0x20, 0x18, 0x1b, 0x15, 0x0d, 0x24, 0x24, + 0x1d, 0x12, 0x16, 0x0e, 0x20, 0x68, 0x05, 0x00, 0x24, 0x24, 0x2e, 0x29, + 0x23, 0xc0, 0x7f, 0xaa, 0x23, 0xc2, 0x01, 0xea, 0xff, 0x21, 0xcd, 0x07, + 0x24, 0x24, 0x29, 0x24, 0x24, 0x24, 0x24, 0x21, 0x4b, 0x09, 0x20, 0x18, + 0x1b, 0x15, 0x0d, 0x24, 0x24, 0x28, 0x24, 0x22, 0x0c, 0x47, 0x24, 0x23, + 0xdc, 0x01, 0xba, 0xff, 0x21, 0xcd, 0x05, 0x16, 0x0a, 0x1b, 0x12, 0x18, + 0x22, 0x0c, 0x07, 0x1d, 0x12, 0x16, 0x0e, 0x24, 0x1e, 0x19, 0xff, 0x21, + 0xcd, 0x05, 0x16, 0x0a, 0x1b, 0x12, 0x18, 0x22, 0x0b, 0x09, 0x10, 0x0a, + 0x16, 0x0e, 0x24, 0x18, 0x1f, 0x0e, 0x1b, 0xff, 0x25, 0x84, 0x15, 0x20, + 0x0e, 0x15, 0x0c, 0x18, 0x16, 0x0e, 0x24, 0x1d, 0x18, 0x24, 0x20, 0x0a, + 0x1b, 0x19, 0x24, 0x23, 0x18, 0x17, 0x0e, 0x2b, 0x26, 0x25, 0x01, 0x24, + 0x26, 0x2d, 0x01, 0x24, 0x26, 0x35, 0x01, 0x24, 0x27, 0xd9, 0x46, 0xaa, + 0x27, 0xe1, 0x45, 0xaa, 0xff, 0x15, 0x1e, 0x12, 0x10, 0x12, 0x04, 0x03, + 0x02, 0x00, 0x24, 0x05, 0x24, 0x00, 0x08, 0x07, 0x06, 0x00, 0x00, 0x00, + 0x27, 0x27, 0x46, 0x4e, 0x59, 0x61, 0x6e, 0x6e, 0x48, 0x0a, 0xa8, 0xc0, + 0x04, 0x90, 0x0c, 0xc0, 0x08, 0x90, 0x02, 0xa0, 0x08, 0xad, 0x7a, 0x07, + 0xd0, 0x01, 0xc8, 0xbe, 0xfe, 0x87, 0xa0, 0x00, 0xbd, 0x52, 0x87, 0xc9, + 0xff, 0xf0, 0x07, 0x99, 0x01, 0x03, 0xe8, 0xc8, 0xd0, 0xf2, 0xa9, 0x00, + 0x99, 0x01, 0x03, 0x68, 0xaa, 0xc9, 0x04, 0xb0, 0x49, 0xca, 0xd0, 0x23, + 0xad, 0x5a, 0x07, 0x18, 0x69, 0x01, 0xc9, 0x0a, 0x90, 0x07, 0xe9, 0x0a, + 0xa0, 0x9f, 0x8c, 0x08, 0x03, 0x8d, 0x09, 0x03, 0xac, 0x5f, 0x07, 0xc8, + 0x8c, 0x14, 0x03, 0xac, 0x5c, 0x07, 0xc8, 0x8c, 0x16, 0x03, 0x60, 0xad, + 0x7a, 0x07, 0xf0, 0x1d, 0xad, 0x53, 0x07, 0xca, 0xd0, 0x09, 0xac, 0x70, + 0x07, 0xc0, 0x03, 0xf0, 0x02, 0x49, 0x01, 0x4a, 0x90, 0x0b, 0xa0, 0x04, + 0xb9, 0xed, 0x87, 0x99, 0x04, 0x03, 0x88, 0x10, 0xf7, 0x60, 0xe9, 0x04, + 0x0a, 0x0a, 0xaa, 0xa0, 0x00, 0xbd, 0xf2, 0x87, 0x99, 0x1c, 0x03, 0xe8, + 0xc8, 0xc8, 0xc8, 0xc8, 0xc0, 0x0c, 0x90, 0xf1, 0xa9, 0x2c, 0x4c, 0x3f, + 0x86, 0xad, 0xa0, 0x07, 0xd0, 0x0b, 0x20, 0x20, 0x82, 0xa9, 0x07, 0x8d, + 0xa0, 0x07, 0xee, 0x3c, 0x07, 0x60, 0xad, 0x26, 0x07, 0x29, 0x01, 0x85, + 0x05, 0xac, 0x40, 0x03, 0x84, 0x00, 0xad, 0x21, 0x07, 0x99, 0x42, 0x03, + 0xad, 0x20, 0x07, 0x99, 0x41, 0x03, 0xa9, 0x9a, 0x99, 0x43, 0x03, 0xa9, + 0x00, 0x85, 0x04, 0xaa, 0x86, 0x01, 0xbd, 0xa1, 0x06, 0x29, 0xc0, 0x85, + 0x03, 0x0a, 0x2a, 0x2a, 0xa8, 0xb9, 0x08, 0x8b, 0x85, 0x06, 0xb9, 0x0c, + 0x8b, 0x85, 0x07, 0xbd, 0xa1, 0x06, 0x0a, 0x0a, 0x85, 0x02, 0xad, 0x1f, + 0x07, 0x29, 0x01, 0x49, 0x01, 0x0a, 0x65, 0x02, 0xa8, 0xa6, 0x00, 0xb1, + 0x06, 0x9d, 0x44, 0x03, 0xc8, 0xb1, 0x06, 0x9d, 0x45, 0x03, 0xa4, 0x04, + 0xa5, 0x05, 0xd0, 0x0e, 0xa5, 0x01, 0x4a, 0xb0, 0x19, 0x26, 0x03, 0x26, + 0x03, 0x26, 0x03, 0x4c, 0x30, 0x89, 0xa5, 0x01, 0x4a, 0xb0, 0x0f, 0x46, + 0x03, 0x46, 0x03, 0x46, 0x03, 0x46, 0x03, 0x4c, 0x30, 0x89, 0x46, 0x03, + 0x46, 0x03, 0xe6, 0x04, 0xb9, 0xf9, 0x03, 0x05, 0x03, 0x99, 0xf9, 0x03, + 0xe6, 0x00, 0xe6, 0x00, 0xa6, 0x01, 0xe8, 0xe0, 0x0d, 0x90, 0x8d, 0xa4, + 0x00, 0xc8, 0xc8, 0xc8, 0xa9, 0x00, 0x99, 0x41, 0x03, 0x8c, 0x40, 0x03, + 0xee, 0x21, 0x07, 0xad, 0x21, 0x07, 0x29, 0x1f, 0xd0, 0x0d, 0xa9, 0x80, + 0x8d, 0x21, 0x07, 0xad, 0x20, 0x07, 0x49, 0x04, 0x8d, 0x20, 0x07, 0x4c, + 0xbd, 0x89, 0xad, 0x21, 0x07, 0x29, 0x1f, 0x38, 0xe9, 0x04, 0x29, 0x1f, + 0x85, 0x01, 0xad, 0x20, 0x07, 0xb0, 0x02, 0x49, 0x04, 0x29, 0x04, 0x09, + 0x23, 0x85, 0x00, 0xa5, 0x01, 0x4a, 0x4a, 0x69, 0xc0, 0x85, 0x01, 0xa2, + 0x00, 0xac, 0x40, 0x03, 0xa5, 0x00, 0x99, 0x41, 0x03, 0xa5, 0x01, 0x18, + 0x69, 0x08, 0x99, 0x42, 0x03, 0x85, 0x01, 0xbd, 0xf9, 0x03, 0x99, 0x44, + 0x03, 0xa9, 0x01, 0x99, 0x43, 0x03, 0x4a, 0x9d, 0xf9, 0x03, 0xc8, 0xc8, + 0xc8, 0xc8, 0xe8, 0xe0, 0x07, 0x90, 0xd9, 0x99, 0x41, 0x03, 0x8c, 0x40, + 0x03, 0xa9, 0x06, 0x8d, 0x73, 0x07, 0x60, 0x27, 0x27, 0x27, 0x17, 0x07, + 0x17, 0x3f, 0x0c, 0x04, 0xff, 0xff, 0xff, 0xff, 0x00, 0x0f, 0x07, 0x12, + 0x0f, 0x0f, 0x07, 0x17, 0x0f, 0x0f, 0x07, 0x17, 0x1c, 0x0f, 0x07, 0x17, + 0x00, 0xa5, 0x09, 0x29, 0x07, 0xd0, 0x51, 0xae, 0x00, 0x03, 0xe0, 0x31, + 0xb0, 0x4a, 0xa8, 0xb9, 0xc9, 0x89, 0x9d, 0x01, 0x03, 0xe8, 0xc8, 0xc0, + 0x08, 0x90, 0xf4, 0xae, 0x00, 0x03, 0xa9, 0x03, 0x85, 0x00, 0xad, 0x4e, + 0x07, 0x0a, 0x0a, 0xa8, 0xb9, 0xd1, 0x89, 0x9d, 0x04, 0x03, 0xc8, 0xe8, + 0xc6, 0x00, 0x10, 0xf4, 0xae, 0x00, 0x03, 0xac, 0xd4, 0x06, 0xb9, 0xc3, + 0x89, 0x9d, 0x05, 0x03, 0xad, 0x00, 0x03, 0x18, 0x69, 0x07, 0x8d, 0x00, + 0x03, 0xee, 0xd4, 0x06, 0xad, 0xd4, 0x06, 0xc9, 0x06, 0x90, 0x05, 0xa9, + 0x00, 0x8d, 0xd4, 0x06, 0x60, 0x45, 0x45, 0x47, 0x47, 0x47, 0x47, 0x47, + 0x47, 0x57, 0x58, 0x59, 0x5a, 0x24, 0x24, 0x24, 0x24, 0x26, 0x26, 0x26, + 0x26, 0xa0, 0x41, 0xa9, 0x03, 0xae, 0x4e, 0x07, 0xd0, 0x02, 0xa9, 0x04, + 0x20, 0x97, 0x8a, 0xa9, 0x06, 0x8d, 0x73, 0x07, 0x60, 0x20, 0x6d, 0x8a, + 0xee, 0xf0, 0x03, 0xde, 0xec, 0x03, 0x60, 0xa9, 0x00, 0xa0, 0x03, 0xc9, + 0x00, 0xf0, 0x14, 0xa0, 0x00, 0xc9, 0x58, 0xf0, 0x0e, 0xc9, 0x51, 0xf0, + 0x0a, 0xc8, 0xc9, 0x5d, 0xf0, 0x05, 0xc9, 0x52, 0xf0, 0x01, 0xc8, 0x98, + 0xac, 0x00, 0x03, 0xc8, 0x20, 0x97, 0x8a, 0x88, 0x98, 0x18, 0x69, 0x0a, + 0x4c, 0x3f, 0x86, 0x86, 0x00, 0x84, 0x01, 0x0a, 0x0a, 0xaa, 0xa0, 0x20, + 0xa5, 0x06, 0xc9, 0xd0, 0x90, 0x02, 0xa0, 0x24, 0x84, 0x03, 0x29, 0x0f, + 0x0a, 0x85, 0x04, 0xa9, 0x00, 0x85, 0x05, 0xa5, 0x02, 0x18, 0x69, 0x20, + 0x0a, 0x26, 0x05, 0x0a, 0x26, 0x05, 0x65, 0x04, 0x85, 0x04, 0xa5, 0x05, + 0x69, 0x00, 0x18, 0x65, 0x03, 0x85, 0x05, 0xa4, 0x01, 0xbd, 0x39, 0x8a, + 0x99, 0x03, 0x03, 0xbd, 0x3a, 0x8a, 0x99, 0x04, 0x03, 0xbd, 0x3b, 0x8a, + 0x99, 0x08, 0x03, 0xbd, 0x3c, 0x8a, 0x99, 0x09, 0x03, 0xa5, 0x04, 0x99, + 0x01, 0x03, 0x18, 0x69, 0x20, 0x99, 0x06, 0x03, 0xa5, 0x05, 0x99, 0x00, + 0x03, 0x99, 0x05, 0x03, 0xa9, 0x02, 0x99, 0x02, 0x03, 0x99, 0x07, 0x03, + 0xa9, 0x00, 0x99, 0x0a, 0x03, 0xa6, 0x00, 0x60, 0x10, 0xac, 0x64, 0x8c, + 0x8b, 0x8b, 0x8c, 0x8c, 0x24, 0x24, 0x24, 0x24, 0x27, 0x27, 0x27, 0x27, + 0x24, 0x24, 0x24, 0x35, 0x36, 0x25, 0x37, 0x25, 0x24, 0x38, 0x24, 0x24, + 0x24, 0x30, 0x30, 0x26, 0x26, 0x26, 0x34, 0x26, 0x24, 0x31, 0x24, 0x32, + 0x33, 0x26, 0x24, 0x33, 0x34, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, + 0x24, 0xc0, 0x24, 0xc0, 0x24, 0x7f, 0x7f, 0x24, 0xb8, 0xba, 0xb9, 0xbb, + 0xb8, 0xbc, 0xb9, 0xbd, 0xba, 0xbc, 0xbb, 0xbd, 0x60, 0x64, 0x61, 0x65, + 0x62, 0x66, 0x63, 0x67, 0x60, 0x64, 0x61, 0x65, 0x62, 0x66, 0x63, 0x67, + 0x68, 0x68, 0x69, 0x69, 0x26, 0x26, 0x6a, 0x6a, 0x4b, 0x4c, 0x4d, 0x4e, + 0x4d, 0x4f, 0x4d, 0x4f, 0x4d, 0x4e, 0x50, 0x51, 0x6b, 0x70, 0x2c, 0x2d, + 0x6c, 0x71, 0x6d, 0x72, 0x6e, 0x73, 0x6f, 0x74, 0x86, 0x8a, 0x87, 0x8b, + 0x88, 0x8c, 0x88, 0x8c, 0x89, 0x8d, 0x69, 0x69, 0x8e, 0x91, 0x8f, 0x92, + 0x26, 0x93, 0x26, 0x93, 0x90, 0x94, 0x69, 0x69, 0xa4, 0xe9, 0xea, 0xeb, + 0x24, 0x24, 0x24, 0x24, 0x24, 0x2f, 0x24, 0x3d, 0xa2, 0xa2, 0xa3, 0xa3, + 0x24, 0x24, 0x24, 0x24, 0xa2, 0xa2, 0xa3, 0xa3, 0x99, 0x24, 0x99, 0x24, + 0x24, 0xa2, 0x3e, 0x3f, 0x5b, 0x5c, 0x24, 0xa3, 0x24, 0x24, 0x24, 0x24, + 0x9d, 0x47, 0x9e, 0x47, 0x47, 0x47, 0x27, 0x27, 0x47, 0x47, 0x47, 0x47, + 0x27, 0x27, 0x47, 0x47, 0xa9, 0x47, 0xaa, 0x47, 0x9b, 0x27, 0x9c, 0x27, + 0x27, 0x27, 0x27, 0x27, 0x52, 0x52, 0x52, 0x52, 0x80, 0xa0, 0x81, 0xa1, + 0xbe, 0xbe, 0xbf, 0xbf, 0x75, 0xba, 0x76, 0xbb, 0xba, 0xba, 0xbb, 0xbb, + 0x45, 0x47, 0x45, 0x47, 0x47, 0x47, 0x47, 0x47, 0x45, 0x47, 0x45, 0x47, + 0xb4, 0xb6, 0xb5, 0xb7, 0x45, 0x47, 0x45, 0x47, 0x45, 0x47, 0x45, 0x47, + 0x45, 0x47, 0x45, 0x47, 0x45, 0x47, 0x45, 0x47, 0x45, 0x47, 0x45, 0x47, + 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, + 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, 0x24, 0x24, 0x24, 0x24, + 0x24, 0x24, 0x24, 0x24, 0xab, 0xac, 0xad, 0xae, 0x5d, 0x5e, 0x5d, 0x5e, + 0xc1, 0x24, 0xc1, 0x24, 0xc6, 0xc8, 0xc7, 0xc9, 0xca, 0xcc, 0xcb, 0xcd, + 0x2a, 0x2a, 0x40, 0x40, 0x24, 0x24, 0x24, 0x24, 0x24, 0x47, 0x24, 0x47, + 0x82, 0x83, 0x84, 0x85, 0x24, 0x47, 0x24, 0x47, 0x86, 0x8a, 0x87, 0x8b, + 0x8e, 0x91, 0x8f, 0x92, 0x24, 0x2f, 0x24, 0x3d, 0x24, 0x24, 0x24, 0x35, + 0x36, 0x25, 0x37, 0x25, 0x24, 0x38, 0x24, 0x24, 0x24, 0x24, 0x39, 0x24, + 0x3a, 0x24, 0x3b, 0x24, 0x3c, 0x24, 0x24, 0x24, 0x41, 0x26, 0x41, 0x26, + 0x26, 0x26, 0x26, 0x26, 0xb0, 0xb1, 0xb2, 0xb3, 0x77, 0x79, 0x77, 0x79, + 0x53, 0x55, 0x54, 0x56, 0x53, 0x55, 0x54, 0x56, 0xa5, 0xa7, 0xa6, 0xa8, + 0xc2, 0xc4, 0xc3, 0xc5, 0x57, 0x59, 0x58, 0x5a, 0x7b, 0x7d, 0x7c, 0x7e, + 0x3f, 0x00, 0x20, 0x0f, 0x15, 0x12, 0x25, 0x0f, 0x3a, 0x1a, 0x0f, 0x0f, + 0x30, 0x12, 0x0f, 0x0f, 0x27, 0x12, 0x0f, 0x22, 0x16, 0x27, 0x18, 0x0f, + 0x10, 0x30, 0x27, 0x0f, 0x16, 0x30, 0x27, 0x0f, 0x0f, 0x30, 0x10, 0x00, + 0x3f, 0x00, 0x20, 0x0f, 0x29, 0x1a, 0x0f, 0x0f, 0x36, 0x17, 0x0f, 0x0f, + 0x30, 0x21, 0x0f, 0x0f, 0x27, 0x17, 0x0f, 0x0f, 0x16, 0x27, 0x18, 0x0f, + 0x1a, 0x30, 0x27, 0x0f, 0x16, 0x30, 0x27, 0x0f, 0x0f, 0x36, 0x17, 0x00, + 0x3f, 0x00, 0x20, 0x0f, 0x29, 0x1a, 0x09, 0x0f, 0x3c, 0x1c, 0x0f, 0x0f, + 0x30, 0x21, 0x1c, 0x0f, 0x27, 0x17, 0x1c, 0x0f, 0x16, 0x27, 0x18, 0x0f, + 0x1c, 0x36, 0x17, 0x0f, 0x16, 0x30, 0x27, 0x0f, 0x0c, 0x3c, 0x1c, 0x00, + 0x3f, 0x00, 0x20, 0x0f, 0x30, 0x10, 0x00, 0x0f, 0x30, 0x10, 0x00, 0x0f, + 0x30, 0x16, 0x00, 0x0f, 0x27, 0x17, 0x00, 0x0f, 0x16, 0x27, 0x18, 0x0f, + 0x1c, 0x36, 0x17, 0x0f, 0x16, 0x30, 0x27, 0x0f, 0x00, 0x30, 0x10, 0x00, + 0x3f, 0x00, 0x04, 0x22, 0x30, 0x00, 0x10, 0x00, 0x3f, 0x00, 0x04, 0x0f, + 0x30, 0x00, 0x10, 0x00, 0x3f, 0x00, 0x04, 0x22, 0x27, 0x16, 0x0f, 0x00, + 0x3f, 0x14, 0x04, 0x0f, 0x1a, 0x30, 0x27, 0x00, 0x25, 0x48, 0x10, 0x1d, + 0x11, 0x0a, 0x17, 0x14, 0x24, 0x22, 0x18, 0x1e, 0x24, 0x16, 0x0a, 0x1b, + 0x12, 0x18, 0x2b, 0x00, 0x25, 0x48, 0x10, 0x1d, 0x11, 0x0a, 0x17, 0x14, + 0x24, 0x22, 0x18, 0x1e, 0x24, 0x15, 0x1e, 0x12, 0x10, 0x12, 0x2b, 0x00, + 0x25, 0xc5, 0x16, 0x0b, 0x1e, 0x1d, 0x24, 0x18, 0x1e, 0x1b, 0x24, 0x19, + 0x1b, 0x12, 0x17, 0x0c, 0x0e, 0x1c, 0x1c, 0x24, 0x12, 0x1c, 0x24, 0x12, + 0x17, 0x26, 0x05, 0x0f, 0x0a, 0x17, 0x18, 0x1d, 0x11, 0x0e, 0x1b, 0x24, + 0x0c, 0x0a, 0x1c, 0x1d, 0x15, 0x0e, 0x2b, 0x00, 0x25, 0xa7, 0x13, 0x22, + 0x18, 0x1e, 0x1b, 0x24, 0x1a, 0x1e, 0x0e, 0x1c, 0x1d, 0x24, 0x12, 0x1c, + 0x24, 0x18, 0x1f, 0x0e, 0x1b, 0xaf, 0x00, 0x25, 0xe3, 0x1b, 0x20, 0x0e, + 0x24, 0x19, 0x1b, 0x0e, 0x1c, 0x0e, 0x17, 0x1d, 0x24, 0x22, 0x18, 0x1e, + 0x24, 0x0a, 0x24, 0x17, 0x0e, 0x20, 0x24, 0x1a, 0x1e, 0x0e, 0x1c, 0x1d, + 0xaf, 0x00, 0x26, 0x4a, 0x0d, 0x19, 0x1e, 0x1c, 0x11, 0x24, 0x0b, 0x1e, + 0x1d, 0x1d, 0x18, 0x17, 0x24, 0x0b, 0x00, 0x26, 0x88, 0x11, 0x1d, 0x18, + 0x24, 0x1c, 0x0e, 0x15, 0x0e, 0x0c, 0x1d, 0x24, 0x0a, 0x24, 0x20, 0x18, + 0x1b, 0x15, 0x0d, 0x00, 0x0a, 0xa8, 0x68, 0x85, 0x04, 0x68, 0x85, 0x05, + 0xc8, 0xb1, 0x04, 0x85, 0x06, 0xc8, 0xb1, 0x04, 0x85, 0x07, 0x6c, 0x06, + 0x00, 0xad, 0x02, 0x20, 0xad, 0x78, 0x07, 0x09, 0x10, 0x29, 0xf0, 0x20, + 0xed, 0x8e, 0xa9, 0x24, 0x20, 0x2d, 0x8e, 0xa9, 0x20, 0x8d, 0x06, 0x20, + 0xa9, 0x00, 0x8d, 0x06, 0x20, 0xa2, 0x04, 0xa0, 0xc0, 0xa9, 0x24, 0x8d, + 0x07, 0x20, 0x88, 0xd0, 0xfa, 0xca, 0xd0, 0xf7, 0xa0, 0x40, 0x8a, 0x8d, + 0x00, 0x03, 0x8d, 0x01, 0x03, 0x8d, 0x07, 0x20, 0x88, 0xd0, 0xfa, 0x8d, + 0x3f, 0x07, 0x8d, 0x40, 0x07, 0x4c, 0xe6, 0x8e, 0xa9, 0x01, 0x8d, 0x16, + 0x40, 0x4a, 0xaa, 0x8d, 0x16, 0x40, 0x20, 0x6a, 0x8e, 0xe8, 0xa0, 0x08, + 0x48, 0xbd, 0x16, 0x40, 0x85, 0x00, 0x4a, 0x05, 0x00, 0x4a, 0x68, 0x2a, + 0x88, 0xd0, 0xf1, 0x9d, 0xfc, 0x06, 0x48, 0x29, 0x30, 0x3d, 0x4a, 0x07, + 0xf0, 0x07, 0x68, 0x29, 0xcf, 0x9d, 0xfc, 0x06, 0x60, 0x68, 0x9d, 0x4a, + 0x07, 0x60, 0x8d, 0x06, 0x20, 0xc8, 0xb1, 0x00, 0x8d, 0x06, 0x20, 0xc8, + 0xb1, 0x00, 0x0a, 0x48, 0xad, 0x78, 0x07, 0x09, 0x04, 0xb0, 0x02, 0x29, + 0xfb, 0x20, 0xed, 0x8e, 0x68, 0x0a, 0x90, 0x03, 0x09, 0x02, 0xc8, 0x4a, + 0x4a, 0xaa, 0xb0, 0x01, 0xc8, 0xb1, 0x00, 0x8d, 0x07, 0x20, 0xca, 0xd0, + 0xf5, 0x38, 0x98, 0x65, 0x00, 0x85, 0x00, 0xa9, 0x00, 0x65, 0x01, 0x85, + 0x01, 0xa9, 0x3f, 0x8d, 0x06, 0x20, 0xa9, 0x00, 0x8d, 0x06, 0x20, 0x8d, + 0x06, 0x20, 0x8d, 0x06, 0x20, 0xae, 0x02, 0x20, 0xa0, 0x00, 0xb1, 0x00, + 0xd0, 0xac, 0x8d, 0x05, 0x20, 0x8d, 0x05, 0x20, 0x60, 0x8d, 0x00, 0x20, + 0x8d, 0x78, 0x07, 0x60, 0xf0, 0x06, 0x62, 0x06, 0x62, 0x06, 0x6d, 0x02, + 0x6d, 0x02, 0x7a, 0x03, 0x06, 0x0c, 0x12, 0x18, 0x1e, 0x24, 0x85, 0x00, + 0x20, 0x11, 0x8f, 0xa5, 0x00, 0x4a, 0x4a, 0x4a, 0x4a, 0x18, 0x69, 0x01, + 0x29, 0x0f, 0xc9, 0x06, 0xb0, 0x44, 0x48, 0x0a, 0xa8, 0xae, 0x00, 0x03, + 0xa9, 0x20, 0xc0, 0x00, 0xd0, 0x02, 0xa9, 0x22, 0x9d, 0x01, 0x03, 0xb9, + 0xf4, 0x8e, 0x9d, 0x02, 0x03, 0xb9, 0xf5, 0x8e, 0x9d, 0x03, 0x03, 0x85, + 0x03, 0x86, 0x02, 0x68, 0xaa, 0xbd, 0x00, 0x8f, 0x38, 0xf9, 0xf5, 0x8e, + 0xa8, 0xa6, 0x02, 0xb9, 0xd7, 0x07, 0x9d, 0x04, 0x03, 0xe8, 0xc8, 0xc6, + 0x03, 0xd0, 0xf4, 0xa9, 0x00, 0x9d, 0x04, 0x03, 0xe8, 0xe8, 0xe8, 0x8e, + 0x00, 0x03, 0x60, 0xad, 0x70, 0x07, 0xc9, 0x00, 0xf0, 0x16, 0xa2, 0x05, + 0xbd, 0x34, 0x01, 0x18, 0x79, 0xd7, 0x07, 0x30, 0x16, 0xc9, 0x0a, 0xb0, + 0x19, 0x99, 0xd7, 0x07, 0x88, 0xca, 0x10, 0xec, 0xa9, 0x00, 0xa2, 0x06, + 0x9d, 0x33, 0x01, 0xca, 0x10, 0xfa, 0x60, 0xde, 0x33, 0x01, 0xa9, 0x09, + 0xd0, 0xe7, 0x38, 0xe9, 0x0a, 0xfe, 0x33, 0x01, 0x4c, 0x75, 0x8f, 0xa2, + 0x05, 0x20, 0x9e, 0x8f, 0xa2, 0x0b, 0xa0, 0x05, 0x38, 0xbd, 0xdd, 0x07, + 0xf9, 0xd7, 0x07, 0xca, 0x88, 0x10, 0xf6, 0x90, 0x0e, 0xe8, 0xc8, 0xbd, + 0xdd, 0x07, 0x99, 0xd7, 0x07, 0xe8, 0xc8, 0xc0, 0x06, 0x90, 0xf4, 0x60, + 0x04, 0x30, 0x48, 0x60, 0x78, 0x90, 0xa8, 0xc0, 0xd8, 0xe8, 0x24, 0xf8, + 0xfc, 0x28, 0x2c, 0x18, 0xff, 0x23, 0x58, 0xa0, 0x6f, 0x20, 0xcc, 0x90, + 0xa0, 0x1f, 0x99, 0xb0, 0x07, 0x88, 0x10, 0xfa, 0xa9, 0x18, 0x8d, 0xa2, + 0x07, 0x20, 0x03, 0x9c, 0xa0, 0x4b, 0x20, 0xcc, 0x90, 0xa2, 0x21, 0xa9, + 0x00, 0x9d, 0x80, 0x07, 0xca, 0x10, 0xfa, 0xad, 0x5b, 0x07, 0xac, 0x52, + 0x07, 0xf0, 0x03, 0xad, 0x51, 0x07, 0x8d, 0x1a, 0x07, 0x8d, 0x25, 0x07, + 0x8d, 0x28, 0x07, 0x20, 0x38, 0xb0, 0xa0, 0x20, 0x29, 0x01, 0xf0, 0x02, + 0xa0, 0x24, 0x8c, 0x20, 0x07, 0xa0, 0x80, 0x8c, 0x21, 0x07, 0x0a, 0x0a, + 0x0a, 0x0a, 0x8d, 0xa0, 0x06, 0xce, 0x30, 0x07, 0xce, 0x31, 0x07, 0xce, + 0x32, 0x07, 0xa9, 0x0b, 0x8d, 0x1e, 0x07, 0x20, 0x22, 0x9c, 0xad, 0x6a, + 0x07, 0xd0, 0x10, 0xad, 0x5f, 0x07, 0xc9, 0x04, 0x90, 0x0c, 0xd0, 0x07, + 0xad, 0x5c, 0x07, 0xc9, 0x02, 0x90, 0x03, 0xee, 0xcc, 0x06, 0xad, 0x5b, + 0x07, 0xf0, 0x05, 0xa9, 0x02, 0x8d, 0x10, 0x07, 0xa9, 0x80, 0x85, 0xfb, + 0xa9, 0x01, 0x8d, 0x74, 0x07, 0xee, 0x72, 0x07, 0x60, 0xa9, 0x01, 0x8d, + 0x57, 0x07, 0x8d, 0x54, 0x07, 0xa9, 0x02, 0x8d, 0x5a, 0x07, 0x8d, 0x61, + 0x07, 0xa9, 0x00, 0x8d, 0x74, 0x07, 0xa8, 0x99, 0x00, 0x03, 0xc8, 0xd0, + 0xfa, 0x8d, 0x59, 0x07, 0x8d, 0x69, 0x07, 0x8d, 0x28, 0x07, 0xa9, 0xff, + 0x8d, 0xa0, 0x03, 0xad, 0x1a, 0x07, 0x4e, 0x78, 0x07, 0x29, 0x01, 0x6a, + 0x2e, 0x78, 0x07, 0x20, 0xed, 0x90, 0xa9, 0x38, 0x8d, 0xe3, 0x06, 0xa9, + 0x48, 0x8d, 0xe2, 0x06, 0xa9, 0x58, 0x8d, 0xe1, 0x06, 0xa2, 0x0e, 0xbd, + 0xbc, 0x8f, 0x9d, 0xe4, 0x06, 0xca, 0x10, 0xf7, 0xa0, 0x03, 0xb9, 0xcb, + 0x8f, 0x99, 0x00, 0x02, 0x88, 0x10, 0xf7, 0x20, 0xaf, 0x92, 0x20, 0xaa, + 0x92, 0xee, 0x22, 0x07, 0xee, 0x72, 0x07, 0x60, 0xa2, 0x07, 0xa9, 0x00, + 0x85, 0x06, 0x86, 0x07, 0xe0, 0x01, 0xd0, 0x04, 0xc0, 0x60, 0xb0, 0x02, + 0x91, 0x06, 0x88, 0xc0, 0xff, 0xd0, 0xf1, 0xca, 0x10, 0xec, 0x60, 0x02, + 0x01, 0x04, 0x08, 0x10, 0x20, 0xad, 0x70, 0x07, 0xf0, 0x23, 0xad, 0x52, + 0x07, 0xc9, 0x02, 0xf0, 0x0d, 0xa0, 0x05, 0xad, 0x10, 0x07, 0xc9, 0x06, + 0xf0, 0x0e, 0xc9, 0x07, 0xf0, 0x0a, 0xac, 0x4e, 0x07, 0xad, 0x43, 0x07, + 0xf0, 0x02, 0xa0, 0x04, 0xb9, 0xe7, 0x90, 0x85, 0xfb, 0x60, 0x28, 0x18, + 0x38, 0x28, 0x08, 0x00, 0x00, 0x20, 0xb0, 0x50, 0x00, 0x00, 0xb0, 0xb0, + 0xf0, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x04, 0x03, + 0x02, 0xad, 0x1a, 0x07, 0x85, 0x6d, 0xa9, 0x28, 0x8d, 0x0a, 0x07, 0xa9, + 0x01, 0x85, 0x33, 0x85, 0xb5, 0xa9, 0x00, 0x85, 0x1d, 0xce, 0x90, 0x04, + 0xa0, 0x00, 0x8c, 0x5b, 0x07, 0xad, 0x4e, 0x07, 0xd0, 0x01, 0xc8, 0x8c, + 0x04, 0x07, 0xae, 0x10, 0x07, 0xac, 0x52, 0x07, 0xf0, 0x07, 0xc0, 0x01, + 0xf0, 0x03, 0xbe, 0x18, 0x91, 0xb9, 0x16, 0x91, 0x85, 0x86, 0xbd, 0x1c, + 0x91, 0x85, 0xce, 0xbd, 0x25, 0x91, 0x8d, 0xc4, 0x03, 0x20, 0xf1, 0x85, + 0xac, 0x15, 0x07, 0xf0, 0x1a, 0xad, 0x57, 0x07, 0xf0, 0x15, 0xb9, 0x2d, + 0x91, 0x8d, 0xf8, 0x07, 0xa9, 0x01, 0x8d, 0xfa, 0x07, 0x4a, 0x8d, 0xf9, + 0x07, 0x8d, 0x57, 0x07, 0x8d, 0x9f, 0x07, 0xac, 0x58, 0x07, 0xf0, 0x14, + 0xa9, 0x03, 0x85, 0x1d, 0xa2, 0x00, 0x20, 0x84, 0xbd, 0xa9, 0xf0, 0x85, + 0xd7, 0xa2, 0x05, 0xa0, 0x00, 0x20, 0x1e, 0xb9, 0xac, 0x4e, 0x07, 0xd0, + 0x03, 0x20, 0x0b, 0xb7, 0xa9, 0x07, 0x85, 0x0e, 0x60, 0x56, 0x40, 0x65, + 0x70, 0x66, 0x40, 0x66, 0x40, 0x66, 0x40, 0x66, 0x60, 0x65, 0x70, 0x00, + 0x00, 0xee, 0x74, 0x07, 0xa9, 0x00, 0x8d, 0x22, 0x07, 0xa9, 0x80, 0x85, + 0xfc, 0xce, 0x5a, 0x07, 0x10, 0x0b, 0xa9, 0x00, 0x8d, 0x72, 0x07, 0xa9, + 0x03, 0x8d, 0x70, 0x07, 0x60, 0xad, 0x5f, 0x07, 0x0a, 0xaa, 0xad, 0x5c, + 0x07, 0x29, 0x02, 0xf0, 0x01, 0xe8, 0xbc, 0xbd, 0x91, 0xad, 0x5c, 0x07, + 0x4a, 0x98, 0xb0, 0x04, 0x4a, 0x4a, 0x4a, 0x4a, 0x29, 0x0f, 0xcd, 0x1a, + 0x07, 0xf0, 0x04, 0x90, 0x02, 0xa9, 0x00, 0x8d, 0x5b, 0x07, 0x20, 0x82, + 0x92, 0x4c, 0x64, 0x92, 0xad, 0x72, 0x07, 0x20, 0x04, 0x8e, 0x24, 0x92, + 0x67, 0x85, 0x37, 0x92, 0xa9, 0x00, 0x8d, 0x3c, 0x07, 0x8d, 0x22, 0x07, + 0xa9, 0x02, 0x85, 0xfc, 0xee, 0x74, 0x07, 0xee, 0x72, 0x07, 0x60, 0xa9, + 0x00, 0x8d, 0x74, 0x07, 0xad, 0xfc, 0x06, 0x29, 0x10, 0xd0, 0x05, 0xad, + 0xa0, 0x07, 0xd0, 0x39, 0xa9, 0x80, 0x85, 0xfc, 0x20, 0x82, 0x92, 0x90, + 0x13, 0xad, 0x5f, 0x07, 0x8d, 0xfd, 0x07, 0xa9, 0x00, 0x0a, 0x8d, 0x72, + 0x07, 0x8d, 0xa0, 0x07, 0x8d, 0x70, 0x07, 0x60, 0x20, 0x03, 0x9c, 0xa9, + 0x01, 0x8d, 0x54, 0x07, 0xee, 0x57, 0x07, 0xa9, 0x00, 0x8d, 0x47, 0x07, + 0x8d, 0x56, 0x07, 0x85, 0x0e, 0x8d, 0x72, 0x07, 0xa9, 0x01, 0x8d, 0x70, + 0x07, 0x60, 0x38, 0xad, 0x7a, 0x07, 0xf0, 0x21, 0xad, 0x61, 0x07, 0x30, + 0x1c, 0xad, 0x53, 0x07, 0x49, 0x01, 0x8d, 0x53, 0x07, 0xa2, 0x06, 0xbd, + 0x5a, 0x07, 0x48, 0xbd, 0x61, 0x07, 0x9d, 0x5a, 0x07, 0x68, 0x9d, 0x61, + 0x07, 0xca, 0x10, 0xef, 0x18, 0x60, 0xa9, 0xff, 0x8d, 0xc9, 0x06, 0x60, + 0xac, 0x1f, 0x07, 0xd0, 0x05, 0xa0, 0x08, 0x8c, 0x1f, 0x07, 0x88, 0x98, + 0x20, 0xc8, 0x92, 0xce, 0x1f, 0x07, 0xd0, 0x03, 0x20, 0x6a, 0x89, 0x60, + 0x20, 0x04, 0x8e, 0xdb, 0x92, 0xae, 0x88, 0xae, 0x88, 0xfc, 0x93, 0xdb, + 0x92, 0xae, 0x88, 0xae, 0x88, 0xfc, 0x93, 0xee, 0x26, 0x07, 0xad, 0x26, + 0x07, 0x29, 0x0f, 0xd0, 0x06, 0x8d, 0x26, 0x07, 0xee, 0x25, 0x07, 0xee, + 0xa0, 0x06, 0xad, 0xa0, 0x06, 0x29, 0x1f, 0x8d, 0xa0, 0x06, 0x60, 0x00, + 0x30, 0x60, 0x93, 0x00, 0x00, 0x11, 0x12, 0x12, 0x13, 0x00, 0x00, 0x51, + 0x52, 0x53, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x91, 0x92, 0x93, 0x00, 0x00, 0x00, + 0x00, 0x51, 0x52, 0x53, 0x41, 0x42, 0x43, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x91, 0x92, 0x97, 0x87, 0x88, 0x89, 0x99, 0x00, 0x00, 0x00, 0x11, 0x12, + 0x13, 0xa4, 0xa5, 0xa5, 0xa5, 0xa6, 0x97, 0x98, 0x99, 0x01, 0x02, 0x03, + 0x00, 0xa4, 0xa5, 0xa6, 0x00, 0x11, 0x12, 0x12, 0x12, 0x13, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x02, 0x02, 0x03, 0x00, 0xa4, 0xa5, 0xa5, 0xa6, 0x00, + 0x00, 0x00, 0x11, 0x12, 0x12, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x9c, 0x00, 0x8b, 0xaa, 0xaa, 0xaa, 0xaa, 0x11, 0x12, 0x13, 0x8b, + 0x00, 0x9c, 0x9c, 0x00, 0x00, 0x01, 0x02, 0x03, 0x11, 0x12, 0x12, 0x13, + 0x00, 0x00, 0x00, 0x00, 0xaa, 0xaa, 0x9c, 0xaa, 0x00, 0x8b, 0x00, 0x01, + 0x02, 0x03, 0x80, 0x83, 0x00, 0x81, 0x84, 0x00, 0x82, 0x85, 0x00, 0x02, + 0x00, 0x00, 0x03, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07, + 0x06, 0x0a, 0x00, 0x08, 0x09, 0x4d, 0x00, 0x00, 0x0d, 0x0f, 0x4e, 0x0e, + 0x4e, 0x4e, 0x00, 0x0d, 0x1a, 0x86, 0x87, 0x87, 0x87, 0x87, 0x87, 0x87, + 0x87, 0x87, 0x87, 0x87, 0x69, 0x69, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, + 0x47, 0x47, 0x47, 0x47, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86, 0x87, 0x69, 0x54, 0x52, 0x62, + 0x00, 0x00, 0x00, 0x18, 0x01, 0x18, 0x07, 0x18, 0x0f, 0x18, 0xff, 0x18, + 0x01, 0x1f, 0x07, 0x1f, 0x0f, 0x1f, 0x81, 0x1f, 0x01, 0x00, 0x8f, 0x1f, + 0xf1, 0x1f, 0xf9, 0x18, 0xf1, 0x18, 0xff, 0x1f, 0xad, 0x28, 0x07, 0xf0, + 0x03, 0x20, 0x08, 0x95, 0xa2, 0x0c, 0xa9, 0x00, 0x9d, 0xa1, 0x06, 0xca, + 0x10, 0xfa, 0xac, 0x42, 0x07, 0xf0, 0x42, 0xad, 0x25, 0x07, 0xc9, 0x03, + 0x30, 0x05, 0x38, 0xe9, 0x03, 0x10, 0xf7, 0x0a, 0x0a, 0x0a, 0x0a, 0x79, + 0xf6, 0x92, 0x6d, 0x26, 0x07, 0xaa, 0xbd, 0xfa, 0x92, 0xf0, 0x26, 0x48, + 0x29, 0x0f, 0x38, 0xe9, 0x01, 0x85, 0x00, 0x0a, 0x65, 0x00, 0xaa, 0x68, + 0x4a, 0x4a, 0x4a, 0x4a, 0xa8, 0xa9, 0x03, 0x85, 0x00, 0xbd, 0x8a, 0x93, + 0x99, 0xa1, 0x06, 0xe8, 0xc8, 0xc0, 0x0b, 0xf0, 0x04, 0xc6, 0x00, 0xd0, + 0xf0, 0xae, 0x41, 0x07, 0xf0, 0x13, 0xbc, 0xad, 0x93, 0xa2, 0x00, 0xb9, + 0xb1, 0x93, 0xf0, 0x03, 0x9d, 0xa1, 0x06, 0xc8, 0xe8, 0xe0, 0x0d, 0xd0, + 0xf2, 0xac, 0x4e, 0x07, 0xd0, 0x0c, 0xad, 0x5f, 0x07, 0xc9, 0x07, 0xd0, + 0x05, 0xa9, 0x62, 0x4c, 0x88, 0x94, 0xb9, 0xd8, 0x93, 0xac, 0x43, 0x07, + 0xf0, 0x02, 0xa9, 0x88, 0x85, 0x07, 0xa2, 0x00, 0xad, 0x27, 0x07, 0x0a, + 0xa8, 0xb9, 0xdc, 0x93, 0x85, 0x00, 0xc8, 0x84, 0x01, 0xad, 0x43, 0x07, + 0xf0, 0x0a, 0xe0, 0x00, 0xf0, 0x06, 0xa5, 0x00, 0x29, 0x08, 0x85, 0x00, + 0xa0, 0x00, 0xb9, 0x8a, 0xc6, 0x24, 0x00, 0xf0, 0x05, 0xa5, 0x07, 0x9d, + 0xa1, 0x06, 0xe8, 0xe0, 0x0d, 0xf0, 0x18, 0xad, 0x4e, 0x07, 0xc9, 0x02, + 0xd0, 0x08, 0xe0, 0x0b, 0xd0, 0x04, 0xa9, 0x54, 0x85, 0x07, 0xc8, 0xc0, + 0x08, 0xd0, 0xdb, 0xa4, 0x01, 0xd0, 0xbe, 0x20, 0x08, 0x95, 0xad, 0xa0, + 0x06, 0x20, 0xe1, 0x9b, 0xa2, 0x00, 0xa0, 0x00, 0x84, 0x00, 0xbd, 0xa1, + 0x06, 0x29, 0xc0, 0x0a, 0x2a, 0x2a, 0xa8, 0xbd, 0xa1, 0x06, 0xd9, 0x04, + 0x95, 0xb0, 0x02, 0xa9, 0x00, 0xa4, 0x00, 0x91, 0x06, 0x98, 0x18, 0x69, + 0x10, 0xa8, 0xe8, 0xe0, 0x0d, 0x90, 0xdd, 0x60, 0x10, 0x51, 0x88, 0xc0, + 0xa2, 0x02, 0x86, 0x08, 0xa9, 0x00, 0x8d, 0x29, 0x07, 0xac, 0x2c, 0x07, + 0xb1, 0xe7, 0xc9, 0xfd, 0xf0, 0x4b, 0xbd, 0x30, 0x07, 0x10, 0x46, 0xc8, + 0xb1, 0xe7, 0x0a, 0x90, 0x0b, 0xad, 0x2b, 0x07, 0xd0, 0x06, 0xee, 0x2b, + 0x07, 0xee, 0x2a, 0x07, 0x88, 0xb1, 0xe7, 0x29, 0x0f, 0xc9, 0x0d, 0xd0, + 0x1b, 0xc8, 0xb1, 0xe7, 0x88, 0x29, 0x40, 0xd0, 0x1c, 0xad, 0x2b, 0x07, + 0xd0, 0x17, 0xc8, 0xb1, 0xe7, 0x29, 0x1f, 0x8d, 0x2a, 0x07, 0xee, 0x2b, + 0x07, 0x4c, 0x6e, 0x95, 0xc9, 0x0e, 0xd0, 0x05, 0xad, 0x28, 0x07, 0xd0, + 0x08, 0xad, 0x2a, 0x07, 0xcd, 0x25, 0x07, 0x90, 0x06, 0x20, 0x95, 0x95, + 0x4c, 0x71, 0x95, 0xee, 0x29, 0x07, 0x20, 0x89, 0x95, 0xa6, 0x08, 0xbd, + 0x30, 0x07, 0x30, 0x03, 0xde, 0x30, 0x07, 0xca, 0x10, 0x8c, 0xad, 0x29, + 0x07, 0xd0, 0x85, 0xad, 0x28, 0x07, 0xd0, 0x80, 0x60, 0xee, 0x2c, 0x07, + 0xee, 0x2c, 0x07, 0xa9, 0x00, 0x8d, 0x2b, 0x07, 0x60, 0xbd, 0x30, 0x07, + 0x30, 0x03, 0xbc, 0x2d, 0x07, 0xa2, 0x10, 0xb1, 0xe7, 0xc9, 0xfd, 0xf0, + 0xe3, 0x29, 0x0f, 0xc9, 0x0f, 0xf0, 0x08, 0xa2, 0x08, 0xc9, 0x0c, 0xf0, + 0x02, 0xa2, 0x00, 0x86, 0x07, 0xa6, 0x08, 0xc9, 0x0e, 0xd0, 0x08, 0xa9, + 0x00, 0x85, 0x07, 0xa9, 0x2e, 0xd0, 0x53, 0xc9, 0x0d, 0xd0, 0x1b, 0xa9, + 0x22, 0x85, 0x07, 0xc8, 0xb1, 0xe7, 0x29, 0x40, 0xf0, 0x63, 0xb1, 0xe7, + 0x29, 0x7f, 0xc9, 0x4b, 0xd0, 0x03, 0xee, 0x45, 0x07, 0x29, 0x3f, 0x4c, + 0x16, 0x96, 0xc9, 0x0c, 0xb0, 0x27, 0xc8, 0xb1, 0xe7, 0x29, 0x70, 0xd0, + 0x0b, 0xa9, 0x16, 0x85, 0x07, 0xb1, 0xe7, 0x29, 0x0f, 0x4c, 0x16, 0x96, + 0x85, 0x00, 0xc9, 0x70, 0xd0, 0x0a, 0xb1, 0xe7, 0x29, 0x08, 0xf0, 0x04, + 0xa9, 0x00, 0x85, 0x00, 0xa5, 0x00, 0x4c, 0x12, 0x96, 0xc8, 0xb1, 0xe7, + 0x29, 0x70, 0x4a, 0x4a, 0x4a, 0x4a, 0x85, 0x00, 0xbd, 0x30, 0x07, 0x10, + 0x42, 0xad, 0x2a, 0x07, 0xcd, 0x25, 0x07, 0xf0, 0x11, 0xac, 0x2c, 0x07, + 0xb1, 0xe7, 0x29, 0x0f, 0xc9, 0x0e, 0xd0, 0x05, 0xad, 0x28, 0x07, 0xd0, + 0x21, 0x60, 0xad, 0x28, 0x07, 0xf0, 0x0b, 0xa9, 0x00, 0x8d, 0x28, 0x07, + 0x8d, 0x29, 0x07, 0x85, 0x08, 0x60, 0xac, 0x2c, 0x07, 0xb1, 0xe7, 0x29, + 0xf0, 0x4a, 0x4a, 0x4a, 0x4a, 0xcd, 0x26, 0x07, 0xd0, 0xdf, 0xad, 0x2c, + 0x07, 0x9d, 0x2d, 0x07, 0x20, 0x89, 0x95, 0xa5, 0x00, 0x18, 0x65, 0x07, + 0x20, 0x04, 0x8e, 0xe5, 0x98, 0x40, 0x97, 0x2e, 0x9a, 0x3e, 0x9a, 0xf2, + 0x99, 0x50, 0x9a, 0x59, 0x9a, 0xe5, 0x98, 0x41, 0x9b, 0xba, 0x97, 0x79, + 0x99, 0x7c, 0x99, 0x7f, 0x99, 0x57, 0x99, 0x68, 0x99, 0x6b, 0x99, 0xd0, + 0x99, 0xd7, 0x99, 0x06, 0x98, 0xb7, 0x9a, 0xab, 0x98, 0x94, 0x99, 0x0e, + 0x9b, 0x0e, 0x9b, 0x0e, 0x9b, 0x01, 0x9b, 0x19, 0x9b, 0x19, 0x9b, 0x19, + 0x9b, 0x14, 0x9b, 0x19, 0x9b, 0x6f, 0x98, 0x19, 0x9a, 0xd3, 0x9a, 0x82, + 0x98, 0x9e, 0x99, 0x09, 0x9a, 0x0e, 0x9a, 0x01, 0x9a, 0xf2, 0x96, 0x0d, + 0x97, 0x0d, 0x97, 0x2b, 0x97, 0x2b, 0x97, 0x2b, 0x97, 0x45, 0x96, 0xc5, + 0x96, 0xbc, 0x2d, 0x07, 0xc8, 0xb1, 0xe7, 0x48, 0x29, 0x40, 0xd0, 0x12, + 0x68, 0x48, 0x29, 0x0f, 0x8d, 0x27, 0x07, 0x68, 0x29, 0x30, 0x4a, 0x4a, + 0x4a, 0x4a, 0x8d, 0x42, 0x07, 0x60, 0x68, 0x29, 0x07, 0xc9, 0x04, 0x90, + 0x05, 0x8d, 0x44, 0x07, 0xa9, 0x00, 0x8d, 0x41, 0x07, 0x60, 0xa2, 0x04, + 0xad, 0x5f, 0x07, 0xf0, 0x08, 0xe8, 0xac, 0x4e, 0x07, 0x88, 0xd0, 0x01, + 0xe8, 0x8a, 0x8d, 0xd6, 0x06, 0x20, 0x08, 0x88, 0xa9, 0x0d, 0x20, 0x16, + 0x97, 0xad, 0x23, 0x07, 0x49, 0x01, 0x8d, 0x23, 0x07, 0x60, 0x85, 0x00, + 0xa9, 0x00, 0xa2, 0x04, 0xb4, 0x16, 0xc4, 0x00, 0xd0, 0x02, 0x95, 0x0f, + 0xca, 0x10, 0xf5, 0x60, 0x14, 0x17, 0x18, 0xa6, 0x00, 0xbd, 0x20, 0x97, + 0xa0, 0x05, 0x88, 0x30, 0x07, 0xd9, 0x16, 0x00, 0xd0, 0xf8, 0xa9, 0x00, + 0x8d, 0xcd, 0x06, 0x60, 0xad, 0x33, 0x07, 0x20, 0x04, 0x8e, 0x4c, 0x97, + 0x78, 0x97, 0x69, 0x9a, 0x20, 0xbb, 0x9b, 0xbd, 0x30, 0x07, 0xf0, 0x1f, + 0x10, 0x11, 0x98, 0x9d, 0x30, 0x07, 0xad, 0x25, 0x07, 0x0d, 0x26, 0x07, + 0xf0, 0x05, 0xa9, 0x16, 0x4c, 0xb0, 0x97, 0xa6, 0x07, 0xa9, 0x17, 0x9d, + 0xa1, 0x06, 0xa9, 0x4c, 0x4c, 0xaa, 0x97, 0xa9, 0x18, 0x4c, 0xb0, 0x97, + 0x20, 0xac, 0x9b, 0x84, 0x06, 0x90, 0x0c, 0xbd, 0x30, 0x07, 0x4a, 0x9d, + 0x36, 0x07, 0xa9, 0x19, 0x4c, 0xb0, 0x97, 0xa9, 0x1b, 0xbc, 0x30, 0x07, + 0xf0, 0x1e, 0xbd, 0x36, 0x07, 0x85, 0x06, 0xa6, 0x07, 0xa9, 0x1a, 0x9d, + 0xa1, 0x06, 0xc4, 0x06, 0xd0, 0x2c, 0xe8, 0xa9, 0x4f, 0x9d, 0xa1, 0x06, + 0xa9, 0x50, 0xe8, 0xa0, 0x0f, 0x4c, 0x7d, 0x9b, 0xa6, 0x07, 0xa0, 0x00, + 0x4c, 0x7d, 0x9b, 0x42, 0x41, 0x43, 0x20, 0xac, 0x9b, 0xa0, 0x00, 0xb0, + 0x07, 0xc8, 0xbd, 0x30, 0x07, 0xd0, 0x01, 0xc8, 0xb9, 0xb7, 0x97, 0x8d, + 0xa1, 0x06, 0x60, 0x00, 0x45, 0x45, 0x45, 0x00, 0x00, 0x48, 0x47, 0x46, + 0x00, 0x45, 0x49, 0x49, 0x49, 0x45, 0x47, 0x47, 0x4a, 0x47, 0x47, 0x47, + 0x47, 0x4b, 0x47, 0x47, 0x49, 0x49, 0x49, 0x49, 0x49, 0x47, 0x4a, 0x47, + 0x4a, 0x47, 0x47, 0x4b, 0x47, 0x4b, 0x47, 0x47, 0x47, 0x47, 0x47, 0x47, + 0x4a, 0x47, 0x4a, 0x47, 0x4a, 0x4b, 0x47, 0x4b, 0x47, 0x4b, 0x20, 0xbb, + 0x9b, 0x84, 0x07, 0xa0, 0x04, 0x20, 0xaf, 0x9b, 0x8a, 0x48, 0xbc, 0x30, + 0x07, 0xa6, 0x07, 0xa9, 0x0b, 0x85, 0x06, 0xb9, 0xcf, 0x97, 0x9d, 0xa1, + 0x06, 0xe8, 0xa5, 0x06, 0xf0, 0x07, 0xc8, 0xc8, 0xc8, 0xc8, 0xc8, 0xc6, + 0x06, 0xe0, 0x0b, 0xd0, 0xea, 0x68, 0xaa, 0xad, 0x25, 0x07, 0xf0, 0x36, + 0xbd, 0x30, 0x07, 0xc9, 0x01, 0xf0, 0x2a, 0xa4, 0x07, 0xd0, 0x04, 0xc9, + 0x03, 0xf0, 0x22, 0xc9, 0x02, 0xd0, 0x23, 0x20, 0xcb, 0x9b, 0x48, 0x20, + 0x4a, 0x99, 0x68, 0x95, 0x87, 0xad, 0x25, 0x07, 0x95, 0x6e, 0xa9, 0x01, + 0x95, 0xb6, 0x95, 0x0f, 0xa9, 0x90, 0x95, 0xcf, 0xa9, 0x31, 0x95, 0x16, + 0x60, 0xa0, 0x52, 0x8c, 0xab, 0x06, 0x60, 0x20, 0xbb, 0x9b, 0xbc, 0x30, + 0x07, 0xa6, 0x07, 0xa9, 0x6b, 0x9d, 0xa1, 0x06, 0xa9, 0x6c, 0x9d, 0xa2, + 0x06, 0x60, 0xa0, 0x03, 0x20, 0xaf, 0x9b, 0xa0, 0x0a, 0x20, 0xb3, 0x98, + 0xb0, 0x10, 0xa2, 0x06, 0xa9, 0x00, 0x9d, 0xa1, 0x06, 0xca, 0x10, 0xf8, + 0xb9, 0xdd, 0x98, 0x8d, 0xa8, 0x06, 0x60, 0x15, 0x14, 0x00, 0x00, 0x15, + 0x1e, 0x1d, 0x1c, 0x15, 0x21, 0x20, 0x1f, 0xa0, 0x03, 0x20, 0xaf, 0x9b, + 0x20, 0xbb, 0x9b, 0x88, 0x88, 0x84, 0x05, 0xbc, 0x30, 0x07, 0x84, 0x06, + 0xa6, 0x05, 0xe8, 0xb9, 0x9f, 0x98, 0xc9, 0x00, 0xf0, 0x08, 0xa2, 0x00, + 0xa4, 0x05, 0x20, 0x7d, 0x9b, 0x18, 0xa4, 0x06, 0xb9, 0xa3, 0x98, 0x9d, + 0xa1, 0x06, 0xb9, 0xa7, 0x98, 0x9d, 0xa2, 0x06, 0x60, 0x11, 0x10, 0x15, + 0x14, 0x13, 0x12, 0x15, 0x14, 0x20, 0x39, 0x99, 0xa5, 0x00, 0xf0, 0x04, + 0xc8, 0xc8, 0xc8, 0xc8, 0x98, 0x48, 0xad, 0x60, 0x07, 0x0d, 0x5f, 0x07, + 0xf0, 0x2b, 0xbc, 0x30, 0x07, 0xf0, 0x26, 0x20, 0x4a, 0x99, 0xb0, 0x21, + 0x20, 0xcb, 0x9b, 0x18, 0x69, 0x08, 0x95, 0x87, 0xad, 0x25, 0x07, 0x69, + 0x00, 0x95, 0x6e, 0xa9, 0x01, 0x95, 0xb6, 0x95, 0x0f, 0x20, 0xd3, 0x9b, + 0x95, 0xcf, 0xa9, 0x0d, 0x95, 0x16, 0x20, 0x87, 0xc7, 0x68, 0xa8, 0xa6, + 0x07, 0xb9, 0xdd, 0x98, 0x9d, 0xa1, 0x06, 0xe8, 0xb9, 0xdf, 0x98, 0xa4, + 0x06, 0x88, 0x4c, 0x7d, 0x9b, 0xa0, 0x01, 0x20, 0xaf, 0x9b, 0x20, 0xbb, + 0x9b, 0x98, 0x29, 0x07, 0x85, 0x06, 0xbc, 0x30, 0x07, 0x60, 0xa2, 0x00, + 0x18, 0xb5, 0x0f, 0xf0, 0x05, 0xe8, 0xe0, 0x05, 0xd0, 0xf6, 0x60, 0x20, + 0xac, 0x9b, 0xa9, 0x86, 0x8d, 0xab, 0x06, 0xa2, 0x0b, 0xa0, 0x01, 0xa9, + 0x87, 0x4c, 0x7d, 0x9b, 0xa9, 0x03, 0x2c, 0xa9, 0x07, 0x48, 0x20, 0xac, + 0x9b, 0x68, 0xaa, 0xa9, 0xc0, 0x9d, 0xa1, 0x06, 0x60, 0xa9, 0x06, 0x2c, + 0xa9, 0x07, 0x2c, 0xa9, 0x09, 0x48, 0x20, 0xac, 0x9b, 0x68, 0xaa, 0xa9, + 0x0b, 0x9d, 0xa1, 0x06, 0xe8, 0xa0, 0x00, 0xa9, 0x63, 0x4c, 0x7d, 0x9b, + 0x20, 0xbb, 0x9b, 0xa2, 0x02, 0xa9, 0x6d, 0x4c, 0x7d, 0x9b, 0xa9, 0x24, + 0x8d, 0xa1, 0x06, 0xa2, 0x01, 0xa0, 0x08, 0xa9, 0x25, 0x20, 0x7d, 0x9b, + 0xa9, 0x61, 0x8d, 0xab, 0x06, 0x20, 0xcb, 0x9b, 0x38, 0xe9, 0x08, 0x85, + 0x8c, 0xad, 0x25, 0x07, 0xe9, 0x00, 0x85, 0x73, 0xa9, 0x30, 0x85, 0xd4, + 0xa9, 0xb0, 0x8d, 0x0d, 0x01, 0xa9, 0x30, 0x85, 0x1b, 0xe6, 0x14, 0x60, + 0xa2, 0x00, 0xa0, 0x0f, 0x4c, 0xe9, 0x99, 0x8a, 0x48, 0xa2, 0x01, 0xa0, + 0x0f, 0xa9, 0x44, 0x20, 0x7d, 0x9b, 0x68, 0xaa, 0x20, 0xbb, 0x9b, 0xa2, + 0x01, 0xa9, 0x40, 0x4c, 0x7d, 0x9b, 0xc3, 0xc2, 0xc2, 0xc2, 0xac, 0x4e, + 0x07, 0xb9, 0xee, 0x99, 0x4c, 0x44, 0x9a, 0x06, 0x07, 0x08, 0xc5, 0x0c, + 0x89, 0xa0, 0x0c, 0x20, 0xaf, 0x9b, 0x4c, 0x0e, 0x9a, 0xa9, 0x08, 0x8d, + 0x73, 0x07, 0xa4, 0x00, 0xbe, 0xf9, 0x99, 0xb9, 0xfc, 0x99, 0x4c, 0x20, + 0x9a, 0x20, 0xbb, 0x9b, 0xa6, 0x07, 0xa9, 0xc4, 0xa0, 0x00, 0x4c, 0x7d, + 0x9b, 0x69, 0x61, 0x61, 0x62, 0x22, 0x51, 0x52, 0x52, 0x88, 0xac, 0x4e, + 0x07, 0xad, 0x43, 0x07, 0xf0, 0x02, 0xa0, 0x04, 0xb9, 0x29, 0x9a, 0x4c, + 0x44, 0x9a, 0xac, 0x4e, 0x07, 0xb9, 0x25, 0x9a, 0x48, 0x20, 0xac, 0x9b, + 0xa6, 0x07, 0xa0, 0x00, 0x68, 0x4c, 0x7d, 0x9b, 0xac, 0x4e, 0x07, 0xb9, + 0x29, 0x9a, 0x4c, 0x5f, 0x9a, 0xac, 0x4e, 0x07, 0xb9, 0x25, 0x9a, 0x48, + 0x20, 0xbb, 0x9b, 0x68, 0xa6, 0x07, 0x4c, 0x7d, 0x9b, 0x20, 0xbb, 0x9b, + 0xa6, 0x07, 0xa9, 0x64, 0x9d, 0xa1, 0x06, 0xe8, 0x88, 0x30, 0x0e, 0xa9, + 0x65, 0x9d, 0xa1, 0x06, 0xe8, 0x88, 0x30, 0x05, 0xa9, 0x66, 0x20, 0x7d, + 0x9b, 0xae, 0x6a, 0x04, 0x20, 0xd3, 0x9b, 0x9d, 0x77, 0x04, 0xad, 0x25, + 0x07, 0x9d, 0x6b, 0x04, 0x20, 0xcb, 0x9b, 0x9d, 0x71, 0x04, 0xe8, 0xe0, + 0x06, 0x90, 0x02, 0xa2, 0x00, 0x8e, 0x6a, 0x04, 0x60, 0x07, 0x07, 0x06, + 0x05, 0x04, 0x03, 0x02, 0x01, 0x00, 0x03, 0x03, 0x04, 0x05, 0x06, 0x07, + 0x08, 0x09, 0x0a, 0x20, 0xac, 0x9b, 0x90, 0x05, 0xa9, 0x09, 0x8d, 0x34, + 0x07, 0xce, 0x34, 0x07, 0xac, 0x34, 0x07, 0xbe, 0xae, 0x9a, 0xb9, 0xa5, + 0x9a, 0xa8, 0xa9, 0x61, 0x4c, 0x7d, 0x9b, 0x20, 0xbb, 0x9b, 0x20, 0x4a, + 0x99, 0x20, 0xcb, 0x9b, 0x95, 0x87, 0xad, 0x25, 0x07, 0x95, 0x6e, 0x20, + 0xd3, 0x9b, 0x95, 0xcf, 0x95, 0x58, 0xa9, 0x32, 0x95, 0x16, 0xa0, 0x01, + 0x94, 0xb6, 0xf6, 0x0f, 0xa6, 0x07, 0xa9, 0x67, 0x9d, 0xa1, 0x06, 0xa9, + 0x68, 0x9d, 0xa2, 0x06, 0x60, 0xad, 0x5d, 0x07, 0xf0, 0x36, 0xa9, 0x00, + 0x8d, 0x5d, 0x07, 0x4c, 0x19, 0x9b, 0x20, 0x36, 0x9b, 0x4c, 0x2c, 0x9b, + 0xa9, 0x00, 0x8d, 0xbc, 0x06, 0x20, 0x36, 0x9b, 0x84, 0x07, 0xa9, 0x00, + 0xac, 0x4e, 0x07, 0x88, 0xf0, 0x02, 0xa9, 0x05, 0x18, 0x65, 0x07, 0xa8, + 0xb9, 0xe8, 0xbd, 0x48, 0x20, 0xbb, 0x9b, 0x4c, 0x48, 0x9a, 0xa5, 0x00, + 0x38, 0xe9, 0x00, 0xa8, 0x60, 0x87, 0x00, 0x00, 0x00, 0x20, 0xac, 0x9b, + 0x90, 0x2d, 0xad, 0x4e, 0x07, 0xd0, 0x28, 0xae, 0x6a, 0x04, 0x20, 0xcb, + 0x9b, 0x38, 0xe9, 0x10, 0x9d, 0x71, 0x04, 0xad, 0x25, 0x07, 0xe9, 0x00, + 0x9d, 0x6b, 0x04, 0xc8, 0xc8, 0x98, 0x0a, 0x0a, 0x0a, 0x0a, 0x9d, 0x77, + 0x04, 0xe8, 0xe0, 0x05, 0x90, 0x02, 0xa2, 0x00, 0x8e, 0x6a, 0x04, 0xae, + 0x4e, 0x07, 0xbd, 0x3d, 0x9b, 0xa2, 0x08, 0xa0, 0x0f, 0x8c, 0x35, 0x07, + 0xbc, 0xa1, 0x06, 0xf0, 0x18, 0xc0, 0x17, 0xf0, 0x17, 0xc0, 0x1a, 0xf0, + 0x13, 0xc0, 0xc0, 0xf0, 0x0c, 0xc0, 0xc0, 0xb0, 0x0b, 0xc0, 0x54, 0xd0, + 0x04, 0xc9, 0x50, 0xf0, 0x03, 0x9d, 0xa1, 0x06, 0xe8, 0xe0, 0x0d, 0xb0, + 0x06, 0xac, 0x35, 0x07, 0x88, 0x10, 0xd2, 0x60, 0x20, 0xbb, 0x9b, 0xbd, + 0x30, 0x07, 0x18, 0x10, 0x05, 0x98, 0x9d, 0x30, 0x07, 0x38, 0x60, 0xbc, + 0x2d, 0x07, 0xb1, 0xe7, 0x29, 0x0f, 0x85, 0x07, 0xc8, 0xb1, 0xe7, 0x29, + 0x0f, 0xa8, 0x60, 0xad, 0x26, 0x07, 0x0a, 0x0a, 0x0a, 0x0a, 0x60, 0xa5, + 0x07, 0x0a, 0x0a, 0x0a, 0x0a, 0x18, 0x69, 0x20, 0x60, 0x00, 0xd0, 0x05, + 0x05, 0x48, 0x4a, 0x4a, 0x4a, 0x4a, 0xa8, 0xb9, 0xdf, 0x9b, 0x85, 0x07, + 0x68, 0x29, 0x0f, 0x18, 0x79, 0xdd, 0x9b, 0x85, 0x06, 0x60, 0xff, 0xff, + 0x12, 0x36, 0x0e, 0x0e, 0x0e, 0x32, 0x32, 0x32, 0x0a, 0x26, 0x40, 0x20, + 0x13, 0x9c, 0x8d, 0x50, 0x07, 0x29, 0x60, 0x0a, 0x2a, 0x2a, 0x2a, 0x8d, + 0x4e, 0x07, 0x60, 0xac, 0x5f, 0x07, 0xb9, 0xb4, 0x9c, 0x18, 0x6d, 0x60, + 0x07, 0xa8, 0xb9, 0xbc, 0x9c, 0x60, 0xad, 0x50, 0x07, 0x20, 0x09, 0x9c, + 0xa8, 0xad, 0x50, 0x07, 0x29, 0x1f, 0x8d, 0x4f, 0x07, 0xb9, 0xe0, 0x9c, + 0x18, 0x6d, 0x4f, 0x07, 0xa8, 0xb9, 0xe4, 0x9c, 0x85, 0xe9, 0xb9, 0x06, + 0x9d, 0x85, 0xea, 0xac, 0x4e, 0x07, 0xb9, 0x28, 0x9d, 0x18, 0x6d, 0x4f, + 0x07, 0xa8, 0xb9, 0x2c, 0x9d, 0x85, 0xe7, 0xb9, 0x4e, 0x9d, 0x85, 0xe8, + 0xa0, 0x00, 0xb1, 0xe7, 0x48, 0x29, 0x07, 0xc9, 0x04, 0x90, 0x05, 0x8d, + 0x44, 0x07, 0xa9, 0x00, 0x8d, 0x41, 0x07, 0x68, 0x48, 0x29, 0x38, 0x4a, + 0x4a, 0x4a, 0x8d, 0x10, 0x07, 0x68, 0x29, 0xc0, 0x18, 0x2a, 0x2a, 0x2a, + 0x8d, 0x15, 0x07, 0xc8, 0xb1, 0xe7, 0x48, 0x29, 0x0f, 0x8d, 0x27, 0x07, + 0x68, 0x48, 0x29, 0x30, 0x4a, 0x4a, 0x4a, 0x4a, 0x8d, 0x42, 0x07, 0x68, + 0x29, 0xc0, 0x18, 0x2a, 0x2a, 0x2a, 0xc9, 0x03, 0xd0, 0x05, 0x8d, 0x43, + 0x07, 0xa9, 0x00, 0x8d, 0x33, 0x07, 0xa5, 0xe7, 0x18, 0x69, 0x02, 0x85, + 0xe7, 0xa5, 0xe8, 0x69, 0x00, 0x85, 0xe8, 0x60, 0x00, 0x05, 0x0a, 0x0e, + 0x13, 0x17, 0x1b, 0x20, 0x25, 0x29, 0xc0, 0x26, 0x60, 0x28, 0x29, 0x01, + 0x27, 0x62, 0x24, 0x35, 0x20, 0x63, 0x22, 0x29, 0x41, 0x2c, 0x61, 0x2a, + 0x31, 0x26, 0x62, 0x2e, 0x23, 0x2d, 0x60, 0x33, 0x29, 0x01, 0x27, 0x64, + 0x30, 0x32, 0x21, 0x65, 0x1f, 0x06, 0x1c, 0x00, 0x70, 0x97, 0xb0, 0xdf, + 0x0a, 0x1f, 0x59, 0x7e, 0x9b, 0xa9, 0xd0, 0x01, 0x1f, 0x3c, 0x51, 0x7b, + 0x7c, 0xa0, 0xa9, 0xce, 0xf1, 0xfa, 0xfb, 0x35, 0x60, 0x8e, 0xaa, 0xb3, + 0xd8, 0x05, 0x33, 0x60, 0x71, 0x9b, 0x9d, 0x9d, 0x9d, 0x9d, 0x9e, 0x9e, + 0x9e, 0x9e, 0x9e, 0x9e, 0x9e, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, + 0x9f, 0x9f, 0x9f, 0x9f, 0x9f, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa0, 0xa1, + 0xa1, 0xa1, 0xa1, 0xa1, 0x00, 0x03, 0x19, 0x1c, 0x06, 0x45, 0xc0, 0x6b, + 0xce, 0x37, 0x8a, 0x19, 0x8e, 0xf3, 0x48, 0xcd, 0x32, 0x3b, 0x7a, 0x8f, + 0xf6, 0x5b, 0xce, 0xff, 0x92, 0x05, 0x7e, 0xd7, 0x02, 0x35, 0xd8, 0x79, + 0xaf, 0x10, 0x8f, 0x02, 0x6f, 0xfa, 0xae, 0xae, 0xae, 0xa4, 0xa4, 0xa5, + 0xa5, 0xa6, 0xa6, 0xa6, 0xa7, 0xa7, 0xa8, 0xa8, 0xa8, 0xa8, 0xa8, 0xa9, + 0xa9, 0xa9, 0xaa, 0xab, 0xab, 0xab, 0xac, 0xac, 0xac, 0xad, 0xa1, 0xa2, + 0xa2, 0xa3, 0xa3, 0xa3, 0x76, 0xdd, 0xbb, 0x4c, 0xea, 0x1d, 0x1b, 0xcc, + 0x56, 0x5d, 0x16, 0x9d, 0xc6, 0x1d, 0x36, 0x9d, 0xc9, 0x1d, 0x04, 0xdb, + 0x49, 0x1d, 0x84, 0x1b, 0xc9, 0x5d, 0x88, 0x95, 0x0f, 0x08, 0x30, 0x4c, + 0x78, 0x2d, 0xa6, 0x28, 0x90, 0xb5, 0xff, 0x0f, 0x03, 0x56, 0x1b, 0xc9, + 0x1b, 0x0f, 0x07, 0x36, 0x1b, 0xaa, 0x1b, 0x48, 0x95, 0x0f, 0x0a, 0x2a, + 0x1b, 0x5b, 0x0c, 0x78, 0x2d, 0x90, 0xb5, 0xff, 0x0b, 0x8c, 0x4b, 0x4c, + 0x77, 0x5f, 0xeb, 0x0c, 0xbd, 0xdb, 0x19, 0x9d, 0x75, 0x1d, 0x7d, 0x5b, + 0xd9, 0x1d, 0x3d, 0xdd, 0x99, 0x1d, 0x26, 0x9d, 0x5a, 0x2b, 0x8a, 0x2c, + 0xca, 0x1b, 0x20, 0x95, 0x7b, 0x5c, 0xdb, 0x4c, 0x1b, 0xcc, 0x3b, 0xcc, + 0x78, 0x2d, 0xa6, 0x28, 0x90, 0xb5, 0xff, 0x0b, 0x8c, 0x3b, 0x1d, 0x8b, + 0x1d, 0xab, 0x0c, 0xdb, 0x1d, 0x0f, 0x03, 0x65, 0x1d, 0x6b, 0x1b, 0x05, + 0x9d, 0x0b, 0x1b, 0x05, 0x9b, 0x0b, 0x1d, 0x8b, 0x0c, 0x1b, 0x8c, 0x70, + 0x15, 0x7b, 0x0c, 0xdb, 0x0c, 0x0f, 0x08, 0x78, 0x2d, 0xa6, 0x28, 0x90, + 0xb5, 0xff, 0x27, 0xa9, 0x4b, 0x0c, 0x68, 0x29, 0x0f, 0x06, 0x77, 0x1b, + 0x0f, 0x0b, 0x60, 0x15, 0x4b, 0x8c, 0x78, 0x2d, 0x90, 0xb5, 0xff, 0x0f, + 0x03, 0x8e, 0x65, 0xe1, 0xbb, 0x38, 0x6d, 0xa8, 0x3e, 0xe5, 0xe7, 0x0f, + 0x08, 0x0b, 0x02, 0x2b, 0x02, 0x5e, 0x65, 0xe1, 0xbb, 0x0e, 0xdb, 0x0e, + 0xbb, 0x8e, 0xdb, 0x0e, 0xfe, 0x65, 0xec, 0x0f, 0x0d, 0x4e, 0x65, 0xe1, + 0x0f, 0x0e, 0x4e, 0x02, 0xe0, 0x0f, 0x10, 0xfe, 0xe5, 0xe1, 0x1b, 0x85, + 0x7b, 0x0c, 0x5b, 0x95, 0x78, 0x2d, 0x90, 0xb5, 0xff, 0xa5, 0x86, 0xe4, + 0x28, 0x18, 0xa8, 0x45, 0x83, 0x69, 0x03, 0xc6, 0x29, 0x9b, 0x83, 0x16, + 0xa4, 0x88, 0x24, 0xe9, 0x28, 0x05, 0xa8, 0x7b, 0x28, 0x24, 0x8f, 0xc8, + 0x03, 0xe8, 0x03, 0x46, 0xa8, 0x85, 0x24, 0xc8, 0x24, 0xff, 0xeb, 0x8e, + 0x0f, 0x03, 0xfb, 0x05, 0x17, 0x85, 0xdb, 0x8e, 0x0f, 0x07, 0x57, 0x05, + 0x7b, 0x05, 0x9b, 0x80, 0x2b, 0x85, 0xfb, 0x05, 0x0f, 0x0b, 0x1b, 0x05, + 0x9b, 0x05, 0xff, 0x2e, 0xc2, 0x66, 0xe2, 0x11, 0x0f, 0x07, 0x02, 0x11, + 0x0f, 0x0c, 0x12, 0x11, 0xff, 0x0e, 0xc2, 0xa8, 0xab, 0x00, 0xbb, 0x8e, + 0x6b, 0x82, 0xde, 0x00, 0xa0, 0x33, 0x86, 0x43, 0x06, 0x3e, 0xb4, 0xa0, + 0xcb, 0x02, 0x0f, 0x07, 0x7e, 0x42, 0xa6, 0x83, 0x02, 0x0f, 0x0a, 0x3b, + 0x02, 0xcb, 0x37, 0x0f, 0x0c, 0xe3, 0x0e, 0xff, 0x9b, 0x8e, 0xca, 0x0e, + 0xee, 0x42, 0x44, 0x5b, 0x86, 0x80, 0xb8, 0x1b, 0x80, 0x50, 0xba, 0x10, + 0xb7, 0x5b, 0x00, 0x17, 0x85, 0x4b, 0x05, 0xfe, 0x34, 0x40, 0xb7, 0x86, + 0xc6, 0x06, 0x5b, 0x80, 0x83, 0x00, 0xd0, 0x38, 0x5b, 0x8e, 0x8a, 0x0e, + 0xa6, 0x00, 0xbb, 0x0e, 0xc5, 0x80, 0xf3, 0x00, 0xff, 0x1e, 0xc2, 0x00, + 0x6b, 0x06, 0x8b, 0x86, 0x63, 0xb7, 0x0f, 0x05, 0x03, 0x06, 0x23, 0x06, + 0x4b, 0xb7, 0xbb, 0x00, 0x5b, 0xb7, 0xfb, 0x37, 0x3b, 0xb7, 0x0f, 0x0b, + 0x1b, 0x37, 0xff, 0x2b, 0xd7, 0xe3, 0x03, 0xc2, 0x86, 0xe2, 0x06, 0x76, + 0xa5, 0xa3, 0x8f, 0x03, 0x86, 0x2b, 0x57, 0x68, 0x28, 0xe9, 0x28, 0xe5, + 0x83, 0x24, 0x8f, 0x36, 0xa8, 0x5b, 0x03, 0xff, 0x0f, 0x02, 0x78, 0x40, + 0x48, 0xce, 0xf8, 0xc3, 0xf8, 0xc3, 0x0f, 0x07, 0x7b, 0x43, 0xc6, 0xd0, + 0x0f, 0x8a, 0xc8, 0x50, 0xff, 0x85, 0x86, 0x0b, 0x80, 0x1b, 0x00, 0xdb, + 0x37, 0x77, 0x80, 0xeb, 0x37, 0xfe, 0x2b, 0x20, 0x2b, 0x80, 0x7b, 0x38, + 0xab, 0xb8, 0x77, 0x86, 0xfe, 0x42, 0x20, 0x49, 0x86, 0x8b, 0x06, 0x9b, + 0x80, 0x7b, 0x8e, 0x5b, 0xb7, 0x9b, 0x0e, 0xbb, 0x0e, 0x9b, 0x80, 0xff, + 0x0b, 0x80, 0x60, 0x38, 0x10, 0xb8, 0xc0, 0x3b, 0xdb, 0x8e, 0x40, 0xb8, + 0xf0, 0x38, 0x7b, 0x8e, 0xa0, 0xb8, 0xc0, 0xb8, 0xfb, 0x00, 0xa0, 0xb8, + 0x30, 0xbb, 0xee, 0x42, 0x88, 0x0f, 0x0b, 0x2b, 0x0e, 0x67, 0x0e, 0xff, + 0x0a, 0xaa, 0x0e, 0x28, 0x2a, 0x0e, 0x31, 0x88, 0xff, 0xc7, 0x83, 0xd7, + 0x03, 0x42, 0x8f, 0x7a, 0x03, 0x05, 0xa4, 0x78, 0x24, 0xa6, 0x25, 0xe4, + 0x25, 0x4b, 0x83, 0xe3, 0x03, 0x05, 0xa4, 0x89, 0x24, 0xb5, 0x24, 0x09, + 0xa4, 0x65, 0x24, 0xc9, 0x24, 0x0f, 0x08, 0x85, 0x25, 0xff, 0xcd, 0xa5, + 0xb5, 0xa8, 0x07, 0xa8, 0x76, 0x28, 0xcc, 0x25, 0x65, 0xa4, 0xa9, 0x24, + 0xe5, 0x24, 0x19, 0xa4, 0x0f, 0x07, 0x95, 0x28, 0xe6, 0x24, 0x19, 0xa4, + 0xd7, 0x29, 0x16, 0xa9, 0x58, 0x29, 0x97, 0x29, 0xff, 0x0f, 0x02, 0x02, + 0x11, 0x0f, 0x07, 0x02, 0x11, 0xff, 0xff, 0x2b, 0x82, 0xab, 0x38, 0xde, + 0x42, 0xe2, 0x1b, 0xb8, 0xeb, 0x3b, 0xdb, 0x80, 0x8b, 0xb8, 0x1b, 0x82, + 0xfb, 0xb8, 0x7b, 0x80, 0xfb, 0x3c, 0x5b, 0xbc, 0x7b, 0xb8, 0x1b, 0x8e, + 0xcb, 0x0e, 0x1b, 0x8e, 0x0f, 0x0d, 0x2b, 0x3b, 0xbb, 0xb8, 0xeb, 0x82, + 0x4b, 0xb8, 0xbb, 0x38, 0x3b, 0xb7, 0xbb, 0x02, 0x0f, 0x13, 0x1b, 0x00, + 0xcb, 0x80, 0x6b, 0xbc, 0xff, 0x7b, 0x80, 0xae, 0x00, 0x80, 0x8b, 0x8e, + 0xe8, 0x05, 0xf9, 0x86, 0x17, 0x86, 0x16, 0x85, 0x4e, 0x2b, 0x80, 0xab, + 0x8e, 0x87, 0x85, 0xc3, 0x05, 0x8b, 0x82, 0x9b, 0x02, 0xab, 0x02, 0xbb, + 0x86, 0xcb, 0x06, 0xd3, 0x03, 0x3b, 0x8e, 0x6b, 0x0e, 0xa7, 0x8e, 0xff, + 0x29, 0x8e, 0x52, 0x11, 0x83, 0x0e, 0x0f, 0x03, 0x9b, 0x0e, 0x2b, 0x8e, + 0x5b, 0x0e, 0xcb, 0x8e, 0xfb, 0x0e, 0xfb, 0x82, 0x9b, 0x82, 0xbb, 0x02, + 0xfe, 0x42, 0xe8, 0xbb, 0x8e, 0x0f, 0x0a, 0xab, 0x0e, 0xcb, 0x0e, 0xf9, + 0x0e, 0x88, 0x86, 0xa6, 0x06, 0xdb, 0x02, 0xb6, 0x8e, 0xff, 0xab, 0xce, + 0xde, 0x42, 0xc0, 0xcb, 0xce, 0x5b, 0x8e, 0x1b, 0xce, 0x4b, 0x85, 0x67, + 0x45, 0x0f, 0x07, 0x2b, 0x00, 0x7b, 0x85, 0x97, 0x05, 0x0f, 0x0a, 0x92, + 0x02, 0xff, 0x0a, 0xaa, 0x0e, 0x24, 0x4a, 0x1e, 0x23, 0xaa, 0xff, 0x1b, + 0x80, 0xbb, 0x38, 0x4b, 0xbc, 0xeb, 0x3b, 0x0f, 0x04, 0x2b, 0x00, 0xab, + 0x38, 0xeb, 0x00, 0xcb, 0x8e, 0xfb, 0x80, 0xab, 0xb8, 0x6b, 0x80, 0xfb, + 0x3c, 0x9b, 0xbb, 0x5b, 0xbc, 0xfb, 0x00, 0x6b, 0xb8, 0xfb, 0x38, 0xff, + 0x0b, 0x86, 0x1a, 0x06, 0xdb, 0x06, 0xde, 0xc2, 0x02, 0xf0, 0x3b, 0xbb, + 0x80, 0xeb, 0x06, 0x0b, 0x86, 0x93, 0x06, 0xf0, 0x39, 0x0f, 0x06, 0x60, + 0xb8, 0x1b, 0x86, 0xa0, 0xb9, 0xb7, 0x27, 0xbd, 0x27, 0x2b, 0x83, 0xa1, + 0x26, 0xa9, 0x26, 0xee, 0x25, 0x0b, 0x27, 0xb4, 0xff, 0x0f, 0x02, 0x1e, + 0x2f, 0x60, 0xe0, 0x3a, 0xa5, 0xa7, 0xdb, 0x80, 0x3b, 0x82, 0x8b, 0x02, + 0xfe, 0x42, 0x68, 0x70, 0xbb, 0x25, 0xa7, 0x2c, 0x27, 0xb2, 0x26, 0xb9, + 0x26, 0x9b, 0x80, 0xa8, 0x82, 0xb5, 0x27, 0xbc, 0x27, 0xb0, 0xbb, 0x3b, + 0x82, 0x87, 0x34, 0xee, 0x25, 0x6b, 0xff, 0x1e, 0xa5, 0x0a, 0x2e, 0x28, + 0x27, 0x2e, 0x33, 0xc7, 0x0f, 0x03, 0x1e, 0x40, 0x07, 0x2e, 0x30, 0xe7, + 0x0f, 0x05, 0x1e, 0x24, 0x44, 0x0f, 0x07, 0x1e, 0x22, 0x6a, 0x2e, 0x23, + 0xab, 0x0f, 0x09, 0x1e, 0x41, 0x68, 0x1e, 0x2a, 0x8a, 0x2e, 0x23, 0xa2, + 0x2e, 0x32, 0xea, 0xff, 0x3b, 0x87, 0x66, 0x27, 0xcc, 0x27, 0xee, 0x31, + 0x87, 0xee, 0x23, 0xa7, 0x3b, 0x87, 0xdb, 0x07, 0xff, 0x0f, 0x01, 0x2e, + 0x25, 0x2b, 0x2e, 0x25, 0x4b, 0x4e, 0x25, 0xcb, 0x6b, 0x07, 0x97, 0x47, + 0xe9, 0x87, 0x47, 0xc7, 0x7a, 0x07, 0xd6, 0xc7, 0x78, 0x07, 0x38, 0x87, + 0xab, 0x47, 0xe3, 0x07, 0x9b, 0x87, 0x0f, 0x09, 0x68, 0x47, 0xdb, 0xc7, + 0x3b, 0xc7, 0xff, 0x47, 0x9b, 0xcb, 0x07, 0xfa, 0x1d, 0x86, 0x9b, 0x3a, + 0x87, 0x56, 0x07, 0x88, 0x1b, 0x07, 0x9d, 0x2e, 0x65, 0xf0, 0xff, 0x9b, + 0x07, 0x05, 0x32, 0x06, 0x33, 0x07, 0x34, 0xce, 0x03, 0xdc, 0x51, 0xee, + 0x07, 0x73, 0xe0, 0x74, 0x0a, 0x7e, 0x06, 0x9e, 0x0a, 0xce, 0x06, 0xe4, + 0x00, 0xe8, 0x0a, 0xfe, 0x0a, 0x2e, 0x89, 0x4e, 0x0b, 0x54, 0x0a, 0x14, + 0x8a, 0xc4, 0x0a, 0x34, 0x8a, 0x7e, 0x06, 0xc7, 0x0a, 0x01, 0xe0, 0x02, + 0x0a, 0x47, 0x0a, 0x81, 0x60, 0x82, 0x0a, 0xc7, 0x0a, 0x0e, 0x87, 0x7e, + 0x02, 0xa7, 0x02, 0xb3, 0x02, 0xd7, 0x02, 0xe3, 0x02, 0x07, 0x82, 0x13, + 0x02, 0x3e, 0x06, 0x7e, 0x02, 0xae, 0x07, 0xfe, 0x0a, 0x0d, 0xc4, 0xcd, + 0x43, 0xce, 0x09, 0xde, 0x0b, 0xdd, 0x42, 0xfe, 0x02, 0x5d, 0xc7, 0xfd, + 0x5b, 0x07, 0x05, 0x32, 0x06, 0x33, 0x07, 0x34, 0x5e, 0x0a, 0x68, 0x64, + 0x98, 0x64, 0xa8, 0x64, 0xce, 0x06, 0xfe, 0x02, 0x0d, 0x01, 0x1e, 0x0e, + 0x7e, 0x02, 0x94, 0x63, 0xb4, 0x63, 0xd4, 0x63, 0xf4, 0x63, 0x14, 0xe3, + 0x2e, 0x0e, 0x5e, 0x02, 0x64, 0x35, 0x88, 0x72, 0xbe, 0x0e, 0x0d, 0x04, + 0xae, 0x02, 0xce, 0x08, 0xcd, 0x4b, 0xfe, 0x02, 0x0d, 0x05, 0x68, 0x31, + 0x7e, 0x0a, 0x96, 0x31, 0xa9, 0x63, 0xa8, 0x33, 0xd5, 0x30, 0xee, 0x02, + 0xe6, 0x62, 0xf4, 0x61, 0x04, 0xb1, 0x08, 0x3f, 0x44, 0x33, 0x94, 0x63, + 0xa4, 0x31, 0xe4, 0x31, 0x04, 0xbf, 0x08, 0x3f, 0x04, 0xbf, 0x08, 0x3f, + 0xcd, 0x4b, 0x03, 0xe4, 0x0e, 0x03, 0x2e, 0x01, 0x7e, 0x06, 0xbe, 0x02, + 0xde, 0x06, 0xfe, 0x0a, 0x0d, 0xc4, 0xcd, 0x43, 0xce, 0x09, 0xde, 0x0b, + 0xdd, 0x42, 0xfe, 0x02, 0x5d, 0xc7, 0xfd, 0x9b, 0x07, 0x05, 0x32, 0x06, + 0x33, 0x07, 0x34, 0xfe, 0x00, 0x27, 0xb1, 0x65, 0x32, 0x75, 0x0a, 0x71, + 0x00, 0xb7, 0x31, 0x08, 0xe4, 0x18, 0x64, 0x1e, 0x04, 0x57, 0x3b, 0xbb, + 0x0a, 0x17, 0x8a, 0x27, 0x3a, 0x73, 0x0a, 0x7b, 0x0a, 0xd7, 0x0a, 0xe7, + 0x3a, 0x3b, 0x8a, 0x97, 0x0a, 0xfe, 0x08, 0x24, 0x8a, 0x2e, 0x00, 0x3e, + 0x40, 0x38, 0x64, 0x6f, 0x00, 0x9f, 0x00, 0xbe, 0x43, 0xc8, 0x0a, 0xc9, + 0x63, 0xce, 0x07, 0xfe, 0x07, 0x2e, 0x81, 0x66, 0x42, 0x6a, 0x42, 0x79, + 0x0a, 0xbe, 0x00, 0xc8, 0x64, 0xf8, 0x64, 0x08, 0xe4, 0x2e, 0x07, 0x7e, + 0x03, 0x9e, 0x07, 0xbe, 0x03, 0xde, 0x07, 0xfe, 0x0a, 0x03, 0xa5, 0x0d, + 0x44, 0xcd, 0x43, 0xce, 0x09, 0xdd, 0x42, 0xde, 0x0b, 0xfe, 0x02, 0x5d, + 0xc7, 0xfd, 0x9b, 0x07, 0x05, 0x32, 0x06, 0x33, 0x07, 0x34, 0xfe, 0x06, + 0x0c, 0x81, 0x39, 0x0a, 0x5c, 0x01, 0x89, 0x0a, 0xac, 0x01, 0xd9, 0x0a, + 0xfc, 0x01, 0x2e, 0x83, 0xa7, 0x01, 0xb7, 0x00, 0xc7, 0x01, 0xde, 0x0a, + 0xfe, 0x02, 0x4e, 0x83, 0x5a, 0x32, 0x63, 0x0a, 0x69, 0x0a, 0x7e, 0x02, + 0xee, 0x03, 0xfa, 0x32, 0x03, 0x8a, 0x09, 0x0a, 0x1e, 0x02, 0xee, 0x03, + 0xfa, 0x32, 0x03, 0x8a, 0x09, 0x0a, 0x14, 0x42, 0x1e, 0x02, 0x7e, 0x0a, + 0x9e, 0x07, 0xfe, 0x0a, 0x2e, 0x86, 0x5e, 0x0a, 0x8e, 0x06, 0xbe, 0x0a, + 0xee, 0x07, 0x3e, 0x83, 0x5e, 0x07, 0xfe, 0x0a, 0x0d, 0xc4, 0x41, 0x52, + 0x51, 0x52, 0xcd, 0x43, 0xce, 0x09, 0xde, 0x0b, 0xdd, 0x42, 0xfe, 0x02, + 0x5d, 0xc7, 0xfd, 0x5b, 0x07, 0x05, 0x32, 0x06, 0x33, 0x07, 0x34, 0xfe, + 0x0a, 0xae, 0x86, 0xbe, 0x07, 0xfe, 0x02, 0x0d, 0x02, 0x27, 0x32, 0x46, + 0x61, 0x55, 0x62, 0x5e, 0x0e, 0x1e, 0x82, 0x68, 0x3c, 0x74, 0x3a, 0x7d, + 0x4b, 0x5e, 0x8e, 0x7d, 0x4b, 0x7e, 0x82, 0x84, 0x62, 0x94, 0x61, 0xa4, + 0x31, 0xbd, 0x4b, 0xce, 0x06, 0xfe, 0x02, 0x0d, 0x06, 0x34, 0x31, 0x3e, + 0x0a, 0x64, 0x32, 0x75, 0x0a, 0x7b, 0x61, 0xa4, 0x33, 0xae, 0x02, 0xde, + 0x0e, 0x3e, 0x82, 0x64, 0x32, 0x78, 0x32, 0xb4, 0x36, 0xc8, 0x36, 0xdd, + 0x4b, 0x44, 0xb2, 0x58, 0x32, 0x94, 0x63, 0xa4, 0x3e, 0xba, 0x30, 0xc9, + 0x61, 0xce, 0x06, 0xdd, 0x4b, 0xce, 0x86, 0xdd, 0x4b, 0xfe, 0x02, 0x2e, + 0x86, 0x5e, 0x02, 0x7e, 0x06, 0xfe, 0x02, 0x1e, 0x86, 0x3e, 0x02, 0x5e, + 0x06, 0x7e, 0x02, 0x9e, 0x06, 0xfe, 0x0a, 0x0d, 0xc4, 0xcd, 0x43, 0xce, + 0x09, 0xde, 0x0b, 0xdd, 0x42, 0xfe, 0x02, 0x5d, 0xc7, 0xfd, 0x5b, 0x06, + 0x05, 0x32, 0x06, 0x33, 0x07, 0x34, 0x5e, 0x0a, 0xae, 0x02, 0x0d, 0x01, + 0x39, 0x73, 0x0d, 0x03, 0x39, 0x7b, 0x4d, 0x4b, 0xde, 0x06, 0x1e, 0x8a, + 0xae, 0x06, 0xc4, 0x33, 0x16, 0xfe, 0xa5, 0x77, 0xfe, 0x02, 0xfe, 0x82, + 0x0d, 0x07, 0x39, 0x73, 0xa8, 0x74, 0xed, 0x4b, 0x49, 0xfb, 0xe8, 0x74, + 0xfe, 0x0a, 0x2e, 0x82, 0x67, 0x02, 0x84, 0x7a, 0x87, 0x31, 0x0d, 0x0b, + 0xfe, 0x02, 0x0d, 0x0c, 0x39, 0x73, 0x5e, 0x06, 0xc6, 0x76, 0x45, 0xff, + 0xbe, 0x0a, 0xdd, 0x48, 0xfe, 0x06, 0x3d, 0xcb, 0x46, 0x7e, 0xad, 0x4a, + 0xfe, 0x82, 0x39, 0xf3, 0xa9, 0x7b, 0x4e, 0x8a, 0x9e, 0x07, 0xfe, 0x0a, + 0x0d, 0xc4, 0xcd, 0x43, 0xce, 0x09, 0xde, 0x0b, 0xdd, 0x42, 0xfe, 0x02, + 0x5d, 0xc7, 0xfd, 0x94, 0x11, 0x0f, 0x26, 0xfe, 0x10, 0x28, 0x94, 0x65, + 0x15, 0xeb, 0x12, 0xfa, 0x41, 0x4a, 0x96, 0x54, 0x40, 0xa4, 0x42, 0xb7, + 0x13, 0xe9, 0x19, 0xf5, 0x15, 0x11, 0x80, 0x47, 0x42, 0x71, 0x13, 0x80, + 0x41, 0x15, 0x92, 0x1b, 0x1f, 0x24, 0x40, 0x55, 0x12, 0x64, 0x40, 0x95, + 0x12, 0xa4, 0x40, 0xd2, 0x12, 0xe1, 0x40, 0x13, 0xc0, 0x2c, 0x17, 0x2f, + 0x12, 0x49, 0x13, 0x83, 0x40, 0x9f, 0x14, 0xa3, 0x40, 0x17, 0x92, 0x83, + 0x13, 0x92, 0x41, 0xb9, 0x14, 0xc5, 0x12, 0xc8, 0x40, 0xd4, 0x40, 0x4b, + 0x92, 0x78, 0x1b, 0x9c, 0x94, 0x9f, 0x11, 0xdf, 0x14, 0xfe, 0x11, 0x7d, + 0xc1, 0x9e, 0x42, 0xcf, 0x20, 0xfd, 0x90, 0xb1, 0x0f, 0x26, 0x29, 0x91, + 0x7e, 0x42, 0xfe, 0x40, 0x28, 0x92, 0x4e, 0x42, 0x2e, 0xc0, 0x57, 0x73, + 0xc3, 0x25, 0xc7, 0x27, 0x23, 0x84, 0x33, 0x20, 0x5c, 0x01, 0x77, 0x63, + 0x88, 0x62, 0x99, 0x61, 0xaa, 0x60, 0xbc, 0x01, 0xee, 0x42, 0x4e, 0xc0, + 0x69, 0x11, 0x7e, 0x42, 0xde, 0x40, 0xf8, 0x62, 0x0e, 0xc2, 0xae, 0x40, + 0xd7, 0x63, 0xe7, 0x63, 0x33, 0xa7, 0x37, 0x27, 0x43, 0x04, 0xcc, 0x01, + 0xe7, 0x73, 0x0c, 0x81, 0x3e, 0x42, 0x0d, 0x0a, 0x5e, 0x40, 0x88, 0x72, + 0xbe, 0x42, 0xe7, 0x87, 0xfe, 0x40, 0x39, 0xe1, 0x4e, 0x00, 0x69, 0x60, + 0x87, 0x60, 0xa5, 0x60, 0xc3, 0x31, 0xfe, 0x31, 0x6d, 0xc1, 0xbe, 0x42, + 0xef, 0x20, 0xfd, 0x52, 0x21, 0x0f, 0x20, 0x6e, 0x40, 0x58, 0xf2, 0x93, + 0x01, 0x97, 0x00, 0x0c, 0x81, 0x97, 0x40, 0xa6, 0x41, 0xc7, 0x40, 0x0d, + 0x04, 0x03, 0x01, 0x07, 0x01, 0x23, 0x01, 0x27, 0x01, 0xec, 0x03, 0xac, + 0xf3, 0xc3, 0x03, 0x78, 0xe2, 0x94, 0x43, 0x47, 0xf3, 0x74, 0x43, 0x47, + 0xfb, 0x74, 0x43, 0x2c, 0xf1, 0x4c, 0x63, 0x47, 0x00, 0x57, 0x21, 0x5c, + 0x01, 0x7c, 0x72, 0x39, 0xf1, 0xec, 0x02, 0x4c, 0x81, 0xd8, 0x62, 0xec, + 0x01, 0x0d, 0x0d, 0x0f, 0x38, 0xc7, 0x07, 0xed, 0x4a, 0x1d, 0xc1, 0x5f, + 0x26, 0xfd, 0x54, 0x21, 0x0f, 0x26, 0xa7, 0x22, 0x37, 0xfb, 0x73, 0x20, + 0x83, 0x07, 0x87, 0x02, 0x93, 0x20, 0xc7, 0x73, 0x04, 0xf1, 0x06, 0x31, + 0x39, 0x71, 0x59, 0x71, 0xe7, 0x73, 0x37, 0xa0, 0x47, 0x04, 0x86, 0x7c, + 0xe5, 0x71, 0xe7, 0x31, 0x33, 0xa4, 0x39, 0x71, 0xa9, 0x71, 0xd3, 0x23, + 0x08, 0xf2, 0x13, 0x05, 0x27, 0x02, 0x49, 0x71, 0x75, 0x75, 0xe8, 0x72, + 0x67, 0xf3, 0x99, 0x71, 0xe7, 0x20, 0xf4, 0x72, 0xf7, 0x31, 0x17, 0xa0, + 0x33, 0x20, 0x39, 0x71, 0x73, 0x28, 0xbc, 0x05, 0x39, 0xf1, 0x79, 0x71, + 0xa6, 0x21, 0xc3, 0x06, 0xd3, 0x20, 0xdc, 0x00, 0xfc, 0x00, 0x07, 0xa2, + 0x13, 0x21, 0x5f, 0x32, 0x8c, 0x00, 0x98, 0x7a, 0xc7, 0x63, 0xd9, 0x61, + 0x03, 0xa2, 0x07, 0x22, 0x74, 0x72, 0x77, 0x31, 0xe7, 0x73, 0x39, 0xf1, + 0x58, 0x72, 0x77, 0x73, 0xd8, 0x72, 0x7f, 0xb1, 0x97, 0x73, 0xb6, 0x64, + 0xc5, 0x65, 0xd4, 0x66, 0xe3, 0x67, 0xf3, 0x67, 0x8d, 0xc1, 0xcf, 0x26, + 0xfd, 0x52, 0x31, 0x0f, 0x20, 0x6e, 0x66, 0x07, 0x81, 0x36, 0x01, 0x66, + 0x00, 0xa7, 0x22, 0x08, 0xf2, 0x67, 0x7b, 0xdc, 0x02, 0x98, 0xf2, 0xd7, + 0x20, 0x39, 0xf1, 0x9f, 0x33, 0xdc, 0x27, 0xdc, 0x57, 0x23, 0x83, 0x57, + 0x63, 0x6c, 0x51, 0x87, 0x63, 0x99, 0x61, 0xa3, 0x06, 0xb3, 0x21, 0x77, + 0xf3, 0xf3, 0x21, 0xf7, 0x2a, 0x13, 0x81, 0x23, 0x22, 0x53, 0x00, 0x63, + 0x22, 0xe9, 0x0b, 0x0c, 0x83, 0x13, 0x21, 0x16, 0x22, 0x33, 0x05, 0x8f, + 0x35, 0xec, 0x01, 0x63, 0xa0, 0x67, 0x20, 0x73, 0x01, 0x77, 0x01, 0x83, + 0x20, 0x87, 0x20, 0xb3, 0x20, 0xb7, 0x20, 0xc3, 0x01, 0xc7, 0x00, 0xd3, + 0x20, 0xd7, 0x20, 0x67, 0xa0, 0x77, 0x07, 0x87, 0x22, 0xe8, 0x62, 0xf5, + 0x65, 0x1c, 0x82, 0x7f, 0x38, 0x8d, 0xc1, 0xcf, 0x26, 0xfd, 0x50, 0x21, + 0x07, 0x81, 0x47, 0x24, 0x57, 0x00, 0x63, 0x01, 0x77, 0x01, 0xc9, 0x71, + 0x68, 0xf2, 0xe7, 0x73, 0x97, 0xfb, 0x06, 0x83, 0x5c, 0x01, 0xd7, 0x22, + 0xe7, 0x00, 0x03, 0xa7, 0x6c, 0x02, 0xb3, 0x22, 0xe3, 0x01, 0xe7, 0x07, + 0x47, 0xa0, 0x57, 0x06, 0xa7, 0x01, 0xd3, 0x00, 0xd7, 0x01, 0x07, 0x81, + 0x67, 0x20, 0x93, 0x22, 0x03, 0xa3, 0x1c, 0x61, 0x17, 0x21, 0x6f, 0x33, + 0xc7, 0x63, 0xd8, 0x62, 0xe9, 0x61, 0xfa, 0x60, 0x4f, 0xb3, 0x87, 0x63, + 0x9c, 0x01, 0xb7, 0x63, 0xc8, 0x62, 0xd9, 0x61, 0xea, 0x60, 0x39, 0xf1, + 0x87, 0x21, 0xa7, 0x01, 0xb7, 0x20, 0x39, 0xf1, 0x5f, 0x38, 0x6d, 0xc1, + 0xaf, 0x26, 0xfd, 0x90, 0x11, 0x0f, 0x26, 0xfe, 0x10, 0x2a, 0x93, 0x87, + 0x17, 0xa3, 0x14, 0xb2, 0x42, 0x0a, 0x92, 0x19, 0x40, 0x36, 0x14, 0x50, + 0x41, 0x82, 0x16, 0x2b, 0x93, 0x24, 0x41, 0xbb, 0x14, 0xb8, 0x00, 0xc2, + 0x43, 0xc3, 0x13, 0x1b, 0x94, 0x67, 0x12, 0xc4, 0x15, 0x53, 0xc1, 0xd2, + 0x41, 0x12, 0xc1, 0x29, 0x13, 0x85, 0x17, 0x1b, 0x92, 0x1a, 0x42, 0x47, + 0x13, 0x83, 0x41, 0xa7, 0x13, 0x0e, 0x91, 0xa7, 0x63, 0xb7, 0x63, 0xc5, + 0x65, 0xd5, 0x65, 0xdd, 0x4a, 0xe3, 0x67, 0xf3, 0x67, 0x8d, 0xc1, 0xae, + 0x42, 0xdf, 0x20, 0xfd, 0x90, 0x11, 0x0f, 0x26, 0x6e, 0x10, 0x8b, 0x17, + 0xaf, 0x32, 0xd8, 0x62, 0xe8, 0x62, 0xfc, 0x3f, 0xad, 0xc8, 0xf8, 0x64, + 0x0c, 0xbe, 0x43, 0x43, 0xf8, 0x64, 0x0c, 0xbf, 0x73, 0x40, 0x84, 0x40, + 0x93, 0x40, 0xa4, 0x40, 0xb3, 0x40, 0xf8, 0x64, 0x48, 0xe4, 0x5c, 0x39, + 0x83, 0x40, 0x92, 0x41, 0xb3, 0x40, 0xf8, 0x64, 0x48, 0xe4, 0x5c, 0x39, + 0xf8, 0x64, 0x13, 0xc2, 0x37, 0x65, 0x4c, 0x24, 0x63, 0x00, 0x97, 0x65, + 0xc3, 0x42, 0x0b, 0x97, 0xac, 0x32, 0xf8, 0x64, 0x0c, 0xbe, 0x53, 0x45, + 0x9d, 0x48, 0xf8, 0x64, 0x2a, 0xe2, 0x3c, 0x47, 0x56, 0x43, 0xba, 0x62, + 0xf8, 0x64, 0x0c, 0xb7, 0x88, 0x64, 0xbc, 0x31, 0xd4, 0x45, 0xfc, 0x31, + 0x3c, 0xb1, 0x78, 0x64, 0x8c, 0x38, 0x0b, 0x9c, 0x1a, 0x33, 0x18, 0x61, + 0x28, 0x61, 0x39, 0x60, 0x5d, 0x4a, 0xee, 0x11, 0x0f, 0xb8, 0x1d, 0xc1, + 0x3e, 0x42, 0x6f, 0x20, 0xfd, 0x52, 0x31, 0x0f, 0x20, 0x6e, 0x40, 0xf7, + 0x20, 0x07, 0x84, 0x17, 0x20, 0x4f, 0x34, 0xc3, 0x03, 0xc7, 0x02, 0xd3, + 0x22, 0x27, 0xe3, 0x39, 0x61, 0xe7, 0x73, 0x5c, 0xe4, 0x57, 0x00, 0x6c, + 0x73, 0x47, 0xa0, 0x53, 0x06, 0x63, 0x22, 0xa7, 0x73, 0xfc, 0x73, 0x13, + 0xa1, 0x33, 0x05, 0x43, 0x21, 0x5c, 0x72, 0xc3, 0x23, 0xcc, 0x03, 0x77, + 0xfb, 0xac, 0x02, 0x39, 0xf1, 0xa7, 0x73, 0xd3, 0x04, 0xe8, 0x72, 0xe3, + 0x22, 0x26, 0xf4, 0xbc, 0x02, 0x8c, 0x81, 0xa8, 0x62, 0x17, 0x87, 0x43, + 0x24, 0xa7, 0x01, 0xc3, 0x04, 0x08, 0xf2, 0x97, 0x21, 0xa3, 0x02, 0xc9, + 0x0b, 0xe1, 0x69, 0xf1, 0x69, 0x8d, 0xc1, 0xcf, 0x26, 0xfd, 0x38, 0x11, + 0x0f, 0x26, 0xad, 0x40, 0x3d, 0xc7, 0xfd, 0x95, 0xb1, 0x0f, 0x26, 0x0d, + 0x02, 0xc8, 0x72, 0x1c, 0x81, 0x38, 0x72, 0x0d, 0x05, 0x97, 0x34, 0x98, + 0x62, 0xa3, 0x20, 0xb3, 0x06, 0xc3, 0x20, 0xcc, 0x03, 0xf9, 0x91, 0x2c, + 0x81, 0x48, 0x62, 0x0d, 0x09, 0x37, 0x63, 0x47, 0x03, 0x57, 0x21, 0x8c, + 0x02, 0xc5, 0x79, 0xc7, 0x31, 0xf9, 0x11, 0x39, 0xf1, 0xa9, 0x11, 0x6f, + 0xb4, 0xd3, 0x65, 0xe3, 0x65, 0x7d, 0xc1, 0xbf, 0x26, 0xfd, 0x00, 0xc1, + 0x4c, 0x00, 0xf4, 0x4f, 0x0d, 0x02, 0x02, 0x42, 0x43, 0x4f, 0x52, 0xc2, + 0xde, 0x00, 0x5a, 0xc2, 0x4d, 0xc7, 0xfd, 0x90, 0x51, 0x0f, 0x26, 0xee, + 0x10, 0x0b, 0x94, 0x33, 0x14, 0x42, 0x42, 0x77, 0x16, 0x86, 0x44, 0x02, + 0x92, 0x4a, 0x16, 0x69, 0x42, 0x73, 0x14, 0xb0, 0x00, 0xc7, 0x12, 0x05, + 0xc0, 0x1c, 0x17, 0x1f, 0x11, 0x36, 0x12, 0x8f, 0x14, 0x91, 0x40, 0x1b, + 0x94, 0x35, 0x12, 0x34, 0x42, 0x60, 0x42, 0x61, 0x12, 0x87, 0x12, 0x96, + 0x40, 0xa3, 0x14, 0x1c, 0x98, 0x1f, 0x11, 0x47, 0x12, 0x9f, 0x15, 0xcc, + 0x15, 0xcf, 0x11, 0x05, 0xc0, 0x1f, 0x15, 0x39, 0x12, 0x7c, 0x16, 0x7f, + 0x11, 0x82, 0x40, 0x98, 0x12, 0xdf, 0x15, 0x16, 0xc4, 0x17, 0x14, 0x54, + 0x12, 0x9b, 0x16, 0x28, 0x94, 0xce, 0x01, 0x3d, 0xc1, 0x5e, 0x42, 0x8f, + 0x20, 0xfd, 0x97, 0x11, 0x0f, 0x26, 0xfe, 0x10, 0x2b, 0x92, 0x57, 0x12, + 0x8b, 0x12, 0xc0, 0x41, 0xf7, 0x13, 0x5b, 0x92, 0x69, 0x0b, 0xbb, 0x12, + 0xb2, 0x46, 0x19, 0x93, 0x71, 0x00, 0x17, 0x94, 0x7c, 0x14, 0x7f, 0x11, + 0x93, 0x41, 0xbf, 0x15, 0xfc, 0x13, 0xff, 0x11, 0x2f, 0x95, 0x50, 0x42, + 0x51, 0x12, 0x58, 0x14, 0xa6, 0x12, 0xdb, 0x12, 0x1b, 0x93, 0x46, 0x43, + 0x7b, 0x12, 0x8d, 0x49, 0xb7, 0x14, 0x1b, 0x94, 0x49, 0x0b, 0xbb, 0x12, + 0xfc, 0x13, 0xff, 0x12, 0x03, 0xc1, 0x2f, 0x15, 0x43, 0x12, 0x4b, 0x13, + 0x77, 0x13, 0x9d, 0x4a, 0x15, 0xc1, 0xa1, 0x41, 0xc3, 0x12, 0xfe, 0x01, + 0x7d, 0xc1, 0x9e, 0x42, 0xcf, 0x20, 0xfd, 0x52, 0x21, 0x0f, 0x20, 0x6e, + 0x44, 0x0c, 0xf1, 0x4c, 0x01, 0xaa, 0x35, 0xd9, 0x34, 0xee, 0x20, 0x08, + 0xb3, 0x37, 0x32, 0x43, 0x04, 0x4e, 0x21, 0x53, 0x20, 0x7c, 0x01, 0x97, + 0x21, 0xb7, 0x07, 0x9c, 0x81, 0xe7, 0x42, 0x5f, 0xb3, 0x97, 0x63, 0xac, + 0x02, 0xc5, 0x41, 0x49, 0xe0, 0x58, 0x61, 0x76, 0x64, 0x85, 0x65, 0x94, + 0x66, 0xa4, 0x22, 0xa6, 0x03, 0xc8, 0x22, 0xdc, 0x02, 0x68, 0xf2, 0x96, + 0x42, 0x13, 0x82, 0x17, 0x02, 0xaf, 0x34, 0xf6, 0x21, 0xfc, 0x06, 0x26, + 0x80, 0x2a, 0x24, 0x36, 0x01, 0x8c, 0x00, 0xff, 0x35, 0x4e, 0xa0, 0x55, + 0x21, 0x77, 0x20, 0x87, 0x07, 0x89, 0x22, 0xae, 0x21, 0x4c, 0x82, 0x9f, + 0x34, 0xec, 0x01, 0x03, 0xe7, 0x13, 0x67, 0x8d, 0x4a, 0xad, 0x41, 0x0f, + 0xa6, 0xfd, 0x10, 0x51, 0x4c, 0x00, 0xc7, 0x12, 0xc6, 0x42, 0x03, 0x92, + 0x02, 0x42, 0x29, 0x12, 0x63, 0x12, 0x62, 0x42, 0x69, 0x14, 0xa5, 0x12, + 0xa4, 0x42, 0xe2, 0x14, 0xe1, 0x44, 0xf8, 0x16, 0x37, 0xc1, 0x8f, 0x38, + 0x02, 0xbb, 0x28, 0x7a, 0x68, 0x7a, 0xa8, 0x7a, 0xe0, 0x6a, 0xf0, 0x6a, + 0x6d, 0xc5, 0xfd, 0x92, 0x31, 0x0f, 0x20, 0x6e, 0x40, 0x0d, 0x02, 0x37, + 0x73, 0xec, 0x00, 0x0c, 0x80, 0x3c, 0x00, 0x6c, 0x00, 0x9c, 0x00, 0x06, + 0xc0, 0xc7, 0x73, 0x06, 0x83, 0x28, 0x72, 0x96, 0x40, 0xe7, 0x73, 0x26, + 0xc0, 0x87, 0x7b, 0xd2, 0x41, 0x39, 0xf1, 0xc8, 0xf2, 0x97, 0xe3, 0xa3, + 0x23, 0xe7, 0x02, 0xe3, 0x07, 0xf3, 0x22, 0x37, 0xe3, 0x9c, 0x00, 0xbc, + 0x00, 0xec, 0x00, 0x0c, 0x80, 0x3c, 0x00, 0x86, 0x21, 0xa6, 0x06, 0xb6, + 0x24, 0x5c, 0x80, 0x7c, 0x00, 0x9c, 0x00, 0x29, 0xe1, 0xdc, 0x05, 0xf6, + 0x41, 0xdc, 0x80, 0xe8, 0x72, 0x0c, 0x81, 0x27, 0x73, 0x4c, 0x01, 0x66, + 0x74, 0x0d, 0x11, 0x3f, 0x35, 0xb6, 0x41, 0x2c, 0x82, 0x36, 0x40, 0x7c, + 0x02, 0x86, 0x40, 0xf9, 0x61, 0x39, 0xe1, 0xac, 0x04, 0xc6, 0x41, 0x0c, + 0x83, 0x16, 0x41, 0x88, 0xf2, 0x39, 0xf1, 0x7c, 0x00, 0x89, 0x61, 0x9c, + 0x00, 0xa7, 0x63, 0xbc, 0x00, 0xc5, 0x65, 0xdc, 0x00, 0xe3, 0x67, 0xf3, + 0x67, 0x8d, 0xc1, 0xcf, 0x26, 0xfd, 0x55, 0xb1, 0x0f, 0x26, 0xcf, 0x33, + 0x07, 0xb2, 0x15, 0x11, 0x52, 0x42, 0x99, 0x0b, 0xac, 0x02, 0xd3, 0x24, + 0xd6, 0x42, 0xd7, 0x25, 0x23, 0x84, 0xcf, 0x33, 0x07, 0xe3, 0x19, 0x61, + 0x78, 0x7a, 0xef, 0x33, 0x2c, 0x81, 0x46, 0x64, 0x55, 0x65, 0x65, 0x65, + 0xec, 0x74, 0x47, 0x82, 0x53, 0x05, 0x63, 0x21, 0x62, 0x41, 0x96, 0x22, + 0x9a, 0x41, 0xcc, 0x03, 0xb9, 0x91, 0x39, 0xf1, 0x63, 0x26, 0x67, 0x27, + 0xd3, 0x06, 0xfc, 0x01, 0x18, 0xe2, 0xd9, 0x07, 0xe9, 0x04, 0x0c, 0x86, + 0x37, 0x22, 0x93, 0x24, 0x87, 0x84, 0xac, 0x02, 0xc2, 0x41, 0xc3, 0x23, + 0xd9, 0x71, 0xfc, 0x01, 0x7f, 0xb1, 0x9c, 0x00, 0xa7, 0x63, 0xb6, 0x64, + 0xcc, 0x00, 0xd4, 0x66, 0xe3, 0x67, 0xf3, 0x67, 0x8d, 0xc1, 0xcf, 0x26, + 0xfd, 0x50, 0xb1, 0x0f, 0x26, 0xfc, 0x00, 0x1f, 0xb3, 0x5c, 0x00, 0x65, + 0x65, 0x74, 0x66, 0x83, 0x67, 0x93, 0x67, 0xdc, 0x73, 0x4c, 0x80, 0xb3, + 0x20, 0xc9, 0x0b, 0xc3, 0x08, 0xd3, 0x2f, 0xdc, 0x00, 0x2c, 0x80, 0x4c, + 0x00, 0x8c, 0x00, 0xd3, 0x2e, 0xed, 0x4a, 0xfc, 0x00, 0xd7, 0xa1, 0xec, + 0x01, 0x4c, 0x80, 0x59, 0x11, 0xd8, 0x11, 0xda, 0x10, 0x37, 0xa0, 0x47, + 0x04, 0x99, 0x11, 0xe7, 0x21, 0x3a, 0x90, 0x67, 0x20, 0x76, 0x10, 0x77, + 0x60, 0x87, 0x07, 0xd8, 0x12, 0x39, 0xf1, 0xac, 0x00, 0xe9, 0x71, 0x0c, + 0x80, 0x2c, 0x00, 0x4c, 0x05, 0xc7, 0x7b, 0x39, 0xf1, 0xec, 0x00, 0xf9, + 0x11, 0x0c, 0x82, 0x6f, 0x34, 0xf8, 0x11, 0xfa, 0x10, 0x7f, 0xb2, 0xac, + 0x00, 0xb6, 0x64, 0xcc, 0x01, 0xe3, 0x67, 0xf3, 0x67, 0x8d, 0xc1, 0xcf, + 0x26, 0xfd, 0x52, 0xb1, 0x0f, 0x20, 0x6e, 0x45, 0x39, 0x91, 0xb3, 0x04, + 0xc3, 0x21, 0xc8, 0x11, 0xca, 0x10, 0x49, 0x91, 0x7c, 0x73, 0xe8, 0x12, + 0x88, 0x91, 0x8a, 0x10, 0xe7, 0x21, 0x05, 0x91, 0x07, 0x30, 0x17, 0x07, + 0x27, 0x20, 0x49, 0x11, 0x9c, 0x01, 0xc8, 0x72, 0x23, 0xa6, 0x27, 0x26, + 0xd3, 0x03, 0xd8, 0x7a, 0x89, 0x91, 0xd8, 0x72, 0x39, 0xf1, 0xa9, 0x11, + 0x09, 0xf1, 0x63, 0x24, 0x67, 0x24, 0xd8, 0x62, 0x28, 0x91, 0x2a, 0x10, + 0x56, 0x21, 0x70, 0x04, 0x79, 0x0b, 0x8c, 0x00, 0x94, 0x21, 0x9f, 0x35, + 0x2f, 0xb8, 0x3d, 0xc1, 0x7f, 0x26, 0xfd, 0x06, 0xc1, 0x4c, 0x00, 0xf4, + 0x4f, 0x0d, 0x02, 0x06, 0x20, 0x24, 0x4f, 0x35, 0xa0, 0x36, 0x20, 0x53, + 0x46, 0xd5, 0x20, 0xd6, 0x20, 0x34, 0xa1, 0x73, 0x49, 0x74, 0x20, 0x94, + 0x20, 0xb4, 0x20, 0xd4, 0x20, 0xf4, 0x20, 0x2e, 0x80, 0x59, 0x42, 0x4d, + 0xc7, 0xfd, 0x96, 0x31, 0x0f, 0x26, 0x0d, 0x03, 0x1a, 0x60, 0x77, 0x42, + 0xc4, 0x00, 0xc8, 0x62, 0xb9, 0xe1, 0xd3, 0x06, 0xd7, 0x07, 0xf9, 0x61, + 0x0c, 0x81, 0x4e, 0xb1, 0x8e, 0xb1, 0xbc, 0x01, 0xe4, 0x50, 0xe9, 0x61, + 0x0c, 0x81, 0x0d, 0x0a, 0x84, 0x43, 0x98, 0x72, 0x0d, 0x0c, 0x0f, 0x38, + 0x1d, 0xc1, 0x5f, 0x26, 0xfd, 0x48, 0x0f, 0x0e, 0x01, 0x5e, 0x02, 0xa7, + 0x00, 0xbc, 0x73, 0x1a, 0xe0, 0x39, 0x61, 0x58, 0x62, 0x77, 0x63, 0x97, + 0x63, 0xb8, 0x62, 0xd6, 0x07, 0xf8, 0x62, 0x19, 0xe1, 0x75, 0x52, 0x86, + 0x40, 0x87, 0x50, 0x95, 0x52, 0x93, 0x43, 0xa5, 0x21, 0xc5, 0x52, 0xd6, + 0x40, 0xd7, 0x20, 0xe5, 0x06, 0xe6, 0x51, 0x3e, 0x8d, 0x5e, 0x03, 0x67, + 0x52, 0x77, 0x52, 0x7e, 0x02, 0x9e, 0x03, 0xa6, 0x43, 0xa7, 0x23, 0xde, + 0x05, 0xfe, 0x02, 0x1e, 0x83, 0x33, 0x54, 0x46, 0x40, 0x47, 0x21, 0x56, + 0x04, 0x5e, 0x02, 0x83, 0x54, 0x93, 0x52, 0x96, 0x07, 0x97, 0x50, 0xbe, + 0x03, 0xc7, 0x23, 0xfe, 0x02, 0x0c, 0x82, 0x43, 0x45, 0x45, 0x24, 0x46, + 0x24, 0x90, 0x08, 0x95, 0x51, 0x78, 0xfa, 0xd7, 0x73, 0x39, 0xf1, 0x8c, + 0x01, 0xa8, 0x52, 0xb8, 0x52, 0xcc, 0x01, 0x5f, 0xb3, 0x97, 0x63, 0x9e, + 0x00, 0x0e, 0x81, 0x16, 0x24, 0x66, 0x04, 0x8e, 0x00, 0xfe, 0x01, 0x08, + 0xd2, 0x0e, 0x06, 0x6f, 0x47, 0x9e, 0x0f, 0x0e, 0x82, 0x2d, 0x47, 0x28, + 0x7a, 0x68, 0x7a, 0xa8, 0x7a, 0xae, 0x01, 0xde, 0x0f, 0x6d, 0xc5, 0xfd, + 0x48, 0x0f, 0x0e, 0x01, 0x5e, 0x02, 0xbc, 0x01, 0xfc, 0x01, 0x2c, 0x82, + 0x41, 0x52, 0x4e, 0x04, 0x67, 0x25, 0x68, 0x24, 0x69, 0x24, 0xba, 0x42, + 0xc7, 0x04, 0xde, 0x0b, 0xb2, 0x87, 0xfe, 0x02, 0x2c, 0xe1, 0x2c, 0x71, + 0x67, 0x01, 0x77, 0x00, 0x87, 0x01, 0x8e, 0x00, 0xee, 0x01, 0xf6, 0x02, + 0x03, 0x85, 0x05, 0x02, 0x13, 0x21, 0x16, 0x02, 0x27, 0x02, 0x2e, 0x02, + 0x88, 0x72, 0xc7, 0x20, 0xd7, 0x07, 0xe4, 0x76, 0x07, 0xa0, 0x17, 0x06, + 0x48, 0x7a, 0x76, 0x20, 0x98, 0x72, 0x79, 0xe1, 0x88, 0x62, 0x9c, 0x01, + 0xb7, 0x73, 0xdc, 0x01, 0xf8, 0x62, 0xfe, 0x01, 0x08, 0xe2, 0x0e, 0x00, + 0x6e, 0x02, 0x73, 0x20, 0x77, 0x23, 0x83, 0x04, 0x93, 0x20, 0xae, 0x00, + 0xfe, 0x0a, 0x0e, 0x82, 0x39, 0x71, 0xa8, 0x72, 0xe7, 0x73, 0x0c, 0x81, + 0x8f, 0x32, 0xae, 0x00, 0xfe, 0x04, 0x04, 0xd1, 0x17, 0x04, 0x26, 0x49, + 0x27, 0x29, 0xdf, 0x33, 0xfe, 0x02, 0x44, 0xf6, 0x7c, 0x01, 0x8e, 0x06, + 0xbf, 0x47, 0xee, 0x0f, 0x4d, 0xc7, 0x0e, 0x82, 0x68, 0x7a, 0xae, 0x01, + 0xde, 0x0f, 0x6d, 0xc5, 0xfd, 0x48, 0x01, 0x0e, 0x01, 0x00, 0x5a, 0x3e, + 0x06, 0x45, 0x46, 0x47, 0x46, 0x53, 0x44, 0xae, 0x01, 0xdf, 0x4a, 0x4d, + 0xc7, 0x0e, 0x81, 0x00, 0x5a, 0x2e, 0x04, 0x37, 0x28, 0x3a, 0x48, 0x46, + 0x47, 0xc7, 0x07, 0xce, 0x0f, 0xdf, 0x4a, 0x4d, 0xc7, 0x0e, 0x81, 0x00, + 0x5a, 0x33, 0x53, 0x43, 0x51, 0x46, 0x40, 0x47, 0x50, 0x53, 0x04, 0x55, + 0x40, 0x56, 0x50, 0x62, 0x43, 0x64, 0x40, 0x65, 0x50, 0x71, 0x41, 0x73, + 0x51, 0x83, 0x51, 0x94, 0x40, 0x95, 0x50, 0xa3, 0x50, 0xa5, 0x40, 0xa6, + 0x50, 0xb3, 0x51, 0xb6, 0x40, 0xb7, 0x50, 0xc3, 0x53, 0xdf, 0x4a, 0x4d, + 0xc7, 0x0e, 0x81, 0x00, 0x5a, 0x2e, 0x02, 0x36, 0x47, 0x37, 0x52, 0x3a, + 0x49, 0x47, 0x25, 0xa7, 0x52, 0xd7, 0x04, 0xdf, 0x4a, 0x4d, 0xc7, 0x0e, + 0x81, 0x00, 0x5a, 0x3e, 0x02, 0x44, 0x51, 0x53, 0x44, 0x54, 0x44, 0x55, + 0x24, 0xa1, 0x54, 0xae, 0x01, 0xb4, 0x21, 0xdf, 0x4a, 0xe5, 0x07, 0x4d, + 0xc7, 0xfd, 0x41, 0x01, 0xb4, 0x34, 0xc8, 0x52, 0xf2, 0x51, 0x47, 0xd3, + 0x6c, 0x03, 0x65, 0x49, 0x9e, 0x07, 0xbe, 0x01, 0xcc, 0x03, 0xfe, 0x07, + 0x0d, 0xc9, 0x1e, 0x01, 0x6c, 0x01, 0x62, 0x35, 0x63, 0x53, 0x8a, 0x41, + 0xac, 0x01, 0xb3, 0x53, 0xe9, 0x51, 0x26, 0xc3, 0x27, 0x33, 0x63, 0x43, + 0x64, 0x33, 0xba, 0x60, 0xc9, 0x61, 0xce, 0x0b, 0xe5, 0x09, 0xee, 0x0f, + 0x7d, 0xca, 0x7d, 0x47, 0xfd, 0x41, 0x01, 0xb8, 0x52, 0xea, 0x41, 0x27, + 0xb2, 0xb3, 0x42, 0x16, 0xd4, 0x4a, 0x42, 0xa5, 0x51, 0xa7, 0x31, 0x27, + 0xd3, 0x08, 0xe2, 0x16, 0x64, 0x2c, 0x04, 0x38, 0x42, 0x76, 0x64, 0x88, + 0x62, 0xde, 0x07, 0xfe, 0x01, 0x0d, 0xc9, 0x23, 0x32, 0x31, 0x51, 0x98, + 0x52, 0x0d, 0xc9, 0x59, 0x42, 0x63, 0x53, 0x67, 0x31, 0x14, 0xc2, 0x36, + 0x31, 0x87, 0x53, 0x17, 0xe3, 0x29, 0x61, 0x30, 0x62, 0x3c, 0x08, 0x42, + 0x37, 0x59, 0x40, 0x6a, 0x42, 0x99, 0x40, 0xc9, 0x61, 0xd7, 0x63, 0x39, + 0xd1, 0x58, 0x52, 0xc3, 0x67, 0xd3, 0x31, 0xdc, 0x06, 0xf7, 0x42, 0xfa, + 0x42, 0x23, 0xb1, 0x43, 0x67, 0xc3, 0x34, 0xc7, 0x34, 0xd1, 0x51, 0x43, + 0xb3, 0x47, 0x33, 0x9a, 0x30, 0xa9, 0x61, 0xb8, 0x62, 0xbe, 0x0b, 0xd5, + 0x09, 0xde, 0x0f, 0x0d, 0xca, 0x7d, 0x47, 0xfd, 0x49, 0x0f, 0x1e, 0x01, + 0x39, 0x73, 0x5e, 0x07, 0xae, 0x0b, 0x1e, 0x82, 0x6e, 0x88, 0x9e, 0x02, + 0x0d, 0x04, 0x2e, 0x0b, 0x45, 0x09, 0x4e, 0x0f, 0xed, 0x47, 0xfd, 0xff, + 0xad, 0x72, 0x07, 0x20, 0x04, 0x8e, 0xe4, 0x8f, 0x67, 0x85, 0x71, 0x90, + 0xea, 0xae, 0xae, 0x53, 0x07, 0xbd, 0xfc, 0x06, 0x8d, 0xfc, 0x06, 0x20, + 0x4a, 0xb0, 0xad, 0x72, 0x07, 0xc9, 0x03, 0xb0, 0x01, 0x60, 0x20, 0x24, + 0xb6, 0xa2, 0x00, 0x86, 0x08, 0x20, 0x47, 0xc0, 0x20, 0xc3, 0x84, 0xe8, + 0xe0, 0x06, 0xd0, 0xf3, 0x20, 0x80, 0xf1, 0x20, 0x2a, 0xf1, 0x20, 0xe9, + 0xee, 0x20, 0xd4, 0xbe, 0xa2, 0x01, 0x86, 0x08, 0x20, 0x70, 0xbe, 0xca, + 0x86, 0x08, 0x20, 0x70, 0xbe, 0x20, 0x96, 0xbb, 0x20, 0xbc, 0xb9, 0x20, + 0xb8, 0xb7, 0x20, 0x55, 0xb8, 0x20, 0x4f, 0xb7, 0x20, 0xe1, 0x89, 0xa5, + 0xb5, 0xc9, 0x02, 0x10, 0x11, 0xad, 0x9f, 0x07, 0xf0, 0x1e, 0xc9, 0x04, + 0xd0, 0x08, 0xad, 0x7f, 0x07, 0xd0, 0x03, 0x20, 0xed, 0x90, 0xac, 0x9f, + 0x07, 0xa5, 0x09, 0xc0, 0x08, 0xb0, 0x02, 0x4a, 0x4a, 0x4a, 0x20, 0x88, + 0xb2, 0x4c, 0x67, 0xaf, 0x20, 0x9a, 0xb2, 0xa5, 0x0a, 0x85, 0x0d, 0xa9, + 0x00, 0x85, 0x0c, 0xad, 0x73, 0x07, 0xc9, 0x06, 0xf0, 0x1c, 0xad, 0x1f, + 0x07, 0xd0, 0x14, 0xad, 0x3d, 0x07, 0xc9, 0x20, 0x30, 0x10, 0xad, 0x3d, + 0x07, 0xe9, 0x20, 0x8d, 0x3d, 0x07, 0xa9, 0x00, 0x8d, 0x40, 0x03, 0x20, + 0xb0, 0x92, 0x60, 0xad, 0xff, 0x06, 0x18, 0x6d, 0xa1, 0x03, 0x8d, 0xff, + 0x06, 0xad, 0x23, 0x07, 0xd0, 0x59, 0xad, 0x55, 0x07, 0xc9, 0x50, 0x90, + 0x52, 0xad, 0x85, 0x07, 0xd0, 0x4d, 0xac, 0xff, 0x06, 0x88, 0x30, 0x47, + 0xc8, 0xc0, 0x02, 0x90, 0x01, 0x88, 0xad, 0x55, 0x07, 0xc9, 0x70, 0x90, + 0x03, 0xac, 0xff, 0x06, 0x98, 0x8d, 0x75, 0x07, 0x18, 0x6d, 0x3d, 0x07, + 0x8d, 0x3d, 0x07, 0x98, 0x18, 0x6d, 0x1c, 0x07, 0x8d, 0x1c, 0x07, 0x8d, + 0x3f, 0x07, 0xad, 0x1a, 0x07, 0x69, 0x00, 0x8d, 0x1a, 0x07, 0x29, 0x01, + 0x85, 0x00, 0xad, 0x78, 0x07, 0x29, 0xfe, 0x05, 0x00, 0x8d, 0x78, 0x07, + 0x20, 0x38, 0xb0, 0xa9, 0x08, 0x8d, 0x95, 0x07, 0x4c, 0x00, 0xb0, 0xa9, + 0x00, 0x8d, 0x75, 0x07, 0xa2, 0x00, 0x20, 0xf6, 0xf1, 0x85, 0x00, 0xa0, + 0x00, 0x0a, 0xb0, 0x07, 0xc8, 0xa5, 0x00, 0x29, 0x20, 0xf0, 0x1b, 0xb9, + 0x1c, 0x07, 0x38, 0xf9, 0x34, 0xb0, 0x85, 0x86, 0xb9, 0x1a, 0x07, 0xe9, + 0x00, 0x85, 0x6d, 0xa5, 0x0c, 0xd9, 0x36, 0xb0, 0xf0, 0x04, 0xa9, 0x00, + 0x85, 0x57, 0xa9, 0x00, 0x8d, 0xa1, 0x03, 0x60, 0x00, 0x10, 0x01, 0x02, + 0xad, 0x1c, 0x07, 0x18, 0x69, 0xff, 0x8d, 0x1d, 0x07, 0xad, 0x1a, 0x07, + 0x69, 0x00, 0x8d, 0x1b, 0x07, 0x60, 0xa5, 0x0e, 0x20, 0x04, 0x8e, 0x31, + 0x91, 0xc7, 0xb1, 0x06, 0xb2, 0xe5, 0xb1, 0xa4, 0xb2, 0xca, 0xb2, 0xcd, + 0x91, 0x69, 0xb0, 0xe9, 0xb0, 0x33, 0xb2, 0x45, 0xb2, 0x69, 0xb2, 0x7d, + 0xb2, 0xad, 0x52, 0x07, 0xc9, 0x02, 0xf0, 0x2b, 0xa9, 0x00, 0xa4, 0xce, + 0xc0, 0x30, 0x90, 0x6e, 0xad, 0x10, 0x07, 0xc9, 0x06, 0xf0, 0x04, 0xc9, + 0x07, 0xd0, 0x50, 0xad, 0xc4, 0x03, 0xd0, 0x05, 0xa9, 0x01, 0x4c, 0xe6, + 0xb0, 0x20, 0x1f, 0xb2, 0xce, 0xde, 0x06, 0xd0, 0x50, 0xee, 0x69, 0x07, + 0x4c, 0x15, 0xb3, 0xad, 0x58, 0x07, 0xd0, 0x0c, 0xa9, 0xff, 0x20, 0x00, + 0xb2, 0xa5, 0xce, 0xc9, 0x91, 0x90, 0x28, 0x60, 0xad, 0x99, 0x03, 0xc9, + 0x60, 0xd0, 0x32, 0xa5, 0xce, 0xc9, 0x99, 0xa0, 0x00, 0xa9, 0x01, 0x90, + 0x0a, 0xa9, 0x03, 0x85, 0x1d, 0xc8, 0xa9, 0x08, 0x8d, 0xb4, 0x05, 0x8c, + 0x16, 0x07, 0x20, 0xe6, 0xb0, 0xa5, 0x86, 0xc9, 0x48, 0x90, 0x12, 0xa9, + 0x08, 0x85, 0x0e, 0xa9, 0x01, 0x85, 0x33, 0x4a, 0x8d, 0x52, 0x07, 0x8d, + 0x16, 0x07, 0x8d, 0x58, 0x07, 0x60, 0x8d, 0xfc, 0x06, 0xa5, 0x0e, 0xc9, + 0x0b, 0xf0, 0x3c, 0xad, 0x4e, 0x07, 0xd0, 0x10, 0xa4, 0xb5, 0x88, 0xd0, + 0x06, 0xa5, 0xce, 0xc9, 0xd0, 0x90, 0x05, 0xa9, 0x00, 0x8d, 0xfc, 0x06, + 0xad, 0xfc, 0x06, 0x29, 0xc0, 0x85, 0x0a, 0xad, 0xfc, 0x06, 0x29, 0x03, + 0x85, 0x0c, 0xad, 0xfc, 0x06, 0x29, 0x0c, 0x85, 0x0b, 0x29, 0x04, 0xf0, + 0x0e, 0xa5, 0x1d, 0xd0, 0x0a, 0xa4, 0x0c, 0xf0, 0x06, 0xa9, 0x00, 0x85, + 0x0c, 0x85, 0x0b, 0x20, 0x29, 0xb3, 0xa0, 0x01, 0xad, 0x54, 0x07, 0xd0, + 0x09, 0xa0, 0x00, 0xad, 0x14, 0x07, 0xf0, 0x02, 0xa0, 0x02, 0x8c, 0x99, + 0x04, 0xa9, 0x01, 0xa4, 0x57, 0xf0, 0x05, 0x10, 0x01, 0x0a, 0x85, 0x45, + 0x20, 0x93, 0xaf, 0x20, 0x80, 0xf1, 0x20, 0x2a, 0xf1, 0xa2, 0x00, 0x20, + 0x9c, 0xe2, 0x20, 0x64, 0xdc, 0xa5, 0xce, 0xc9, 0x40, 0x90, 0x16, 0xa5, + 0x0e, 0xc9, 0x05, 0xf0, 0x10, 0xc9, 0x07, 0xf0, 0x0c, 0xc9, 0x04, 0x90, + 0x08, 0xad, 0xc4, 0x03, 0x29, 0xdf, 0x8d, 0xc4, 0x03, 0xa5, 0xb5, 0xc9, + 0x02, 0x30, 0x3b, 0xa2, 0x01, 0x8e, 0x23, 0x07, 0xa0, 0x04, 0x84, 0x07, + 0xa2, 0x00, 0xac, 0x59, 0x07, 0xd0, 0x05, 0xac, 0x43, 0x07, 0xd0, 0x16, + 0xe8, 0xa4, 0x0e, 0xc0, 0x0b, 0xf0, 0x0f, 0xac, 0x12, 0x07, 0xd0, 0x06, + 0xc8, 0x84, 0xfc, 0x8c, 0x12, 0x07, 0xa0, 0x06, 0x84, 0x07, 0xc5, 0x07, + 0x30, 0x0c, 0xca, 0x30, 0x0a, 0xac, 0xb1, 0x07, 0xd0, 0x04, 0xa9, 0x06, + 0x85, 0x0e, 0x60, 0xa9, 0x00, 0x8d, 0x58, 0x07, 0x20, 0xdd, 0xb1, 0xee, + 0x52, 0x07, 0x60, 0xa5, 0xb5, 0xd0, 0x06, 0xa5, 0xce, 0xc9, 0xe4, 0x90, + 0x0c, 0xa9, 0x08, 0x8d, 0x58, 0x07, 0xa0, 0x03, 0x84, 0x1d, 0x4c, 0xe6, + 0xb0, 0xa9, 0x02, 0x8d, 0x52, 0x07, 0x4c, 0x13, 0xb2, 0xa9, 0x01, 0x20, + 0x00, 0xb2, 0x20, 0x93, 0xaf, 0xa0, 0x00, 0xad, 0xd6, 0x06, 0xd0, 0x17, + 0xc8, 0xad, 0x4e, 0x07, 0xc9, 0x03, 0xd0, 0x0f, 0xc8, 0x4c, 0x0b, 0xb2, + 0x18, 0x65, 0xce, 0x85, 0xce, 0x60, 0x20, 0x1f, 0xb2, 0xa0, 0x02, 0xce, + 0xde, 0x06, 0xd0, 0x0e, 0x8c, 0x52, 0x07, 0xee, 0x74, 0x07, 0xa9, 0x00, + 0x8d, 0x72, 0x07, 0x8d, 0x22, 0x07, 0x60, 0xa9, 0x08, 0x85, 0x57, 0xa0, + 0x01, 0xa5, 0x86, 0x29, 0x0f, 0xd0, 0x03, 0x85, 0x57, 0xa8, 0x98, 0x20, + 0xe6, 0xb0, 0x60, 0xad, 0x47, 0x07, 0xc9, 0xf8, 0xd0, 0x03, 0x4c, 0x55, + 0xb2, 0xc9, 0xc4, 0xd0, 0x03, 0x20, 0x73, 0xb2, 0x60, 0xad, 0x47, 0x07, + 0xc9, 0xf0, 0xb0, 0x07, 0xc9, 0xc8, 0xf0, 0x23, 0x4c, 0xe9, 0xb0, 0xd0, + 0x13, 0xac, 0x0b, 0x07, 0xd0, 0x0e, 0x8c, 0x0d, 0x07, 0xee, 0x0b, 0x07, + 0xad, 0x54, 0x07, 0x49, 0x01, 0x8d, 0x54, 0x07, 0x60, 0xad, 0x47, 0x07, + 0xc9, 0xf0, 0xb0, 0x33, 0x4c, 0xe9, 0xb0, 0xa9, 0x00, 0x8d, 0x47, 0x07, + 0xa9, 0x08, 0x85, 0x0e, 0x60, 0xad, 0x47, 0x07, 0xc9, 0xc0, 0xf0, 0x13, + 0xa5, 0x09, 0x4a, 0x4a, 0x29, 0x03, 0x85, 0x00, 0xad, 0xc4, 0x03, 0x29, + 0xfc, 0x05, 0x00, 0x8d, 0xc4, 0x03, 0x60, 0x20, 0x73, 0xb2, 0xad, 0xc4, + 0x03, 0x29, 0xfc, 0x8d, 0xc4, 0x03, 0x60, 0x60, 0xa5, 0x1b, 0xc9, 0x30, + 0xd0, 0x15, 0xad, 0x13, 0x07, 0x85, 0xff, 0xa9, 0x00, 0x8d, 0x13, 0x07, + 0xa4, 0xce, 0xc0, 0x9e, 0xb0, 0x02, 0xa9, 0x04, 0x4c, 0xe6, 0xb0, 0xe6, + 0x0e, 0x60, 0x15, 0x23, 0x16, 0x1b, 0x17, 0x18, 0x23, 0x63, 0xa9, 0x01, + 0x20, 0xe6, 0xb0, 0xa5, 0xce, 0xc9, 0xae, 0x90, 0x0e, 0xad, 0x23, 0x07, + 0xf0, 0x09, 0xa9, 0x20, 0x85, 0xfc, 0xa9, 0x00, 0x8d, 0x23, 0x07, 0xad, + 0x90, 0x04, 0x4a, 0xb0, 0x0d, 0xad, 0x46, 0x07, 0xd0, 0x03, 0xee, 0x46, + 0x07, 0xa9, 0x20, 0x8d, 0xc4, 0x03, 0xad, 0x46, 0x07, 0xc9, 0x05, 0xd0, + 0x2b, 0xee, 0x5c, 0x07, 0xad, 0x5c, 0x07, 0xc9, 0x03, 0xd0, 0x0e, 0xac, + 0x5f, 0x07, 0xad, 0x48, 0x07, 0xd9, 0xc2, 0xb2, 0x90, 0x03, 0xee, 0x5d, + 0x07, 0xee, 0x60, 0x07, 0x20, 0x03, 0x9c, 0xee, 0x57, 0x07, 0x20, 0x13, + 0xb2, 0x8d, 0x5b, 0x07, 0xa9, 0x80, 0x85, 0xfc, 0x60, 0xa9, 0x00, 0xac, + 0x54, 0x07, 0xd0, 0x08, 0xa5, 0x1d, 0xd0, 0x07, 0xa5, 0x0b, 0x29, 0x04, + 0x8d, 0x14, 0x07, 0x20, 0x50, 0xb4, 0xad, 0x0b, 0x07, 0xd0, 0x16, 0xa5, + 0x1d, 0xc9, 0x03, 0xf0, 0x05, 0xa0, 0x18, 0x8c, 0x89, 0x07, 0x20, 0x04, + 0x8e, 0x5a, 0xb3, 0x76, 0xb3, 0x6d, 0xb3, 0xcf, 0xb3, 0x60, 0x20, 0x8f, + 0xb5, 0xa5, 0x0c, 0xf0, 0x02, 0x85, 0x33, 0x20, 0xcc, 0xb5, 0x20, 0x09, + 0xbf, 0x8d, 0xff, 0x06, 0x60, 0xad, 0x0a, 0x07, 0x8d, 0x09, 0x07, 0x4c, + 0xac, 0xb3, 0xa4, 0x9f, 0x10, 0x13, 0xa5, 0x0a, 0x29, 0x80, 0x25, 0x0d, + 0xd0, 0x11, 0xad, 0x08, 0x07, 0x38, 0xe5, 0xce, 0xcd, 0x06, 0x07, 0x90, + 0x06, 0xad, 0x0a, 0x07, 0x8d, 0x09, 0x07, 0xad, 0x04, 0x07, 0xf0, 0x14, + 0x20, 0x8f, 0xb5, 0xa5, 0xce, 0xc9, 0x14, 0xb0, 0x05, 0xa9, 0x18, 0x8d, + 0x09, 0x07, 0xa5, 0x0c, 0xf0, 0x02, 0x85, 0x33, 0xa5, 0x0c, 0xf0, 0x03, + 0x20, 0xcc, 0xb5, 0x20, 0x09, 0xbf, 0x8d, 0xff, 0x06, 0xa5, 0x0e, 0xc9, + 0x0b, 0xd0, 0x05, 0xa9, 0x28, 0x8d, 0x09, 0x07, 0x4c, 0x4d, 0xbf, 0x0e, + 0x04, 0xfc, 0xf2, 0x00, 0x00, 0xff, 0xff, 0xad, 0x16, 0x04, 0x18, 0x6d, + 0x33, 0x04, 0x8d, 0x16, 0x04, 0xa0, 0x00, 0xa5, 0x9f, 0x10, 0x01, 0x88, + 0x84, 0x00, 0x65, 0xce, 0x85, 0xce, 0xa5, 0xb5, 0x65, 0x00, 0x85, 0xb5, + 0xa5, 0x0c, 0x2d, 0x90, 0x04, 0xf0, 0x2d, 0xac, 0x89, 0x07, 0xd0, 0x27, + 0xa0, 0x18, 0x8c, 0x89, 0x07, 0xa2, 0x00, 0xa4, 0x33, 0x4a, 0xb0, 0x02, + 0xe8, 0xe8, 0x88, 0xf0, 0x01, 0xe8, 0xa5, 0x86, 0x18, 0x7d, 0xc7, 0xb3, + 0x85, 0x86, 0xa5, 0x6d, 0x7d, 0xcb, 0xb3, 0x85, 0x6d, 0xa5, 0x0c, 0x49, + 0x03, 0x85, 0x33, 0x60, 0x8d, 0x89, 0x07, 0x60, 0x20, 0x20, 0x1e, 0x28, + 0x28, 0x0d, 0x04, 0x70, 0x70, 0x60, 0x90, 0x90, 0x0a, 0x09, 0xfc, 0xfc, + 0xfc, 0xfb, 0xfb, 0xfe, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, + 0xd8, 0xe8, 0xf0, 0x28, 0x18, 0x10, 0x0c, 0xe4, 0x98, 0xd0, 0x00, 0xff, + 0x01, 0x00, 0x20, 0xff, 0xa5, 0x1d, 0xc9, 0x03, 0xd0, 0x23, 0xa0, 0x00, + 0xa5, 0x0b, 0x2d, 0x90, 0x04, 0xf0, 0x06, 0xc8, 0x29, 0x08, 0xd0, 0x01, + 0xc8, 0xbe, 0x4d, 0xb4, 0x8e, 0x33, 0x04, 0xa9, 0x08, 0xbe, 0x4a, 0xb4, + 0x86, 0x9f, 0x30, 0x01, 0x4a, 0x8d, 0x0c, 0x07, 0x60, 0xad, 0x0e, 0x07, + 0xd0, 0x0a, 0xa5, 0x0a, 0x29, 0x80, 0xf0, 0x04, 0x25, 0x0d, 0xf0, 0x03, + 0x4c, 0x1c, 0xb5, 0xa5, 0x1d, 0xf0, 0x11, 0xad, 0x04, 0x07, 0xf0, 0xf4, + 0xad, 0x82, 0x07, 0xd0, 0x07, 0xa5, 0x9f, 0x10, 0x03, 0x4c, 0x1c, 0xb5, + 0xa9, 0x20, 0x8d, 0x82, 0x07, 0xa0, 0x00, 0x8c, 0x16, 0x04, 0x8c, 0x33, + 0x04, 0xa5, 0xb5, 0x8d, 0x07, 0x07, 0xa5, 0xce, 0x8d, 0x08, 0x07, 0xa9, + 0x01, 0x85, 0x1d, 0xad, 0x00, 0x07, 0xc9, 0x09, 0x90, 0x10, 0xc8, 0xc9, + 0x10, 0x90, 0x0b, 0xc8, 0xc9, 0x19, 0x90, 0x06, 0xc8, 0xc9, 0x1c, 0x90, + 0x01, 0xc8, 0xa9, 0x01, 0x8d, 0x06, 0x07, 0xad, 0x04, 0x07, 0xf0, 0x08, + 0xa0, 0x05, 0xad, 0x7d, 0x04, 0xf0, 0x01, 0xc8, 0xb9, 0x24, 0xb4, 0x8d, + 0x09, 0x07, 0xb9, 0x2b, 0xb4, 0x8d, 0x0a, 0x07, 0xb9, 0x39, 0xb4, 0x8d, + 0x33, 0x04, 0xb9, 0x32, 0xb4, 0x85, 0x9f, 0xad, 0x04, 0x07, 0xf0, 0x11, + 0xa9, 0x04, 0x85, 0xff, 0xa5, 0xce, 0xc9, 0x14, 0xb0, 0x12, 0xa9, 0x00, + 0x85, 0x9f, 0x4c, 0x1c, 0xb5, 0xa9, 0x01, 0xac, 0x54, 0x07, 0xf0, 0x02, + 0xa9, 0x80, 0x85, 0xff, 0xa0, 0x00, 0x84, 0x00, 0xa5, 0x1d, 0xf0, 0x09, + 0xad, 0x00, 0x07, 0xc9, 0x19, 0xb0, 0x33, 0x90, 0x18, 0xc8, 0xad, 0x4e, + 0x07, 0xf0, 0x12, 0x88, 0xa5, 0x0c, 0xc5, 0x45, 0xd0, 0x0b, 0xa5, 0x0a, + 0x29, 0x40, 0xd0, 0x19, 0xad, 0x83, 0x07, 0xd0, 0x19, 0xc8, 0xe6, 0x00, + 0xad, 0x03, 0x07, 0xd0, 0x07, 0xad, 0x00, 0x07, 0xc9, 0x21, 0x90, 0x0a, + 0xe6, 0x00, 0x4c, 0x5e, 0xb5, 0xa9, 0x0a, 0x8d, 0x83, 0x07, 0xb9, 0x40, + 0xb4, 0x8d, 0x50, 0x04, 0xa5, 0x0e, 0xc9, 0x07, 0xd0, 0x02, 0xa0, 0x03, + 0xb9, 0x43, 0xb4, 0x8d, 0x56, 0x04, 0xa4, 0x00, 0xb9, 0x47, 0xb4, 0x8d, + 0x02, 0x07, 0xa9, 0x00, 0x8d, 0x01, 0x07, 0xa5, 0x33, 0xc5, 0x45, 0xf0, + 0x06, 0x0e, 0x02, 0x07, 0x2e, 0x01, 0x07, 0x60, 0x02, 0x04, 0x07, 0xa0, + 0x00, 0xad, 0x00, 0x07, 0xc9, 0x1c, 0xb0, 0x15, 0xc8, 0xc9, 0x0e, 0xb0, + 0x01, 0xc8, 0xad, 0xfc, 0x06, 0x29, 0x7f, 0xf0, 0x20, 0x29, 0x03, 0xc5, + 0x45, 0xd0, 0x08, 0xa9, 0x00, 0x8d, 0x03, 0x07, 0x4c, 0xc5, 0xb5, 0xad, + 0x00, 0x07, 0xc9, 0x0b, 0xb0, 0x0b, 0xa5, 0x33, 0x85, 0x45, 0xa9, 0x00, + 0x85, 0x57, 0x8d, 0x05, 0x07, 0xb9, 0x8c, 0xb5, 0x8d, 0x0c, 0x07, 0x60, + 0x2d, 0x90, 0x04, 0xc9, 0x00, 0xd0, 0x08, 0xa5, 0x57, 0xf0, 0x49, 0x10, + 0x23, 0x30, 0x03, 0x4a, 0x90, 0x1e, 0xad, 0x05, 0x07, 0x18, 0x6d, 0x02, + 0x07, 0x8d, 0x05, 0x07, 0xa5, 0x57, 0x6d, 0x01, 0x07, 0x85, 0x57, 0xcd, + 0x56, 0x04, 0x30, 0x23, 0xad, 0x56, 0x04, 0x85, 0x57, 0x4c, 0x20, 0xb6, + 0xad, 0x05, 0x07, 0x38, 0xed, 0x02, 0x07, 0x8d, 0x05, 0x07, 0xa5, 0x57, + 0xed, 0x01, 0x07, 0x85, 0x57, 0xcd, 0x50, 0x04, 0x10, 0x05, 0xad, 0x50, + 0x04, 0x85, 0x57, 0xc9, 0x00, 0x10, 0x05, 0x49, 0xff, 0x18, 0x69, 0x01, + 0x8d, 0x00, 0x07, 0x60, 0xad, 0x56, 0x07, 0xc9, 0x02, 0x90, 0x43, 0xa5, + 0x0a, 0x29, 0x40, 0xf0, 0x33, 0x25, 0x0d, 0xd0, 0x2f, 0xad, 0xce, 0x06, + 0x29, 0x01, 0xaa, 0xb5, 0x24, 0xd0, 0x25, 0xa4, 0xb5, 0x88, 0xd0, 0x20, + 0xad, 0x14, 0x07, 0xd0, 0x1b, 0xa5, 0x1d, 0xc9, 0x03, 0xf0, 0x15, 0xa9, + 0x20, 0x85, 0xff, 0xa9, 0x02, 0x95, 0x24, 0xac, 0x0c, 0x07, 0x8c, 0x11, + 0x07, 0x88, 0x8c, 0x81, 0x07, 0xee, 0xce, 0x06, 0xa2, 0x00, 0x20, 0x89, + 0xb6, 0xa2, 0x01, 0x20, 0x89, 0xb6, 0xad, 0x4e, 0x07, 0xd0, 0x13, 0xa2, + 0x02, 0x86, 0x08, 0x20, 0xf9, 0xb6, 0x20, 0x31, 0xf1, 0x20, 0x91, 0xf1, + 0x20, 0xe1, 0xed, 0xca, 0x10, 0xef, 0x60, 0x40, 0xc0, 0x86, 0x08, 0xb5, + 0x24, 0x0a, 0xb0, 0x63, 0xb4, 0x24, 0xf0, 0x5e, 0x88, 0xf0, 0x27, 0xa5, + 0x86, 0x69, 0x04, 0x95, 0x8d, 0xa5, 0x6d, 0x69, 0x00, 0x95, 0x74, 0xa5, + 0xce, 0x95, 0xd5, 0xa9, 0x01, 0x95, 0xbc, 0xa4, 0x33, 0x88, 0xb9, 0x87, + 0xb6, 0x95, 0x5e, 0xa9, 0x04, 0x95, 0xa6, 0xa9, 0x07, 0x9d, 0xa0, 0x04, + 0xd6, 0x24, 0x8a, 0x18, 0x69, 0x07, 0xaa, 0xa9, 0x50, 0x85, 0x00, 0xa9, + 0x03, 0x85, 0x02, 0xa9, 0x00, 0x20, 0xd7, 0xbf, 0x20, 0x0f, 0xbf, 0xa6, + 0x08, 0x20, 0x3b, 0xf1, 0x20, 0x87, 0xf1, 0x20, 0x2d, 0xe2, 0x20, 0xc8, + 0xe1, 0xad, 0xd2, 0x03, 0x29, 0xcc, 0xd0, 0x06, 0x20, 0xd9, 0xd6, 0x4c, + 0xde, 0xec, 0xa9, 0x00, 0x95, 0x24, 0x60, 0x20, 0x3b, 0xf1, 0x4c, 0x09, + 0xed, 0xbd, 0xa8, 0x07, 0x29, 0x01, 0x85, 0x07, 0xb5, 0xe4, 0xc9, 0xf8, + 0xd0, 0x2c, 0xad, 0x92, 0x07, 0xd0, 0x3f, 0xa0, 0x00, 0xa5, 0x33, 0x4a, + 0x90, 0x02, 0xa0, 0x08, 0x98, 0x65, 0x86, 0x95, 0x9c, 0xa5, 0x6d, 0x69, + 0x00, 0x95, 0x83, 0xa5, 0xce, 0x18, 0x69, 0x08, 0x95, 0xe4, 0xa9, 0x01, + 0x95, 0xcb, 0xa4, 0x07, 0xb9, 0x4d, 0xb7, 0x8d, 0x92, 0x07, 0xa4, 0x07, + 0xbd, 0x2c, 0x04, 0x38, 0xf9, 0x4b, 0xb7, 0x9d, 0x2c, 0x04, 0xb5, 0xe4, + 0xe9, 0x00, 0xc9, 0x20, 0xb0, 0x02, 0xa9, 0xf8, 0x95, 0xe4, 0x60, 0xff, + 0x50, 0x40, 0x20, 0xad, 0x70, 0x07, 0xf0, 0x4f, 0xa5, 0x0e, 0xc9, 0x08, + 0x90, 0x49, 0xc9, 0x0b, 0xf0, 0x45, 0xa5, 0xb5, 0xc9, 0x02, 0xb0, 0x3f, + 0xad, 0x87, 0x07, 0xd0, 0x3a, 0xad, 0xf8, 0x07, 0x0d, 0xf9, 0x07, 0x0d, + 0xfa, 0x07, 0xf0, 0x26, 0xac, 0xf8, 0x07, 0x88, 0xd0, 0x0c, 0xad, 0xf9, + 0x07, 0x0d, 0xfa, 0x07, 0xd0, 0x04, 0xa9, 0x40, 0x85, 0xfc, 0xa9, 0x18, + 0x8d, 0x87, 0x07, 0xa0, 0x23, 0xa9, 0xff, 0x8d, 0x39, 0x01, 0x20, 0x5f, + 0x8f, 0xa9, 0xa4, 0x4c, 0x06, 0x8f, 0x8d, 0x56, 0x07, 0x20, 0x31, 0xd9, + 0xee, 0x59, 0x07, 0x60, 0xad, 0x23, 0x07, 0xf0, 0xfa, 0xa5, 0xce, 0x25, + 0xb5, 0xd0, 0xf4, 0x8d, 0x23, 0x07, 0xee, 0xd6, 0x06, 0x4c, 0x98, 0xc9, + 0xad, 0x4e, 0x07, 0xd0, 0x37, 0x8d, 0x7d, 0x04, 0xad, 0x47, 0x07, 0xd0, + 0x2f, 0xa0, 0x04, 0xb9, 0x71, 0x04, 0x18, 0x79, 0x77, 0x04, 0x85, 0x02, + 0xb9, 0x6b, 0x04, 0xf0, 0x1c, 0x69, 0x00, 0x85, 0x01, 0xa5, 0x86, 0x38, + 0xf9, 0x71, 0x04, 0xa5, 0x6d, 0xf9, 0x6b, 0x04, 0x30, 0x0b, 0xa5, 0x02, + 0x38, 0xe5, 0x86, 0xa5, 0x01, 0xe5, 0x6d, 0x10, 0x04, 0x88, 0x10, 0xd3, + 0x60, 0xb9, 0x77, 0x04, 0x4a, 0x85, 0x00, 0xb9, 0x71, 0x04, 0x18, 0x65, + 0x00, 0x85, 0x01, 0xb9, 0x6b, 0x04, 0x69, 0x00, 0x85, 0x00, 0xa5, 0x09, + 0x4a, 0x90, 0x2c, 0xa5, 0x01, 0x38, 0xe5, 0x86, 0xa5, 0x00, 0xe5, 0x6d, + 0x10, 0x0e, 0xa5, 0x86, 0x38, 0xe9, 0x01, 0x85, 0x86, 0xa5, 0x6d, 0xe9, + 0x00, 0x4c, 0x39, 0xb8, 0xad, 0x90, 0x04, 0x4a, 0x90, 0x0d, 0xa5, 0x86, + 0x18, 0x69, 0x01, 0x85, 0x86, 0xa5, 0x6d, 0x69, 0x00, 0x85, 0x6d, 0xa9, + 0x10, 0x85, 0x00, 0xa9, 0x01, 0x8d, 0x7d, 0x04, 0x85, 0x02, 0x4a, 0xaa, + 0x4c, 0xd7, 0xbf, 0x05, 0x02, 0x08, 0x04, 0x01, 0x03, 0x03, 0x04, 0x04, + 0x04, 0xa2, 0x05, 0x86, 0x08, 0xb5, 0x16, 0xc9, 0x30, 0xd0, 0x56, 0xa5, + 0x0e, 0xc9, 0x04, 0xd0, 0x31, 0xa5, 0x1d, 0xc9, 0x03, 0xd0, 0x2b, 0xb5, + 0xcf, 0xc9, 0xaa, 0xb0, 0x28, 0xa5, 0xce, 0xc9, 0xa2, 0xb0, 0x22, 0xbd, + 0x17, 0x04, 0x69, 0xff, 0x9d, 0x17, 0x04, 0xb5, 0xcf, 0x69, 0x01, 0x95, + 0xcf, 0xad, 0x0e, 0x01, 0x38, 0xe9, 0xff, 0x8d, 0x0e, 0x01, 0xad, 0x0d, + 0x01, 0xe9, 0x01, 0x8d, 0x0d, 0x01, 0x4c, 0xac, 0xb8, 0xac, 0x0f, 0x01, + 0xb9, 0x4b, 0xb8, 0xbe, 0x50, 0xb8, 0x9d, 0x34, 0x01, 0x20, 0x27, 0xbc, + 0xa9, 0x05, 0x85, 0x0e, 0x20, 0xaf, 0xf1, 0x20, 0x52, 0xf1, 0x20, 0x4b, + 0xe5, 0x60, 0x08, 0x10, 0x08, 0x00, 0x20, 0xaf, 0xf1, 0xad, 0x47, 0x07, + 0xd0, 0x40, 0xad, 0x0e, 0x07, 0xf0, 0x3b, 0xa8, 0x88, 0x98, 0x29, 0x02, + 0xd0, 0x07, 0xe6, 0xce, 0xe6, 0xce, 0x4c, 0xd9, 0xb8, 0xc6, 0xce, 0xc6, + 0xce, 0xb5, 0x58, 0x18, 0x79, 0xb6, 0xb8, 0x95, 0xcf, 0xc0, 0x01, 0x90, + 0x0f, 0xa5, 0x0a, 0x29, 0x80, 0xf0, 0x09, 0x25, 0x0d, 0xd0, 0x05, 0xa9, + 0xf4, 0x8d, 0xdb, 0x06, 0xc0, 0x03, 0xd0, 0x0a, 0xad, 0xdb, 0x06, 0x85, + 0x9f, 0xa9, 0x00, 0x8d, 0x0e, 0x07, 0x20, 0x52, 0xf1, 0x20, 0x7d, 0xe8, + 0x20, 0x7a, 0xd6, 0xad, 0x0e, 0x07, 0xf0, 0x0d, 0xad, 0x86, 0x07, 0xd0, + 0x08, 0xa9, 0x04, 0x8d, 0x86, 0x07, 0xee, 0x0e, 0x07, 0x60, 0xa9, 0x2f, + 0x95, 0x16, 0xa9, 0x01, 0x95, 0x0f, 0xb9, 0x76, 0x00, 0x95, 0x6e, 0xb9, + 0x8f, 0x00, 0x95, 0x87, 0xb9, 0xd7, 0x00, 0x95, 0xcf, 0xac, 0x98, 0x03, + 0xd0, 0x03, 0x8d, 0x9d, 0x03, 0x8a, 0x99, 0x9a, 0x03, 0xee, 0x98, 0x03, + 0xa9, 0x04, 0x85, 0xfe, 0x60, 0x30, 0x60, 0xe0, 0x05, 0xd0, 0x68, 0xac, + 0x98, 0x03, 0x88, 0xad, 0x99, 0x03, 0xd9, 0x49, 0xb9, 0xf0, 0x0f, 0xa5, + 0x09, 0x4a, 0x4a, 0x90, 0x09, 0xa5, 0xd4, 0xe9, 0x01, 0x85, 0xd4, 0xee, + 0x99, 0x03, 0xad, 0x99, 0x03, 0xc9, 0x08, 0x90, 0x46, 0x20, 0x52, 0xf1, + 0x20, 0xaf, 0xf1, 0xa0, 0x00, 0x20, 0x35, 0xe4, 0xc8, 0xcc, 0x98, 0x03, + 0xd0, 0xf7, 0xad, 0xd1, 0x03, 0x29, 0x0c, 0xf0, 0x10, 0x88, 0xbe, 0x9a, + 0x03, 0x20, 0x98, 0xc9, 0x88, 0x10, 0xf7, 0x8d, 0x98, 0x03, 0x8d, 0x99, + 0x03, 0xad, 0x99, 0x03, 0xc9, 0x20, 0x90, 0x17, 0xa2, 0x06, 0xa9, 0x01, + 0xa0, 0x1b, 0x20, 0xf0, 0xe3, 0xa4, 0x02, 0xc0, 0xd0, 0xb0, 0x08, 0xb1, + 0x06, 0xd0, 0x04, 0xa9, 0x26, 0x91, 0x06, 0xa6, 0x08, 0x60, 0x0f, 0x07, + 0xad, 0x4e, 0x07, 0xf0, 0x6f, 0xa2, 0x02, 0x86, 0x08, 0xb5, 0x0f, 0xd0, + 0x51, 0xbd, 0xa8, 0x07, 0xac, 0xcc, 0x06, 0x39, 0xba, 0xb9, 0xc9, 0x06, + 0xb0, 0x44, 0xa8, 0xb9, 0x6b, 0x04, 0xf0, 0x3e, 0xb9, 0x7d, 0x04, 0xf0, + 0x08, 0xe9, 0x00, 0x99, 0x7d, 0x04, 0x4c, 0x1a, 0xba, 0xad, 0x47, 0x07, + 0xd0, 0x2c, 0xa9, 0x0e, 0x99, 0x7d, 0x04, 0xb9, 0x6b, 0x04, 0x95, 0x6e, + 0xb9, 0x71, 0x04, 0x95, 0x87, 0xb9, 0x77, 0x04, 0x38, 0xe9, 0x08, 0x95, + 0xcf, 0xa9, 0x01, 0x95, 0xb6, 0x95, 0x0f, 0x4a, 0x95, 0x1e, 0xa9, 0x09, + 0x9d, 0x9a, 0x04, 0xa9, 0x33, 0x95, 0x16, 0x4c, 0x2d, 0xba, 0xb5, 0x16, + 0xc9, 0x33, 0xd0, 0x0d, 0x20, 0x7a, 0xd6, 0xb5, 0x0f, 0xf0, 0x06, 0x20, + 0xaf, 0xf1, 0x20, 0x33, 0xba, 0xca, 0x10, 0x93, 0x60, 0x18, 0xe8, 0xad, + 0x47, 0x07, 0xd0, 0x3e, 0xb5, 0x1e, 0xd0, 0x2e, 0xad, 0xd1, 0x03, 0x29, + 0x0c, 0xc9, 0x0c, 0xf0, 0x40, 0xa0, 0x01, 0x20, 0x43, 0xe1, 0x30, 0x01, + 0xc8, 0x94, 0x46, 0x88, 0xb9, 0x31, 0xba, 0x95, 0x58, 0xa5, 0x00, 0x69, + 0x28, 0xc9, 0x50, 0x90, 0x28, 0xa9, 0x01, 0x95, 0x1e, 0xa9, 0x0a, 0x9d, + 0x8a, 0x07, 0xa9, 0x08, 0x85, 0xfe, 0xb5, 0x1e, 0x29, 0x20, 0xf0, 0x03, + 0x20, 0x63, 0xbf, 0x20, 0x02, 0xbf, 0x20, 0xaf, 0xf1, 0x20, 0x52, 0xf1, + 0x20, 0x43, 0xe2, 0x20, 0x53, 0xd8, 0x4c, 0x7d, 0xe8, 0x20, 0x98, 0xc9, + 0x60, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x06, 0x06, 0x06, 0x10, 0xf0, + 0xad, 0xa8, 0x07, 0x29, 0x07, 0xd0, 0x05, 0xad, 0xa8, 0x07, 0x29, 0x08, + 0xa8, 0xb9, 0x2a, 0x00, 0xd0, 0x19, 0xbe, 0x89, 0xba, 0xb5, 0x0f, 0xd0, + 0x12, 0xa6, 0x08, 0x8a, 0x99, 0xae, 0x06, 0xa9, 0x90, 0x99, 0x2a, 0x00, + 0xa9, 0x07, 0x99, 0xa2, 0x04, 0x38, 0x60, 0xa6, 0x08, 0x18, 0x60, 0xad, + 0x47, 0x07, 0xd0, 0x63, 0xb5, 0x2a, 0x29, 0x7f, 0xbc, 0xae, 0x06, 0xc9, + 0x02, 0xf0, 0x20, 0xb0, 0x34, 0x8a, 0x18, 0x69, 0x0d, 0xaa, 0xa9, 0x10, + 0x85, 0x00, 0xa9, 0x0f, 0x85, 0x01, 0xa9, 0x04, 0x85, 0x02, 0xa9, 0x00, + 0x20, 0xd7, 0xbf, 0x20, 0x0f, 0xbf, 0xa6, 0x08, 0x4c, 0x28, 0xbb, 0xa9, + 0xfe, 0x95, 0xac, 0xb9, 0x1e, 0x00, 0x29, 0xf7, 0x99, 0x1e, 0x00, 0xb6, + 0x46, 0xca, 0xbd, 0x92, 0xba, 0xa6, 0x08, 0x95, 0x64, 0xd6, 0x2a, 0xb9, + 0x87, 0x00, 0x18, 0x69, 0x02, 0x95, 0x93, 0xb9, 0x6e, 0x00, 0x69, 0x00, + 0x95, 0x7a, 0xb9, 0xcf, 0x00, 0x38, 0xe9, 0x0a, 0x95, 0xdb, 0xa9, 0x01, + 0x95, 0xc2, 0xd0, 0x03, 0x20, 0xc4, 0xd7, 0x20, 0x9b, 0xf1, 0x20, 0x48, + 0xf1, 0x20, 0x36, 0xe2, 0x20, 0xdc, 0xe4, 0x60, 0x20, 0x84, 0xbb, 0xb5, + 0x76, 0x99, 0x7a, 0x00, 0xb5, 0x8f, 0x09, 0x05, 0x99, 0x93, 0x00, 0xb5, + 0xd7, 0xe9, 0x10, 0x99, 0xdb, 0x00, 0x4c, 0x6c, 0xbb, 0x20, 0x84, 0xbb, + 0xbd, 0xea, 0x03, 0x99, 0x7a, 0x00, 0xa5, 0x06, 0x0a, 0x0a, 0x0a, 0x0a, + 0x09, 0x05, 0x99, 0x93, 0x00, 0xa5, 0x02, 0x69, 0x20, 0x99, 0xdb, 0x00, + 0xa9, 0xfb, 0x99, 0xac, 0x00, 0xa9, 0x01, 0x99, 0xc2, 0x00, 0x99, 0x2a, + 0x00, 0x85, 0xfe, 0x86, 0x08, 0x20, 0xfe, 0xbb, 0xee, 0x48, 0x07, 0x60, + 0xa0, 0x08, 0xb9, 0x2a, 0x00, 0xf0, 0x07, 0x88, 0xc0, 0x05, 0xd0, 0xf6, + 0xa0, 0x08, 0x8c, 0xb7, 0x06, 0x60, 0xa2, 0x08, 0x86, 0x08, 0xb5, 0x2a, + 0xf0, 0x56, 0x0a, 0x90, 0x06, 0x20, 0xc3, 0xba, 0x4c, 0xf4, 0xbb, 0xb4, + 0x2a, 0x88, 0xf0, 0x1d, 0xf6, 0x2a, 0xb5, 0x93, 0x18, 0x6d, 0x75, 0x07, + 0x95, 0x93, 0xb5, 0x7a, 0x69, 0x00, 0x95, 0x7a, 0xb5, 0x2a, 0xc9, 0x30, + 0xd0, 0x26, 0xa9, 0x00, 0x95, 0x2a, 0x4c, 0xf4, 0xbb, 0x8a, 0x18, 0x69, + 0x0d, 0xaa, 0xa9, 0x50, 0x85, 0x00, 0xa9, 0x06, 0x85, 0x02, 0x4a, 0x85, + 0x01, 0xa9, 0x00, 0x20, 0xd7, 0xbf, 0xa6, 0x08, 0xb5, 0xac, 0xc9, 0x05, + 0xd0, 0x02, 0xf6, 0x2a, 0x20, 0x48, 0xf1, 0x20, 0x9b, 0xf1, 0x20, 0x36, + 0xe2, 0x20, 0x86, 0xe6, 0xca, 0x10, 0xa1, 0x60, 0x17, 0x1d, 0x0b, 0x11, + 0x02, 0x13, 0xa9, 0x01, 0x8d, 0x39, 0x01, 0xae, 0x53, 0x07, 0xbc, 0xf8, + 0xbb, 0x20, 0x5f, 0x8f, 0xee, 0x5e, 0x07, 0xad, 0x5e, 0x07, 0xc9, 0x64, + 0xd0, 0x0c, 0xa9, 0x00, 0x8d, 0x5e, 0x07, 0xee, 0x5a, 0x07, 0xa9, 0x40, + 0x85, 0xfe, 0xa9, 0x02, 0x8d, 0x38, 0x01, 0xae, 0x53, 0x07, 0xbc, 0xfa, + 0xbb, 0x20, 0x5f, 0x8f, 0xac, 0x53, 0x07, 0xb9, 0xfc, 0xbb, 0x20, 0x06, + 0x8f, 0xac, 0x00, 0x03, 0xb9, 0xfb, 0x02, 0xd0, 0x05, 0xa9, 0x24, 0x99, + 0xfb, 0x02, 0xa6, 0x08, 0x60, 0xa9, 0x2e, 0x85, 0x1b, 0xb5, 0x76, 0x85, + 0x73, 0xb5, 0x8f, 0x85, 0x8c, 0xa9, 0x01, 0x85, 0xbb, 0xb5, 0xd7, 0x38, + 0xe9, 0x08, 0x85, 0xd4, 0xa9, 0x01, 0x85, 0x23, 0x85, 0x14, 0xa9, 0x03, + 0x8d, 0x9f, 0x04, 0xa5, 0x39, 0xc9, 0x02, 0xb0, 0x0a, 0xad, 0x56, 0x07, + 0xc9, 0x02, 0x90, 0x01, 0x4a, 0x85, 0x39, 0xa9, 0x20, 0x8d, 0xca, 0x03, + 0xa9, 0x02, 0x85, 0xfe, 0x60, 0xa2, 0x05, 0x86, 0x08, 0xa5, 0x23, 0xf0, + 0x5d, 0x0a, 0x90, 0x23, 0xad, 0x47, 0x07, 0xd0, 0x43, 0xa5, 0x39, 0xf0, + 0x11, 0xc9, 0x03, 0xf0, 0x0d, 0xc9, 0x02, 0xd0, 0x37, 0x20, 0xf9, 0xca, + 0x20, 0x63, 0xe1, 0x4c, 0xd8, 0xbc, 0x20, 0x77, 0xca, 0x20, 0xc1, 0xdf, + 0x4c, 0xd8, 0xbc, 0xa5, 0x09, 0x29, 0x03, 0xd0, 0x19, 0xc6, 0xd4, 0xa5, + 0x23, 0xe6, 0x23, 0xc9, 0x11, 0x90, 0x0f, 0xa9, 0x10, 0x95, 0x58, 0xa9, + 0x80, 0x85, 0x23, 0x0a, 0x8d, 0xca, 0x03, 0x2a, 0x95, 0x46, 0xa5, 0x23, + 0xc9, 0x06, 0x90, 0x12, 0x20, 0x52, 0xf1, 0x20, 0xaf, 0xf1, 0x20, 0x43, + 0xe2, 0x20, 0xd2, 0xe6, 0x20, 0x53, 0xd8, 0x20, 0x7a, 0xd6, 0x60, 0x04, + 0x12, 0x48, 0xa9, 0x11, 0xae, 0xee, 0x03, 0xac, 0x54, 0x07, 0xd0, 0x02, + 0xa9, 0x12, 0x95, 0x26, 0x20, 0x6b, 0x8a, 0xae, 0xee, 0x03, 0xa5, 0x02, + 0x9d, 0xe4, 0x03, 0xa8, 0xa5, 0x06, 0x9d, 0xe6, 0x03, 0xb1, 0x06, 0x20, + 0xf6, 0xbd, 0x85, 0x00, 0xac, 0x54, 0x07, 0xd0, 0x01, 0x98, 0x90, 0x25, + 0xa0, 0x11, 0x94, 0x26, 0xa9, 0xc4, 0xa4, 0x00, 0xc0, 0x58, 0xf0, 0x04, + 0xc0, 0x5d, 0xd0, 0x15, 0xad, 0xbc, 0x06, 0xd0, 0x08, 0xa9, 0x0b, 0x8d, + 0x9d, 0x07, 0xee, 0xbc, 0x06, 0xad, 0x9d, 0x07, 0xd0, 0x02, 0xa0, 0xc4, + 0x98, 0x9d, 0xe8, 0x03, 0x20, 0x84, 0xbd, 0xa4, 0x02, 0xa9, 0x23, 0x91, + 0x06, 0xa9, 0x10, 0x8d, 0x84, 0x07, 0x68, 0x85, 0x05, 0xa0, 0x00, 0xad, + 0x14, 0x07, 0xd0, 0x05, 0xad, 0x54, 0x07, 0xf0, 0x01, 0xc8, 0xa5, 0xce, + 0x18, 0x79, 0xeb, 0xbc, 0x29, 0xf0, 0x95, 0xd7, 0xb4, 0x26, 0xc0, 0x11, + 0xf0, 0x06, 0x20, 0x02, 0xbe, 0x4c, 0x7b, 0xbd, 0x20, 0x9b, 0xbd, 0xad, + 0xee, 0x03, 0x49, 0x01, 0x8d, 0xee, 0x03, 0x60, 0xa5, 0x86, 0x18, 0x69, + 0x08, 0x29, 0xf0, 0x95, 0x8f, 0xa5, 0x6d, 0x69, 0x00, 0x95, 0x76, 0x9d, + 0xea, 0x03, 0xa5, 0xb5, 0x95, 0xbe, 0x60, 0x20, 0x1f, 0xbe, 0xa9, 0x02, + 0x85, 0xff, 0xa9, 0x00, 0x95, 0x60, 0x9d, 0x3c, 0x04, 0x85, 0x9f, 0xa9, + 0xfe, 0x95, 0xa8, 0xa5, 0x05, 0x20, 0xf6, 0xbd, 0x90, 0x31, 0x98, 0xc9, + 0x09, 0x90, 0x02, 0xe9, 0x05, 0x20, 0x04, 0x8e, 0xd2, 0xbd, 0x38, 0xbb, + 0x38, 0xbb, 0xd8, 0xbd, 0xd2, 0xbd, 0xdf, 0xbd, 0xd5, 0xbd, 0x38, 0xbb, + 0xd8, 0xbd, 0xa9, 0x00, 0x2c, 0xa9, 0x02, 0x2c, 0xa9, 0x03, 0x85, 0x39, + 0x4c, 0x49, 0xbc, 0xa2, 0x05, 0xac, 0xee, 0x03, 0x20, 0x1e, 0xb9, 0x60, + 0xc1, 0xc0, 0x5f, 0x60, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, + 0x5d, 0x5e, 0xa0, 0x0d, 0xd9, 0xe8, 0xbd, 0xf0, 0x04, 0x88, 0x10, 0xf8, + 0x18, 0x60, 0x20, 0x1f, 0xbe, 0xa9, 0x01, 0x9d, 0xec, 0x03, 0x85, 0xfd, + 0x20, 0x41, 0xbe, 0xa9, 0xfe, 0x85, 0x9f, 0xa9, 0x05, 0x8d, 0x39, 0x01, + 0x20, 0x27, 0xbc, 0xae, 0xee, 0x03, 0x60, 0xae, 0xee, 0x03, 0xa4, 0x02, + 0xf0, 0x1a, 0x98, 0x38, 0xe9, 0x10, 0x85, 0x02, 0xa8, 0xb1, 0x06, 0xc9, + 0xc2, 0xd0, 0x0d, 0xa9, 0x00, 0x91, 0x06, 0x20, 0x4d, 0x8a, 0xae, 0xee, + 0x03, 0x20, 0x51, 0xbb, 0x60, 0xb5, 0x8f, 0x9d, 0xf1, 0x03, 0xa9, 0xf0, + 0x95, 0x60, 0x95, 0x62, 0xa9, 0xfa, 0x95, 0xa8, 0xa9, 0xfc, 0x95, 0xaa, + 0xa9, 0x00, 0x9d, 0x3c, 0x04, 0x9d, 0x3e, 0x04, 0xb5, 0x76, 0x95, 0x78, + 0xb5, 0x8f, 0x95, 0x91, 0xb5, 0xd7, 0x18, 0x69, 0x08, 0x95, 0xd9, 0xa9, + 0xfa, 0x95, 0xa8, 0x60, 0xb5, 0x26, 0xf0, 0x5d, 0x29, 0x0f, 0x48, 0xa8, + 0x8a, 0x18, 0x69, 0x09, 0xaa, 0x88, 0xf0, 0x33, 0x20, 0xa4, 0xbf, 0x20, + 0x0f, 0xbf, 0x8a, 0x18, 0x69, 0x02, 0xaa, 0x20, 0xa4, 0xbf, 0x20, 0x0f, + 0xbf, 0xa6, 0x08, 0x20, 0x59, 0xf1, 0x20, 0xb6, 0xf1, 0x20, 0x53, 0xec, + 0x68, 0xb4, 0xbe, 0xf0, 0x30, 0x48, 0xa9, 0xf0, 0xd5, 0xd9, 0xb0, 0x02, + 0x95, 0xd9, 0xb5, 0xd7, 0xc9, 0xf0, 0x68, 0x90, 0x20, 0xb0, 0x1c, 0x20, + 0xa4, 0xbf, 0xa6, 0x08, 0x20, 0x59, 0xf1, 0x20, 0xb6, 0xf1, 0x20, 0xd1, + 0xeb, 0xb5, 0xd7, 0x29, 0x0f, 0xc9, 0x05, 0x68, 0xb0, 0x07, 0xa9, 0x01, + 0x9d, 0xec, 0x03, 0xa9, 0x00, 0x95, 0x26, 0x60, 0xa2, 0x01, 0x86, 0x08, + 0xad, 0x01, 0x03, 0xd0, 0x21, 0xbd, 0xec, 0x03, 0xf0, 0x1c, 0xbd, 0xe6, + 0x03, 0x85, 0x06, 0xa9, 0x05, 0x85, 0x07, 0xbd, 0xe4, 0x03, 0x85, 0x02, + 0xa8, 0xbd, 0xe8, 0x03, 0x91, 0x06, 0x20, 0x61, 0x8a, 0xa9, 0x00, 0x9d, + 0xec, 0x03, 0xca, 0x10, 0xd5, 0x60, 0xe8, 0x20, 0x0f, 0xbf, 0xa6, 0x08, + 0x60, 0xad, 0x0e, 0x07, 0xd0, 0x3e, 0xaa, 0xb5, 0x57, 0x0a, 0x0a, 0x0a, + 0x0a, 0x85, 0x01, 0xb5, 0x57, 0x4a, 0x4a, 0x4a, 0x4a, 0xc9, 0x08, 0x90, + 0x02, 0x09, 0xf0, 0x85, 0x00, 0xa0, 0x00, 0xc9, 0x00, 0x10, 0x01, 0x88, + 0x84, 0x02, 0xbd, 0x00, 0x04, 0x18, 0x65, 0x01, 0x9d, 0x00, 0x04, 0xa9, + 0x00, 0x2a, 0x48, 0x6a, 0xb5, 0x86, 0x65, 0x00, 0x95, 0x86, 0xb5, 0x6d, + 0x65, 0x02, 0x95, 0x6d, 0x68, 0x18, 0x65, 0x00, 0x60, 0xa2, 0x00, 0xad, + 0x47, 0x07, 0xd0, 0x05, 0xad, 0x0e, 0x07, 0xd0, 0xf3, 0xad, 0x09, 0x07, + 0x85, 0x00, 0xa9, 0x04, 0x4c, 0xad, 0xbf, 0xa0, 0x3d, 0xb5, 0x1e, 0xc9, + 0x05, 0xd0, 0x02, 0xa0, 0x20, 0x4c, 0x94, 0xbf, 0xa0, 0x00, 0x4c, 0x77, + 0xbf, 0xa0, 0x01, 0xe8, 0xa9, 0x03, 0x85, 0x00, 0xa9, 0x06, 0x85, 0x01, + 0xa9, 0x02, 0x85, 0x02, 0x98, 0x4c, 0xd1, 0xbf, 0xa0, 0x7f, 0xd0, 0x02, + 0xa0, 0x0f, 0xa9, 0x02, 0xd0, 0x04, 0xa0, 0x1c, 0xa9, 0x03, 0x84, 0x00, + 0xe8, 0x20, 0xad, 0xbf, 0xa6, 0x08, 0x60, 0x06, 0x08, 0xa0, 0x00, 0x2c, + 0xa0, 0x01, 0xa9, 0x50, 0x85, 0x00, 0xb9, 0x9f, 0xbf, 0x85, 0x02, 0xa9, + 0x00, 0x4c, 0xd7, 0xbf, 0xa9, 0x00, 0x2c, 0xa9, 0x01, 0x48, 0xb4, 0x16, + 0xe8, 0xa9, 0x05, 0xc0, 0x29, 0xd0, 0x02, 0xa9, 0x09, 0x85, 0x00, 0xa9, + 0x0a, 0x85, 0x01, 0xa9, 0x03, 0x85, 0x02, 0x68, 0xa8, 0x20, 0xd7, 0xbf, + 0xa6, 0x08, 0x60, 0x48, 0xbd, 0x16, 0x04, 0x18, 0x7d, 0x33, 0x04, 0x9d, + 0x16, 0x04, 0xa0, 0x00, 0xb5, 0x9f, 0x10, 0x01, 0x88, 0x84, 0x07, 0x75, + 0xce, 0x95, 0xce, 0xb5, 0xb5, 0x65, 0x07, 0x95, 0xb5, 0xbd, 0x33, 0x04, + 0x18, 0x65, 0x00, 0x9d, 0x33, 0x04, 0xb5, 0x9f, 0x69, 0x00, 0x95, 0x9f, + 0xc5, 0x02, 0x30, 0x10, 0xbd, 0x33, 0x04, 0xc9, 0x80, 0x90, 0x09, 0xa5, + 0x02, 0x95, 0x9f, 0xa9, 0x00, 0x9d, 0x33, 0x04, 0x68, 0xf0, 0x2b, 0xa5, + 0x02, 0x49, 0xff, 0xa8, 0xc8, 0x84, 0x07, 0xbd, 0x33, 0x04, 0x38, 0xe5, + 0x01, 0x9d, 0x33, 0x04, 0xb5, 0x9f, 0xe9, 0x00, 0x95, 0x9f, 0xc5, 0x07, + 0x10, 0x10, 0xbd, 0x33, 0x04, 0xc9, 0x80, 0xb0, 0x09, 0xa5, 0x07, 0x95, + 0x9f, 0xa9, 0xff, 0x9d, 0x33, 0x04, 0x60, 0xb5, 0x0f, 0x48, 0x0a, 0xb0, + 0x12, 0x68, 0xf0, 0x03, 0x4c, 0x82, 0xc8, 0xad, 0x1f, 0x07, 0x29, 0x07, + 0xc9, 0x07, 0xf0, 0x0e, 0x4c, 0xcc, 0xc0, 0x68, 0x29, 0x0f, 0xa8, 0xb9, + 0x0f, 0x00, 0xd0, 0x02, 0x95, 0x0f, 0x60, 0x03, 0x03, 0x06, 0x06, 0x06, + 0x06, 0x06, 0x06, 0x07, 0x07, 0x07, 0x05, 0x09, 0x04, 0x05, 0x06, 0x08, + 0x09, 0x0a, 0x06, 0x0b, 0x10, 0x40, 0xb0, 0xb0, 0x80, 0x40, 0x40, 0x80, + 0x40, 0xf0, 0xf0, 0xf0, 0xa5, 0x6d, 0x38, 0xe9, 0x04, 0x85, 0x6d, 0xad, + 0x25, 0x07, 0x38, 0xe9, 0x04, 0x8d, 0x25, 0x07, 0xad, 0x1a, 0x07, 0x38, + 0xe9, 0x04, 0x8d, 0x1a, 0x07, 0xad, 0x1b, 0x07, 0x38, 0xe9, 0x04, 0x8d, + 0x1b, 0x07, 0xad, 0x2a, 0x07, 0x38, 0xe9, 0x04, 0x8d, 0x2a, 0x07, 0xa9, + 0x00, 0x8d, 0x3b, 0x07, 0x8d, 0x2b, 0x07, 0x8d, 0x39, 0x07, 0x8d, 0x3a, + 0x07, 0xb9, 0xf8, 0x9b, 0x8d, 0x2c, 0x07, 0x60, 0xad, 0x45, 0x07, 0xf0, + 0x5e, 0xad, 0x26, 0x07, 0xd0, 0x59, 0xa0, 0x0b, 0x88, 0x30, 0x54, 0xad, + 0x5f, 0x07, 0xd9, 0x6b, 0xc0, 0xd0, 0xf5, 0xad, 0x25, 0x07, 0xd9, 0x76, + 0xc0, 0xd0, 0xed, 0xa5, 0xce, 0xd9, 0x81, 0xc0, 0xd0, 0x23, 0xa5, 0x1d, + 0xc9, 0x00, 0xd0, 0x1d, 0xad, 0x5f, 0x07, 0xc9, 0x06, 0xd0, 0x23, 0xee, + 0xd9, 0x06, 0xee, 0xda, 0x06, 0xad, 0xda, 0x06, 0xc9, 0x03, 0xd0, 0x1e, + 0xad, 0xd9, 0x06, 0xc9, 0x03, 0xf0, 0x0f, 0xd0, 0x07, 0xad, 0x5f, 0x07, + 0xc9, 0x06, 0xf0, 0xe6, 0x20, 0x8c, 0xc0, 0x20, 0x71, 0xd0, 0xa9, 0x00, + 0x8d, 0xda, 0x06, 0x8d, 0xd9, 0x06, 0xa9, 0x00, 0x8d, 0x45, 0x07, 0xad, + 0xcd, 0x06, 0xf0, 0x10, 0x95, 0x16, 0xa9, 0x01, 0x95, 0x0f, 0xa9, 0x00, + 0x95, 0x1e, 0x8d, 0xcd, 0x06, 0x4c, 0x26, 0xc2, 0xac, 0x39, 0x07, 0xb1, + 0xe9, 0xc9, 0xff, 0xd0, 0x03, 0x4c, 0x16, 0xc2, 0x29, 0x0f, 0xc9, 0x0e, + 0xf0, 0x0e, 0xe0, 0x05, 0x90, 0x0a, 0xc8, 0xb1, 0xe9, 0x29, 0x3f, 0xc9, + 0x2e, 0xf0, 0x01, 0x60, 0xad, 0x1d, 0x07, 0x18, 0x69, 0x30, 0x29, 0xf0, + 0x85, 0x07, 0xad, 0x1b, 0x07, 0x69, 0x00, 0x85, 0x06, 0xac, 0x39, 0x07, + 0xc8, 0xb1, 0xe9, 0x0a, 0x90, 0x0b, 0xad, 0x3b, 0x07, 0xd0, 0x06, 0xee, + 0x3b, 0x07, 0xee, 0x3a, 0x07, 0x88, 0xb1, 0xe9, 0x29, 0x0f, 0xc9, 0x0f, + 0xd0, 0x19, 0xad, 0x3b, 0x07, 0xd0, 0x14, 0xc8, 0xb1, 0xe9, 0x29, 0x3f, + 0x8d, 0x3a, 0x07, 0xee, 0x39, 0x07, 0xee, 0x39, 0x07, 0xee, 0x3b, 0x07, + 0x4c, 0xcc, 0xc0, 0xad, 0x3a, 0x07, 0x95, 0x6e, 0xb1, 0xe9, 0x29, 0xf0, + 0x95, 0x87, 0xcd, 0x1d, 0x07, 0xb5, 0x6e, 0xed, 0x1b, 0x07, 0xb0, 0x0b, + 0xb1, 0xe9, 0x29, 0x0f, 0xc9, 0x0e, 0xf0, 0x69, 0x4c, 0x50, 0xc2, 0xa5, + 0x07, 0xd5, 0x87, 0xa5, 0x06, 0xf5, 0x6e, 0x90, 0x41, 0xa9, 0x01, 0x95, + 0xb6, 0xb1, 0xe9, 0x0a, 0x0a, 0x0a, 0x0a, 0x95, 0xcf, 0xc9, 0xe0, 0xf0, + 0x4c, 0xc8, 0xb1, 0xe9, 0x29, 0x40, 0xf0, 0x05, 0xad, 0xcc, 0x06, 0xf0, + 0x6d, 0xb1, 0xe9, 0x29, 0x3f, 0xc9, 0x37, 0x90, 0x04, 0xc9, 0x3f, 0x90, + 0x31, 0xc9, 0x06, 0xd0, 0x07, 0xac, 0x6a, 0x07, 0xf0, 0x02, 0xa9, 0x02, + 0x95, 0x16, 0xa9, 0x01, 0x95, 0x0f, 0x20, 0x26, 0xc2, 0xb5, 0x0f, 0xd0, + 0x49, 0x60, 0xad, 0xcb, 0x06, 0xd0, 0x09, 0xad, 0x98, 0x03, 0xc9, 0x01, + 0xd0, 0x0b, 0xa9, 0x2f, 0x95, 0x16, 0xa9, 0x00, 0x95, 0x1e, 0x20, 0x6c, + 0xc2, 0x60, 0x4c, 0x1b, 0xc7, 0xc8, 0xc8, 0xb1, 0xe9, 0x4a, 0x4a, 0x4a, + 0x4a, 0x4a, 0xcd, 0x5f, 0x07, 0xd0, 0x0e, 0x88, 0xb1, 0xe9, 0x8d, 0x50, + 0x07, 0xc8, 0xb1, 0xe9, 0x29, 0x1f, 0x8d, 0x51, 0x07, 0x4c, 0x5b, 0xc2, + 0xac, 0x39, 0x07, 0xb1, 0xe9, 0x29, 0x0f, 0xc9, 0x0e, 0xd0, 0x03, 0xee, + 0x39, 0x07, 0xee, 0x39, 0x07, 0xee, 0x39, 0x07, 0xa9, 0x00, 0x8d, 0x3b, + 0x07, 0xa6, 0x08, 0x60, 0xb5, 0x16, 0xc9, 0x15, 0xb0, 0x0d, 0xa8, 0xb5, + 0xcf, 0x69, 0x08, 0x95, 0xcf, 0xa9, 0x01, 0x9d, 0xd8, 0x03, 0x98, 0x20, + 0x04, 0x8e, 0x0e, 0xc3, 0x0e, 0xc3, 0x0e, 0xc3, 0x1e, 0xc3, 0xf0, 0xc2, + 0x28, 0xc3, 0xf1, 0xc2, 0x42, 0xc3, 0x6b, 0xc3, 0xf0, 0xc2, 0x75, 0xc3, + 0x75, 0xc3, 0xf7, 0xc2, 0x87, 0xc7, 0xd1, 0xc7, 0x4a, 0xc3, 0x3d, 0xc3, + 0x85, 0xc3, 0xa0, 0xc7, 0xf0, 0xc2, 0xa0, 0xc7, 0xa0, 0xc7, 0xa0, 0xc7, + 0xa0, 0xc7, 0xb8, 0xc7, 0xf0, 0xc2, 0xf0, 0xc2, 0x5c, 0xc4, 0x5c, 0xc4, + 0x5c, 0xc4, 0x5c, 0xc4, 0x59, 0xc4, 0xf0, 0xc2, 0xf0, 0xc2, 0xf0, 0xc2, + 0xf0, 0xc2, 0xdf, 0xc7, 0x12, 0xc8, 0x3f, 0xc8, 0x45, 0xc8, 0x0b, 0xc8, + 0x03, 0xc8, 0x0b, 0xc8, 0x4b, 0xc8, 0x57, 0xc8, 0x49, 0xc5, 0x60, 0xbc, + 0x1e, 0xb9, 0xf0, 0xc2, 0xf0, 0xc2, 0xf0, 0xc2, 0xf0, 0xc2, 0xf0, 0xc2, + 0x07, 0xc3, 0x81, 0xc8, 0x60, 0x20, 0x0e, 0xc3, 0x4c, 0x46, 0xc3, 0xa9, + 0x02, 0x95, 0xb6, 0x95, 0xcf, 0x4a, 0x9d, 0x96, 0x07, 0x4a, 0x95, 0x1e, + 0x4c, 0x46, 0xc3, 0xa9, 0xb8, 0x95, 0xcf, 0x60, 0xf8, 0xf4, 0xa0, 0x01, + 0xad, 0x6a, 0x07, 0xd0, 0x01, 0x88, 0xb9, 0x0c, 0xc3, 0x95, 0x58, 0x4c, + 0x5a, 0xc3, 0x20, 0x0e, 0xc3, 0xa9, 0x01, 0x95, 0x1e, 0x60, 0x80, 0x50, + 0xa9, 0x00, 0x9d, 0xa2, 0x03, 0x95, 0x58, 0xac, 0xcc, 0x06, 0xb9, 0x26, + 0xc3, 0x9d, 0x96, 0x07, 0xa9, 0x0b, 0x4c, 0x5c, 0xc3, 0xa9, 0x00, 0x4c, + 0x19, 0xc3, 0xa9, 0x00, 0x95, 0x58, 0xa9, 0x09, 0xd0, 0x12, 0xa0, 0x30, + 0xb5, 0xcf, 0x9d, 0x01, 0x04, 0x10, 0x02, 0xa0, 0xe0, 0x98, 0x75, 0xcf, + 0x95, 0x58, 0xa9, 0x03, 0x9d, 0x9a, 0x04, 0xa9, 0x02, 0x95, 0x46, 0xa9, + 0x00, 0x95, 0xa0, 0x9d, 0x34, 0x04, 0x60, 0xa9, 0x02, 0x95, 0x46, 0xa9, + 0x09, 0x9d, 0x9a, 0x04, 0x60, 0x20, 0x46, 0xc3, 0xbd, 0xa7, 0x07, 0x29, + 0x10, 0x95, 0x58, 0xb5, 0xcf, 0x9d, 0x34, 0x04, 0x60, 0xad, 0xcb, 0x06, + 0xd0, 0x0b, 0xa9, 0x00, 0x8d, 0xd1, 0x06, 0x20, 0x3d, 0xc3, 0x4c, 0xd9, + 0xc7, 0x4c, 0x98, 0xc9, 0x26, 0x2c, 0x32, 0x38, 0x20, 0x22, 0x24, 0x26, + 0x13, 0x14, 0x15, 0x16, 0xad, 0x8f, 0x07, 0xd0, 0x3c, 0xe0, 0x05, 0xb0, + 0x38, 0xa9, 0x80, 0x8d, 0x8f, 0x07, 0xa0, 0x04, 0xb9, 0x16, 0x00, 0xc9, + 0x11, 0xf0, 0x2b, 0x88, 0x10, 0xf6, 0xee, 0xd1, 0x06, 0xad, 0xd1, 0x06, + 0xc9, 0x07, 0x90, 0x1d, 0xa2, 0x04, 0xb5, 0x0f, 0xf0, 0x05, 0xca, 0x10, + 0xf9, 0x30, 0x10, 0xa9, 0x00, 0x95, 0x1e, 0xa9, 0x11, 0x95, 0x16, 0x20, + 0x8a, 0xc3, 0xa9, 0x20, 0x20, 0xd8, 0xc5, 0xa6, 0x08, 0x60, 0xa5, 0xce, + 0xc9, 0x2c, 0x90, 0xf9, 0xb9, 0x1e, 0x00, 0xd0, 0xf4, 0xb9, 0x6e, 0x00, + 0x95, 0x6e, 0xb9, 0x87, 0x00, 0x95, 0x87, 0xa9, 0x01, 0x95, 0xb6, 0xb9, + 0xcf, 0x00, 0x38, 0xe9, 0x08, 0x95, 0xcf, 0xbd, 0xa7, 0x07, 0x29, 0x03, + 0xa8, 0xa2, 0x02, 0xb9, 0x98, 0xc3, 0x95, 0x01, 0xc8, 0xc8, 0xc8, 0xc8, + 0xca, 0x10, 0xf4, 0xa6, 0x08, 0x20, 0x6c, 0xcf, 0xa4, 0x57, 0xc0, 0x08, + 0xb0, 0x0e, 0xa8, 0xbd, 0xa8, 0x07, 0x29, 0x03, 0xf0, 0x05, 0x98, 0x49, + 0xff, 0xa8, 0xc8, 0x98, 0x20, 0x46, 0xc3, 0xa0, 0x02, 0x95, 0x58, 0xc9, + 0x00, 0x30, 0x01, 0x88, 0x94, 0x46, 0xa9, 0xfd, 0x95, 0xa0, 0xa9, 0x01, + 0x95, 0x0f, 0xa9, 0x05, 0x95, 0x1e, 0x60, 0x28, 0x38, 0x28, 0x38, 0x28, + 0x00, 0x00, 0x10, 0x10, 0x00, 0x20, 0x75, 0xc5, 0xa9, 0x00, 0x95, 0x58, + 0xb5, 0x16, 0x38, 0xe9, 0x1b, 0xa8, 0xb9, 0x4f, 0xc4, 0x9d, 0x88, 0x03, + 0xb9, 0x54, 0xc4, 0x95, 0x34, 0xb5, 0xcf, 0x18, 0x69, 0x04, 0x95, 0xcf, + 0xb5, 0x87, 0x18, 0x69, 0x04, 0x95, 0x87, 0xb5, 0x6e, 0x69, 0x00, 0x95, + 0x6e, 0x4c, 0xd9, 0xc7, 0x80, 0x30, 0x40, 0x80, 0x30, 0x50, 0x50, 0x70, + 0x20, 0x40, 0x80, 0xa0, 0x70, 0x40, 0x90, 0x68, 0x0e, 0x05, 0x06, 0x0e, + 0x1c, 0x20, 0x10, 0x0c, 0x1e, 0x22, 0x18, 0x14, 0x10, 0x60, 0x20, 0x48, + 0xad, 0x8f, 0x07, 0xd0, 0xa1, 0x20, 0x46, 0xc3, 0xbd, 0xa8, 0x07, 0x29, + 0x03, 0xa8, 0xb9, 0xa4, 0xc4, 0x8d, 0x8f, 0x07, 0xa0, 0x03, 0xad, 0xcc, + 0x06, 0xf0, 0x01, 0xc8, 0x84, 0x00, 0xe4, 0x00, 0xb0, 0x84, 0xbd, 0xa7, + 0x07, 0x29, 0x03, 0x85, 0x00, 0x85, 0x01, 0xa9, 0xfb, 0x95, 0xa0, 0xa9, + 0x00, 0xa4, 0x57, 0xf0, 0x07, 0xa9, 0x04, 0xc0, 0x19, 0x90, 0x01, 0x0a, + 0x48, 0x18, 0x65, 0x00, 0x85, 0x00, 0xbd, 0xa8, 0x07, 0x29, 0x03, 0xf0, + 0x07, 0xbd, 0xa9, 0x07, 0x29, 0x0f, 0x85, 0x00, 0x68, 0x18, 0x65, 0x01, + 0xa8, 0xb9, 0x98, 0xc4, 0x95, 0x58, 0xa9, 0x01, 0x95, 0x46, 0xa5, 0x57, + 0xd0, 0x12, 0xa4, 0x00, 0x98, 0x29, 0x02, 0xf0, 0x0b, 0xb5, 0x58, 0x49, + 0xff, 0x18, 0x69, 0x01, 0x95, 0x58, 0xf6, 0x46, 0x98, 0x29, 0x02, 0xf0, + 0x0f, 0xa5, 0x86, 0x18, 0x79, 0x88, 0xc4, 0x95, 0x87, 0xa5, 0x6d, 0x69, + 0x00, 0x4c, 0x3c, 0xc5, 0xa5, 0x86, 0x38, 0xf9, 0x88, 0xc4, 0x95, 0x87, + 0xa5, 0x6d, 0xe9, 0x00, 0x95, 0x6e, 0xa9, 0x01, 0x95, 0x0f, 0x95, 0xb6, + 0xa9, 0xf8, 0x95, 0xcf, 0x60, 0x20, 0x75, 0xc5, 0x8e, 0x68, 0x03, 0xa9, + 0x00, 0x8d, 0x63, 0x03, 0x8d, 0x69, 0x03, 0xb5, 0x87, 0x8d, 0x66, 0x03, + 0xa9, 0xdf, 0x8d, 0x90, 0x07, 0x95, 0x46, 0xa9, 0x20, 0x8d, 0x64, 0x03, + 0x9d, 0x8a, 0x07, 0xa9, 0x05, 0x8d, 0x83, 0x04, 0x4a, 0x8d, 0x65, 0x03, + 0x60, 0xa0, 0xff, 0xc8, 0xb9, 0x0f, 0x00, 0xd0, 0xfa, 0x8c, 0xcf, 0x06, + 0x8a, 0x09, 0x80, 0x99, 0x0f, 0x00, 0xb5, 0x6e, 0x99, 0x6e, 0x00, 0xb5, + 0x87, 0x99, 0x87, 0x00, 0xa9, 0x01, 0x95, 0x0f, 0x99, 0xb6, 0x00, 0xb5, + 0xcf, 0x99, 0xcf, 0x00, 0x60, 0x90, 0x80, 0x70, 0x90, 0xff, 0x01, 0xad, + 0x8f, 0x07, 0xd0, 0xf4, 0x9d, 0x34, 0x04, 0xa5, 0xfd, 0x09, 0x02, 0x85, + 0xfd, 0xac, 0x68, 0x03, 0xb9, 0x16, 0x00, 0xc9, 0x2d, 0xf0, 0x31, 0x20, + 0xd9, 0xd1, 0x18, 0x69, 0x20, 0xac, 0xcc, 0x06, 0xf0, 0x03, 0x38, 0xe9, + 0x10, 0x8d, 0x8f, 0x07, 0xbd, 0xa7, 0x07, 0x29, 0x03, 0x9d, 0x17, 0x04, + 0xa8, 0xb9, 0x9d, 0xc5, 0x95, 0xcf, 0xad, 0x1d, 0x07, 0x18, 0x69, 0x20, + 0x95, 0x87, 0xad, 0x1b, 0x07, 0x69, 0x00, 0x95, 0x6e, 0x4c, 0x1f, 0xc6, + 0xb9, 0x87, 0x00, 0x38, 0xe9, 0x0e, 0x95, 0x87, 0xb9, 0x6e, 0x00, 0x95, + 0x6e, 0xb9, 0xcf, 0x00, 0x18, 0x69, 0x08, 0x95, 0xcf, 0xbd, 0xa7, 0x07, + 0x29, 0x03, 0x9d, 0x17, 0x04, 0xa8, 0xb9, 0x9d, 0xc5, 0xa0, 0x00, 0xd5, + 0xcf, 0x90, 0x01, 0xc8, 0xb9, 0xa1, 0xc5, 0x9d, 0x34, 0x04, 0xa9, 0x00, + 0x8d, 0xcb, 0x06, 0xa9, 0x08, 0x9d, 0x9a, 0x04, 0xa9, 0x01, 0x95, 0xb6, + 0x95, 0x0f, 0x4a, 0x9d, 0x01, 0x04, 0x95, 0x1e, 0x60, 0x00, 0x30, 0x60, + 0x60, 0x00, 0x20, 0x60, 0x40, 0x70, 0x40, 0x60, 0x30, 0xad, 0x8f, 0x07, + 0xd0, 0x47, 0xa9, 0x20, 0x8d, 0x8f, 0x07, 0xce, 0xd7, 0x06, 0xa0, 0x06, + 0x88, 0xb9, 0x16, 0x00, 0xc9, 0x31, 0xd0, 0xf8, 0xb9, 0x87, 0x00, 0x38, + 0xe9, 0x30, 0x48, 0xb9, 0x6e, 0x00, 0xe9, 0x00, 0x85, 0x00, 0xad, 0xd7, + 0x06, 0x18, 0x79, 0x1e, 0x00, 0xa8, 0x68, 0x18, 0x79, 0x31, 0xc6, 0x95, + 0x87, 0xa5, 0x00, 0x69, 0x00, 0x95, 0x6e, 0xb9, 0x37, 0xc6, 0x95, 0xcf, + 0xa9, 0x01, 0x95, 0xb6, 0x95, 0x0f, 0x4a, 0x95, 0x58, 0xa9, 0x08, 0x95, + 0xa0, 0x60, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x40, 0x30, + 0x90, 0x50, 0x20, 0x60, 0xa0, 0x70, 0x0a, 0x0b, 0xad, 0x8f, 0x07, 0xd0, + 0x6f, 0xad, 0x4e, 0x07, 0xd0, 0x57, 0xe0, 0x03, 0xb0, 0x66, 0xa0, 0x00, + 0xbd, 0xa7, 0x07, 0xc9, 0xaa, 0x90, 0x01, 0xc8, 0xad, 0x5f, 0x07, 0xc9, + 0x01, 0xf0, 0x01, 0xc8, 0x98, 0x29, 0x01, 0xa8, 0xb9, 0x9a, 0xc6, 0x95, + 0x16, 0xad, 0xdd, 0x06, 0xc9, 0xff, 0xd0, 0x05, 0xa9, 0x00, 0x8d, 0xdd, + 0x06, 0xbd, 0xa7, 0x07, 0x29, 0x07, 0xa8, 0xb9, 0x8a, 0xc6, 0x2c, 0xdd, + 0x06, 0xf0, 0x07, 0xc8, 0x98, 0x29, 0x07, 0x4c, 0xd6, 0xc6, 0x0d, 0xdd, + 0x06, 0x8d, 0xdd, 0x06, 0xb9, 0x92, 0xc6, 0x20, 0xd8, 0xc5, 0x9d, 0x17, + 0x04, 0xa9, 0x20, 0x8d, 0x8f, 0x07, 0x4c, 0x6c, 0xc2, 0xa0, 0xff, 0xc8, + 0xc0, 0x05, 0xb0, 0x0d, 0xb9, 0x0f, 0x00, 0xf0, 0xf6, 0xb9, 0x16, 0x00, + 0xc9, 0x08, 0xd0, 0xef, 0x60, 0xa5, 0xfe, 0x09, 0x08, 0x85, 0xfe, 0xa9, + 0x08, 0xd0, 0xa8, 0xa0, 0x00, 0x38, 0xe9, 0x37, 0x48, 0xc9, 0x04, 0xb0, + 0x0b, 0x48, 0xa0, 0x06, 0xad, 0x6a, 0x07, 0xf0, 0x02, 0xa0, 0x02, 0x68, + 0x84, 0x01, 0xa0, 0xb0, 0x29, 0x02, 0xf0, 0x02, 0xa0, 0x70, 0x84, 0x00, + 0xad, 0x1b, 0x07, 0x85, 0x02, 0xad, 0x1d, 0x07, 0x85, 0x03, 0xa0, 0x02, + 0x68, 0x4a, 0x90, 0x01, 0xc8, 0x8c, 0xd3, 0x06, 0xa2, 0xff, 0xe8, 0xe0, + 0x05, 0xb0, 0x2d, 0xb5, 0x0f, 0xd0, 0xf7, 0xa5, 0x01, 0x95, 0x16, 0xa5, + 0x02, 0x95, 0x6e, 0xa5, 0x03, 0x95, 0x87, 0x18, 0x69, 0x18, 0x85, 0x03, + 0xa5, 0x02, 0x69, 0x00, 0x85, 0x02, 0xa5, 0x00, 0x95, 0xcf, 0xa9, 0x01, + 0x95, 0xb6, 0x95, 0x0f, 0x20, 0x6c, 0xc2, 0xce, 0xd3, 0x06, 0xd0, 0xcc, + 0x4c, 0x5e, 0xc2, 0xa9, 0x01, 0x95, 0x58, 0x4a, 0x95, 0x1e, 0x95, 0xa0, + 0xb5, 0xcf, 0x9d, 0x34, 0x04, 0x38, 0xe9, 0x18, 0x9d, 0x17, 0x04, 0xa9, + 0x09, 0x4c, 0xdb, 0xc7, 0xb5, 0x16, 0x8d, 0xcb, 0x06, 0x38, 0xe9, 0x12, + 0x20, 0x04, 0x8e, 0xa4, 0xc3, 0xb7, 0xc7, 0xa8, 0xc4, 0xa3, 0xc5, 0x3d, + 0xc6, 0x9c, 0xc6, 0x60, 0xa0, 0x05, 0xb9, 0x16, 0x00, 0xc9, 0x11, 0xd0, + 0x05, 0xa9, 0x01, 0x99, 0x1e, 0x00, 0x88, 0x10, 0xf1, 0xa9, 0x00, 0x8d, + 0xcb, 0x06, 0x95, 0x0f, 0x60, 0xa9, 0x02, 0x95, 0x46, 0xa9, 0xf8, 0x95, + 0x58, 0xa9, 0x03, 0x9d, 0x9a, 0x04, 0x60, 0xd6, 0xcf, 0xd6, 0xcf, 0xac, + 0xcc, 0x06, 0xd0, 0x05, 0xa0, 0x02, 0x20, 0x71, 0xc8, 0xa0, 0xff, 0xad, + 0xa0, 0x03, 0x95, 0x1e, 0x10, 0x02, 0x8a, 0xa8, 0x8c, 0xa0, 0x03, 0xa9, + 0x00, 0x95, 0x46, 0xa8, 0x20, 0x71, 0xc8, 0xa9, 0xff, 0x9d, 0xa2, 0x03, + 0x4c, 0x28, 0xc8, 0xa9, 0x00, 0x95, 0x58, 0x4c, 0x28, 0xc8, 0xa0, 0x40, + 0xb5, 0xcf, 0x10, 0x07, 0x49, 0xff, 0x18, 0x69, 0x01, 0xa0, 0xc0, 0x9d, + 0x01, 0x04, 0x98, 0x18, 0x75, 0xcf, 0x95, 0x58, 0x20, 0x63, 0xc3, 0xa9, + 0x05, 0xac, 0x4e, 0x07, 0xc0, 0x03, 0xf0, 0x07, 0xac, 0xcc, 0x06, 0xd0, + 0x02, 0xa9, 0x06, 0x9d, 0x9a, 0x04, 0x60, 0x20, 0x4b, 0xc8, 0x4c, 0x48, + 0xc8, 0x20, 0x57, 0xc8, 0x4c, 0x2b, 0xc8, 0xa9, 0x10, 0x9d, 0x34, 0x04, + 0xa9, 0xff, 0x95, 0xa0, 0x4c, 0x60, 0xc8, 0xa9, 0xf0, 0x9d, 0x34, 0x04, + 0xa9, 0x00, 0x95, 0xa0, 0xa0, 0x01, 0x20, 0x71, 0xc8, 0xa9, 0x04, 0x9d, + 0x9a, 0x04, 0x60, 0x08, 0x0c, 0xf8, 0x00, 0x00, 0xff, 0xb5, 0x87, 0x18, + 0x79, 0x6b, 0xc8, 0x95, 0x87, 0xb5, 0x6e, 0x79, 0x6e, 0xc8, 0x95, 0x6e, + 0x60, 0x60, 0xa6, 0x08, 0xa9, 0x00, 0xb4, 0x16, 0xc0, 0x15, 0x90, 0x03, + 0x98, 0xe9, 0x14, 0x20, 0x04, 0x8e, 0xe0, 0xc8, 0x35, 0xc9, 0x95, 0xd2, + 0xd6, 0xc8, 0xd6, 0xc8, 0xd6, 0xc8, 0xd6, 0xc8, 0x47, 0xc9, 0x47, 0xc9, + 0x47, 0xc9, 0x47, 0xc9, 0x47, 0xc9, 0x47, 0xc9, 0x47, 0xc9, 0x47, 0xc9, + 0xd6, 0xc8, 0x65, 0xc9, 0x65, 0xc9, 0x65, 0xc9, 0x65, 0xc9, 0x65, 0xc9, + 0x65, 0xc9, 0x65, 0xc9, 0x4d, 0xc9, 0x4d, 0xc9, 0x65, 0xd0, 0x85, 0xbc, + 0x4b, 0xb9, 0xd6, 0xc8, 0xd9, 0xd2, 0xba, 0xb8, 0xd6, 0xc8, 0xa4, 0xb7, + 0xd7, 0xc8, 0x60, 0x20, 0xaf, 0xf1, 0x20, 0x52, 0xf1, 0x4c, 0x7d, 0xe8, + 0xa9, 0x00, 0x9d, 0xc5, 0x03, 0x20, 0xaf, 0xf1, 0x20, 0x52, 0xf1, 0x20, + 0x7d, 0xe8, 0x20, 0x43, 0xe2, 0x20, 0xc1, 0xdf, 0x20, 0x33, 0xda, 0x20, + 0x53, 0xd8, 0xac, 0x47, 0x07, 0xd0, 0x03, 0x20, 0x05, 0xc9, 0x4c, 0x7a, + 0xd6, 0xb5, 0x16, 0x20, 0x04, 0x8e, 0x77, 0xca, 0x77, 0xca, 0x77, 0xca, + 0x77, 0xca, 0x77, 0xca, 0xd8, 0xc9, 0x77, 0xca, 0x89, 0xcb, 0x36, 0xcc, + 0x34, 0xc9, 0x4a, 0xcc, 0x4a, 0xcc, 0xb0, 0xc9, 0xb0, 0xd3, 0xf9, 0xca, + 0xff, 0xca, 0x25, 0xcb, 0x28, 0xcf, 0x77, 0xca, 0x34, 0xc9, 0xdf, 0xce, + 0x60, 0x20, 0xeb, 0xd1, 0x20, 0xaf, 0xf1, 0x20, 0x52, 0xf1, 0x20, 0x43, + 0xe2, 0x20, 0x53, 0xd8, 0x4c, 0x7a, 0xd6, 0x20, 0x3c, 0xcd, 0x4c, 0x7a, + 0xd6, 0x20, 0xaf, 0xf1, 0x20, 0x52, 0xf1, 0x20, 0x4c, 0xe2, 0x20, 0x7b, + 0xdb, 0x20, 0x52, 0xf1, 0x20, 0x66, 0xed, 0x20, 0x55, 0xd6, 0x4c, 0x7a, + 0xd6, 0x20, 0xaf, 0xf1, 0x20, 0x52, 0xf1, 0x20, 0x73, 0xe2, 0x20, 0x45, + 0xdb, 0xad, 0x47, 0x07, 0xd0, 0x03, 0x20, 0x82, 0xc9, 0x20, 0x52, 0xf1, + 0x20, 0xc8, 0xe5, 0x4c, 0x7a, 0xd6, 0xb5, 0x16, 0x38, 0xe9, 0x24, 0x20, + 0x04, 0x8e, 0x32, 0xd4, 0xd3, 0xd5, 0x4f, 0xd6, 0x4f, 0xd6, 0x07, 0xd6, + 0x31, 0xd6, 0x3d, 0xd6, 0xa9, 0x00, 0x95, 0x0f, 0x95, 0x16, 0x95, 0x1e, + 0x9d, 0x10, 0x01, 0x9d, 0x96, 0x07, 0x9d, 0x25, 0x01, 0x9d, 0xc5, 0x03, + 0x9d, 0x8a, 0x07, 0x60, 0xbd, 0x96, 0x07, 0xd0, 0x16, 0x20, 0xf7, 0xc2, + 0xbd, 0xa8, 0x07, 0x09, 0x80, 0x9d, 0x34, 0x04, 0x29, 0x0f, 0x09, 0x06, + 0x9d, 0x96, 0x07, 0xa9, 0xf9, 0x95, 0xa0, 0x4c, 0x92, 0xbf, 0x30, 0x1c, + 0x00, 0xe8, 0x00, 0x18, 0x08, 0xf8, 0x0c, 0xf4, 0xb5, 0x1e, 0x29, 0x20, + 0xf0, 0x03, 0x4c, 0xe5, 0xca, 0xb5, 0x3c, 0xf0, 0x2d, 0xd6, 0x3c, 0xad, + 0xd1, 0x03, 0x29, 0x0c, 0xd0, 0x6a, 0xbd, 0xa2, 0x03, 0xd0, 0x17, 0xac, + 0xcc, 0x06, 0xb9, 0xce, 0xc9, 0x9d, 0xa2, 0x03, 0x20, 0x94, 0xba, 0x90, + 0x09, 0xb5, 0x1e, 0x09, 0x08, 0x95, 0x1e, 0x4c, 0x58, 0xca, 0xde, 0xa2, + 0x03, 0x4c, 0x58, 0xca, 0x20, 0x37, 0xb5, 0x1e, 0x29, 0x07, 0xc9, 0x01, + 0xf0, 0x3e, 0xa9, 0x00, 0x85, 0x00, 0xa0, 0xfa, 0xb5, 0xcf, 0x30, 0x13, + 0xa0, 0xfd, 0xc9, 0x70, 0xe6, 0x00, 0x90, 0x0b, 0xc6, 0x00, 0xbd, 0xa8, + 0x07, 0x29, 0x01, 0xd0, 0x02, 0xa0, 0xfa, 0x94, 0xa0, 0xb5, 0x1e, 0x09, + 0x01, 0x95, 0x1e, 0xa5, 0x00, 0x3d, 0xa9, 0x07, 0xa8, 0xad, 0xcc, 0x06, + 0xd0, 0x01, 0xa8, 0xb9, 0x10, 0xca, 0x9d, 0x8a, 0x07, 0xbd, 0xa8, 0x07, + 0x09, 0xc0, 0x95, 0x3c, 0xa0, 0xfc, 0xa5, 0x09, 0x29, 0x40, 0xd0, 0x02, + 0xa0, 0x04, 0x94, 0x58, 0xa0, 0x01, 0x20, 0x43, 0xe1, 0x30, 0x0a, 0xc8, + 0xbd, 0x96, 0x07, 0xd0, 0x04, 0xa9, 0xf8, 0x95, 0x58, 0x94, 0x46, 0xa0, + 0x00, 0xb5, 0x1e, 0x29, 0x40, 0xd0, 0x19, 0xb5, 0x1e, 0x0a, 0xb0, 0x30, + 0xb5, 0x1e, 0x29, 0x20, 0xd0, 0x5b, 0xb5, 0x1e, 0x29, 0x07, 0xf0, 0x24, + 0xc9, 0x05, 0xf0, 0x04, 0xc9, 0x03, 0xb0, 0x30, 0x20, 0x63, 0xbf, 0xa0, + 0x00, 0xb5, 0x1e, 0xc9, 0x02, 0xf0, 0x0c, 0x29, 0x40, 0xf0, 0x0d, 0xb5, + 0x16, 0xc9, 0x2e, 0xf0, 0x07, 0xd0, 0x03, 0x4c, 0x02, 0xbf, 0xa0, 0x01, + 0xb5, 0x58, 0x48, 0x10, 0x02, 0xc8, 0xc8, 0x18, 0x79, 0xd0, 0xc9, 0x95, + 0x58, 0x20, 0x02, 0xbf, 0x68, 0x95, 0x58, 0x60, 0xbd, 0x96, 0x07, 0xd0, + 0x1e, 0x95, 0x1e, 0xa5, 0x09, 0x29, 0x01, 0xa8, 0xc8, 0x94, 0x46, 0x88, + 0xad, 0x6a, 0x07, 0xf0, 0x02, 0xc8, 0xc8, 0xb9, 0xd4, 0xc9, 0x95, 0x58, + 0x60, 0x20, 0x63, 0xbf, 0x4c, 0x02, 0xbf, 0xc9, 0x0e, 0xd0, 0x09, 0xb5, + 0x16, 0xc9, 0x06, 0xd0, 0x03, 0x20, 0x98, 0xc9, 0x60, 0x20, 0x92, 0xbf, + 0x4c, 0x02, 0xbf, 0xb5, 0xa0, 0x1d, 0x34, 0x04, 0xd0, 0x13, 0x9d, 0x17, + 0x04, 0xb5, 0xcf, 0xdd, 0x01, 0x04, 0xb0, 0x09, 0xa5, 0x09, 0x29, 0x07, + 0xd0, 0x02, 0xf6, 0xcf, 0x60, 0xb5, 0xcf, 0xd5, 0x58, 0x90, 0x03, 0x4c, + 0x75, 0xbf, 0x4c, 0x70, 0xbf, 0x20, 0x45, 0xcb, 0x20, 0x66, 0xcb, 0xa0, + 0x01, 0xa5, 0x09, 0x29, 0x03, 0xd0, 0x11, 0xa5, 0x09, 0x29, 0x40, 0xd0, + 0x02, 0xa0, 0xff, 0x84, 0x00, 0xb5, 0xcf, 0x18, 0x65, 0x00, 0x95, 0xcf, + 0x60, 0xa9, 0x13, 0x85, 0x01, 0xa5, 0x09, 0x29, 0x03, 0xd0, 0x0d, 0xb4, + 0x58, 0xb5, 0xa0, 0x4a, 0xb0, 0x0a, 0xc4, 0x01, 0xf0, 0x03, 0xf6, 0x58, + 0x60, 0xf6, 0xa0, 0x60, 0x98, 0xf0, 0xfa, 0xd6, 0x58, 0x60, 0xb5, 0x58, + 0x48, 0xa0, 0x01, 0xb5, 0xa0, 0x29, 0x02, 0xd0, 0x0b, 0xb5, 0x58, 0x49, + 0xff, 0x18, 0x69, 0x01, 0x95, 0x58, 0xa0, 0x02, 0x94, 0x46, 0x20, 0x02, + 0xbf, 0x85, 0x00, 0x68, 0x95, 0x58, 0x60, 0x3f, 0x03, 0xb5, 0x1e, 0x29, + 0x20, 0xd0, 0x4d, 0xac, 0xcc, 0x06, 0xbd, 0xa8, 0x07, 0x39, 0x87, 0xcb, + 0xd0, 0x12, 0x8a, 0x4a, 0x90, 0x04, 0xa4, 0x45, 0xb0, 0x08, 0xa0, 0x02, + 0x20, 0x43, 0xe1, 0x10, 0x01, 0x88, 0x94, 0x46, 0x20, 0xdf, 0xcb, 0xb5, + 0xcf, 0x38, 0xfd, 0x34, 0x04, 0xc9, 0x20, 0x90, 0x02, 0x95, 0xcf, 0xb4, + 0x46, 0x88, 0xd0, 0x0e, 0xb5, 0x87, 0x18, 0x75, 0x58, 0x95, 0x87, 0xb5, + 0x6e, 0x69, 0x00, 0x95, 0x6e, 0x60, 0xb5, 0x87, 0x38, 0xf5, 0x58, 0x95, + 0x87, 0xb5, 0x6e, 0xe9, 0x00, 0x95, 0x6e, 0x60, 0x4c, 0x8c, 0xbf, 0xb5, + 0xa0, 0x29, 0x02, 0xd0, 0x37, 0xa5, 0x09, 0x29, 0x07, 0x48, 0xb5, 0xa0, + 0x4a, 0xb0, 0x15, 0x68, 0xd0, 0x11, 0xbd, 0x34, 0x04, 0x18, 0x69, 0x01, + 0x9d, 0x34, 0x04, 0x95, 0x58, 0xc9, 0x02, 0xd0, 0x02, 0xf6, 0xa0, 0x60, + 0x68, 0xd0, 0x14, 0xbd, 0x34, 0x04, 0x38, 0xe9, 0x01, 0x9d, 0x34, 0x04, + 0x95, 0x58, 0xd0, 0x07, 0xf6, 0xa0, 0xa9, 0x02, 0x9d, 0x96, 0x07, 0x60, + 0xbd, 0x96, 0x07, 0xf0, 0x08, 0xa5, 0x09, 0x4a, 0xb0, 0x02, 0xf6, 0xcf, + 0x60, 0xb5, 0xcf, 0x69, 0x10, 0xc5, 0xce, 0x90, 0xf0, 0xa9, 0x00, 0x95, + 0xa0, 0x60, 0xb5, 0x1e, 0x29, 0x20, 0xf0, 0x03, 0x4c, 0x92, 0xbf, 0xa9, + 0xe8, 0x95, 0x58, 0x4c, 0x02, 0xbf, 0x40, 0x80, 0x04, 0x04, 0xb5, 0x1e, + 0x29, 0x20, 0xf0, 0x03, 0x4c, 0x8c, 0xbf, 0x85, 0x03, 0xb5, 0x16, 0x38, + 0xe9, 0x0a, 0xa8, 0xb9, 0x46, 0xcc, 0x85, 0x02, 0xbd, 0x01, 0x04, 0x38, + 0xe5, 0x02, 0x9d, 0x01, 0x04, 0xb5, 0x87, 0xe9, 0x00, 0x95, 0x87, 0xb5, + 0x6e, 0xe9, 0x00, 0x95, 0x6e, 0xa9, 0x20, 0x85, 0x02, 0xe0, 0x02, 0x90, + 0x49, 0xb5, 0x58, 0xc9, 0x10, 0x90, 0x16, 0xbd, 0x17, 0x04, 0x18, 0x65, + 0x02, 0x9d, 0x17, 0x04, 0xb5, 0xcf, 0x65, 0x03, 0x95, 0xcf, 0xb5, 0xb6, + 0x69, 0x00, 0x4c, 0xac, 0xcc, 0xbd, 0x17, 0x04, 0x38, 0xe5, 0x02, 0x9d, + 0x17, 0x04, 0xb5, 0xcf, 0xe5, 0x03, 0x95, 0xcf, 0xb5, 0xb6, 0xe9, 0x00, + 0x95, 0xb6, 0xa0, 0x00, 0xb5, 0xcf, 0x38, 0xfd, 0x34, 0x04, 0x10, 0x07, + 0xa0, 0x10, 0x49, 0xff, 0x18, 0x69, 0x01, 0xc9, 0x0f, 0x90, 0x03, 0x98, + 0x95, 0x58, 0x60, 0x00, 0x01, 0x03, 0x04, 0x05, 0x06, 0x07, 0x07, 0x08, + 0x00, 0x03, 0x06, 0x09, 0x0b, 0x0d, 0x0e, 0x0f, 0x10, 0x00, 0x04, 0x09, + 0x0d, 0x10, 0x13, 0x16, 0x17, 0x18, 0x00, 0x06, 0x0c, 0x12, 0x16, 0x1a, + 0x1d, 0x1f, 0x20, 0x00, 0x07, 0x0f, 0x16, 0x1c, 0x21, 0x25, 0x27, 0x28, + 0x00, 0x09, 0x12, 0x1b, 0x21, 0x27, 0x2c, 0x2f, 0x30, 0x00, 0x0b, 0x15, + 0x1f, 0x27, 0x2e, 0x33, 0x37, 0x38, 0x00, 0x0c, 0x18, 0x24, 0x2d, 0x35, + 0x3b, 0x3e, 0x40, 0x00, 0x0e, 0x1b, 0x28, 0x32, 0x3b, 0x42, 0x46, 0x48, + 0x00, 0x0f, 0x1f, 0x2d, 0x38, 0x42, 0x4a, 0x4e, 0x50, 0x00, 0x11, 0x22, + 0x31, 0x3e, 0x49, 0x51, 0x56, 0x58, 0x01, 0x03, 0x02, 0x00, 0x00, 0x09, + 0x12, 0x1b, 0x24, 0x2d, 0x36, 0x3f, 0x48, 0x51, 0x5a, 0x63, 0x0c, 0x18, + 0x20, 0xaf, 0xf1, 0xad, 0xd1, 0x03, 0x29, 0x08, 0xd0, 0x74, 0xad, 0x47, + 0x07, 0xd0, 0x0a, 0xbd, 0x88, 0x03, 0x20, 0x10, 0xd4, 0x29, 0x1f, 0x95, + 0xa0, 0xb5, 0xa0, 0xb4, 0x16, 0xc0, 0x1f, 0x90, 0x0d, 0xc9, 0x08, 0xf0, + 0x04, 0xc9, 0x18, 0xd0, 0x05, 0x18, 0x69, 0x01, 0x95, 0xa0, 0x85, 0xef, + 0x20, 0x52, 0xf1, 0x20, 0x8e, 0xce, 0xbc, 0xe5, 0x06, 0xad, 0xb9, 0x03, + 0x99, 0x00, 0x02, 0x85, 0x07, 0xad, 0xae, 0x03, 0x99, 0x03, 0x02, 0x85, + 0x06, 0xa9, 0x01, 0x85, 0x00, 0x20, 0x08, 0xce, 0xa0, 0x05, 0xb5, 0x16, + 0xc9, 0x1f, 0x90, 0x02, 0xa0, 0x0b, 0x84, 0xed, 0xa9, 0x00, 0x85, 0x00, + 0xa5, 0xef, 0x20, 0x8e, 0xce, 0x20, 0xbb, 0xcd, 0xa5, 0x00, 0xc9, 0x04, + 0xd0, 0x08, 0xac, 0xcf, 0x06, 0xb9, 0xe5, 0x06, 0x85, 0x06, 0xe6, 0x00, + 0xa5, 0x00, 0xc5, 0xed, 0x90, 0xe2, 0x60, 0xa5, 0x03, 0x85, 0x05, 0xa4, + 0x06, 0xa5, 0x01, 0x46, 0x05, 0xb0, 0x04, 0x49, 0xff, 0x69, 0x01, 0x18, + 0x6d, 0xae, 0x03, 0x99, 0x03, 0x02, 0x85, 0x06, 0xcd, 0xae, 0x03, 0xb0, + 0x09, 0xad, 0xae, 0x03, 0x38, 0xe5, 0x06, 0x4c, 0xe6, 0xcd, 0x38, 0xed, + 0xae, 0x03, 0xc9, 0x59, 0x90, 0x04, 0xa9, 0xf8, 0xd0, 0x15, 0xad, 0xb9, + 0x03, 0xc9, 0xf8, 0xf0, 0x0e, 0xa5, 0x02, 0x46, 0x05, 0xb0, 0x04, 0x49, + 0xff, 0x69, 0x01, 0x18, 0x6d, 0xb9, 0x03, 0x99, 0x00, 0x02, 0x85, 0x07, + 0x20, 0xed, 0xec, 0x98, 0x48, 0xad, 0x9f, 0x07, 0x0d, 0x47, 0x07, 0xd0, + 0x70, 0x85, 0x05, 0xa4, 0xb5, 0x88, 0xd0, 0x69, 0xa4, 0xce, 0xad, 0x54, + 0x07, 0xd0, 0x05, 0xad, 0x14, 0x07, 0xf0, 0x09, 0xe6, 0x05, 0xe6, 0x05, + 0x98, 0x18, 0x69, 0x18, 0xa8, 0x98, 0x38, 0xe5, 0x07, 0x10, 0x05, 0x49, + 0xff, 0x18, 0x69, 0x01, 0xc9, 0x08, 0xb0, 0x1c, 0xa5, 0x06, 0xc9, 0xf0, + 0xb0, 0x16, 0xad, 0x07, 0x02, 0x18, 0x69, 0x04, 0x85, 0x04, 0x38, 0xe5, + 0x06, 0x10, 0x05, 0x49, 0xff, 0x18, 0x69, 0x01, 0xc9, 0x08, 0x90, 0x13, + 0xa5, 0x05, 0xc9, 0x02, 0xf0, 0x23, 0xa4, 0x05, 0xa5, 0xce, 0x18, 0x79, + 0x3a, 0xcd, 0xe6, 0x05, 0x4c, 0x32, 0xce, 0xa2, 0x01, 0xa5, 0x04, 0xc5, + 0x06, 0xb0, 0x01, 0xe8, 0x86, 0x46, 0xa2, 0x00, 0xa5, 0x00, 0x48, 0x20, + 0x2c, 0xd9, 0x68, 0x85, 0x00, 0x68, 0x18, 0x69, 0x04, 0x85, 0x06, 0xa6, + 0x08, 0x60, 0x48, 0x29, 0x0f, 0xc9, 0x09, 0x90, 0x05, 0x49, 0x0f, 0x18, + 0x69, 0x01, 0x85, 0x01, 0xa4, 0x00, 0xb9, 0x2e, 0xcd, 0x18, 0x65, 0x01, + 0xa8, 0xb9, 0xc7, 0xcc, 0x85, 0x01, 0x68, 0x48, 0x18, 0x69, 0x08, 0x29, + 0x0f, 0xc9, 0x09, 0x90, 0x05, 0x49, 0x0f, 0x18, 0x69, 0x01, 0x85, 0x02, + 0xa4, 0x00, 0xb9, 0x2e, 0xcd, 0x18, 0x65, 0x02, 0xa8, 0xb9, 0xc7, 0xcc, + 0x85, 0x02, 0x68, 0x4a, 0x4a, 0x4a, 0xa8, 0xb9, 0x2a, 0xcd, 0x85, 0x03, + 0x60, 0xf8, 0xa0, 0x70, 0xbd, 0x00, 0x20, 0x20, 0x20, 0x00, 0x00, 0xb5, + 0x1e, 0x29, 0x20, 0xf0, 0x08, 0xa9, 0x00, 0x9d, 0xc5, 0x03, 0x4c, 0x92, + 0xbf, 0x20, 0x02, 0xbf, 0xa0, 0x0d, 0xa9, 0x05, 0x20, 0x96, 0xbf, 0xbd, + 0x34, 0x04, 0x4a, 0x4a, 0x4a, 0x4a, 0xa8, 0xb5, 0xcf, 0x38, 0xf9, 0xd5, + 0xce, 0x10, 0x05, 0x49, 0xff, 0x18, 0x69, 0x01, 0xc9, 0x08, 0xb0, 0x0e, + 0xbd, 0x34, 0x04, 0x18, 0x69, 0x10, 0x9d, 0x34, 0x04, 0x4a, 0x4a, 0x4a, + 0x4a, 0xa8, 0xb9, 0xda, 0xce, 0x9d, 0xc5, 0x03, 0x60, 0x15, 0x30, 0x40, + 0xb5, 0x1e, 0x29, 0x20, 0xf0, 0x03, 0x4c, 0x63, 0xbf, 0xb5, 0x1e, 0xf0, + 0x0b, 0xa9, 0x00, 0x95, 0xa0, 0x8d, 0xcb, 0x06, 0xa9, 0x10, 0xd0, 0x13, + 0xa9, 0x12, 0x8d, 0xcb, 0x06, 0xa0, 0x02, 0xb9, 0x25, 0xcf, 0x99, 0x01, + 0x00, 0x88, 0x10, 0xf7, 0x20, 0x6c, 0xcf, 0x95, 0x58, 0xa0, 0x01, 0xb5, + 0xa0, 0x29, 0x01, 0xd0, 0x0a, 0xb5, 0x58, 0x49, 0xff, 0x18, 0x69, 0x01, + 0x95, 0x58, 0xc8, 0x94, 0x46, 0x4c, 0x02, 0xbf, 0xa0, 0x00, 0x20, 0x43, + 0xe1, 0x10, 0x0a, 0xc8, 0xa5, 0x00, 0x49, 0xff, 0x18, 0x69, 0x01, 0x85, + 0x00, 0xa5, 0x00, 0xc9, 0x3c, 0x90, 0x1c, 0xa9, 0x3c, 0x85, 0x00, 0xb5, + 0x16, 0xc9, 0x11, 0xd0, 0x12, 0x98, 0xd5, 0xa0, 0xf0, 0x0d, 0xb5, 0xa0, + 0xf0, 0x06, 0xd6, 0x58, 0xb5, 0x58, 0xd0, 0x40, 0x98, 0x95, 0xa0, 0xa5, + 0x00, 0x29, 0x3c, 0x4a, 0x4a, 0x85, 0x00, 0xa0, 0x00, 0xa5, 0x57, 0xf0, + 0x24, 0xad, 0x75, 0x07, 0xf0, 0x1f, 0xc8, 0xa5, 0x57, 0xc9, 0x19, 0x90, + 0x08, 0xad, 0x75, 0x07, 0xc9, 0x02, 0x90, 0x01, 0xc8, 0xb5, 0x16, 0xc9, + 0x12, 0xd0, 0x04, 0xa5, 0x57, 0xd0, 0x06, 0xb5, 0xa0, 0xd0, 0x02, 0xa0, + 0x00, 0xb9, 0x01, 0x00, 0xa4, 0x00, 0x38, 0xe9, 0x01, 0x88, 0x10, 0xfa, + 0x60, 0x1a, 0x58, 0x98, 0x96, 0x94, 0x92, 0x90, 0x8e, 0x8c, 0x8a, 0x88, + 0x86, 0x84, 0x82, 0x80, 0xae, 0x68, 0x03, 0xb5, 0x16, 0xc9, 0x2d, 0xd0, + 0x10, 0x86, 0x08, 0xb5, 0x1e, 0xf0, 0x1a, 0x29, 0x40, 0xf0, 0x06, 0xb5, + 0xcf, 0xc9, 0xe0, 0x90, 0x0a, 0xa9, 0x80, 0x85, 0xfc, 0xee, 0x72, 0x07, + 0x4c, 0x71, 0xd0, 0x20, 0x8c, 0xbf, 0x4c, 0x7b, 0xd1, 0xce, 0x64, 0x03, + 0xd0, 0x44, 0xa9, 0x04, 0x8d, 0x64, 0x03, 0xad, 0x63, 0x03, 0x49, 0x01, + 0x8d, 0x63, 0x03, 0xa9, 0x22, 0x85, 0x05, 0xac, 0x69, 0x03, 0xb9, 0xdd, + 0xcf, 0x85, 0x04, 0xac, 0x00, 0x03, 0xc8, 0xa2, 0x0c, 0x20, 0xcd, 0x8a, + 0xa6, 0x08, 0x20, 0x8f, 0x8a, 0xa9, 0x08, 0x85, 0xfe, 0xa9, 0x01, 0x85, + 0xfd, 0xee, 0x69, 0x03, 0xad, 0x69, 0x03, 0xc9, 0x0f, 0xd0, 0x0b, 0x20, + 0x63, 0xc3, 0xa9, 0x40, 0x95, 0x1e, 0xa9, 0x80, 0x85, 0xfe, 0x4c, 0x7b, + 0xd1, 0x21, 0x41, 0x11, 0x31, 0xb5, 0x1e, 0x29, 0x20, 0xf0, 0x14, 0xb5, + 0xcf, 0xc9, 0xe0, 0x90, 0x9e, 0xa2, 0x04, 0x20, 0x98, 0xc9, 0xca, 0x10, + 0xfa, 0x8d, 0xcb, 0x06, 0xa6, 0x08, 0x60, 0xa9, 0x00, 0x8d, 0xcb, 0x06, + 0xad, 0x47, 0x07, 0xf0, 0x03, 0x4c, 0x39, 0xd1, 0xad, 0x63, 0x03, 0x10, + 0x03, 0x4c, 0x0f, 0xd1, 0xce, 0x64, 0x03, 0xd0, 0x0d, 0xa9, 0x20, 0x8d, + 0x64, 0x03, 0xad, 0x63, 0x03, 0x49, 0x01, 0x8d, 0x63, 0x03, 0xa5, 0x09, + 0x29, 0x0f, 0xd0, 0x04, 0xa9, 0x02, 0x95, 0x46, 0xbd, 0x8a, 0x07, 0xf0, + 0x1c, 0x20, 0x43, 0xe1, 0x10, 0x17, 0xa9, 0x01, 0x95, 0x46, 0xa9, 0x02, + 0x8d, 0x65, 0x03, 0xa9, 0x20, 0x9d, 0x8a, 0x07, 0x8d, 0x90, 0x07, 0xb5, + 0x87, 0xc9, 0xc8, 0xb0, 0x3e, 0xa5, 0x09, 0x29, 0x03, 0xd0, 0x38, 0xb5, + 0x87, 0xcd, 0x66, 0x03, 0xd0, 0x0c, 0xbd, 0xa7, 0x07, 0x29, 0x03, 0xa8, + 0xb9, 0x61, 0xd0, 0x8d, 0xdc, 0x06, 0xb5, 0x87, 0x18, 0x6d, 0x65, 0x03, + 0x95, 0x87, 0xb4, 0x46, 0xc0, 0x01, 0xf0, 0x17, 0xa0, 0xff, 0x38, 0xed, + 0x66, 0x03, 0x10, 0x07, 0x49, 0xff, 0x18, 0x69, 0x01, 0xa0, 0x01, 0xcd, + 0xdc, 0x06, 0x90, 0x03, 0x8c, 0x65, 0x03, 0xbd, 0x8a, 0x07, 0xd0, 0x28, + 0x20, 0x8c, 0xbf, 0xad, 0x5f, 0x07, 0xc9, 0x05, 0x90, 0x09, 0xa5, 0x09, + 0x29, 0x03, 0xd0, 0x03, 0x20, 0x94, 0xba, 0xb5, 0xcf, 0xc9, 0x80, 0x90, + 0x1c, 0xbd, 0xa7, 0x07, 0x29, 0x03, 0xa8, 0xb9, 0x61, 0xd0, 0x9d, 0x8a, + 0x07, 0x4c, 0x49, 0xd1, 0xc9, 0x01, 0xd0, 0x09, 0xd6, 0xcf, 0x20, 0x63, + 0xc3, 0xa9, 0xfe, 0x95, 0xa0, 0xad, 0x5f, 0x07, 0xc9, 0x07, 0xf0, 0x04, + 0xc9, 0x05, 0xb0, 0x27, 0xad, 0x90, 0x07, 0xd0, 0x22, 0xa9, 0x20, 0x8d, + 0x90, 0x07, 0xad, 0x63, 0x03, 0x49, 0x80, 0x8d, 0x63, 0x03, 0x30, 0xe1, + 0x20, 0xd9, 0xd1, 0xac, 0xcc, 0x06, 0xf0, 0x03, 0x38, 0xe9, 0x10, 0x8d, + 0x90, 0x07, 0xa9, 0x15, 0x8d, 0xcb, 0x06, 0x20, 0xbc, 0xd1, 0xa0, 0x10, + 0xb5, 0x46, 0x4a, 0x90, 0x02, 0xa0, 0xf0, 0x98, 0x18, 0x75, 0x87, 0xac, + 0xcf, 0x06, 0x99, 0x87, 0x00, 0xb5, 0xcf, 0x18, 0x69, 0x08, 0x99, 0xcf, + 0x00, 0xb5, 0x1e, 0x99, 0x1e, 0x00, 0xb5, 0x46, 0x99, 0x46, 0x00, 0xa5, + 0x08, 0x48, 0xae, 0xcf, 0x06, 0x86, 0x08, 0xa9, 0x2d, 0x95, 0x16, 0x20, + 0xbc, 0xd1, 0x68, 0x85, 0x08, 0xaa, 0xa9, 0x00, 0x8d, 0x6a, 0x03, 0x60, + 0xee, 0x6a, 0x03, 0x20, 0xd7, 0xc8, 0xb5, 0x1e, 0xd0, 0xf5, 0xa9, 0x0a, + 0x9d, 0x9a, 0x04, 0x20, 0x43, 0xe2, 0x4c, 0x53, 0xd8, 0xbf, 0x40, 0xbf, + 0xbf, 0xbf, 0x40, 0x40, 0xbf, 0xac, 0x67, 0x03, 0xee, 0x67, 0x03, 0xad, + 0x67, 0x03, 0x29, 0x07, 0x8d, 0x67, 0x03, 0xb9, 0xd1, 0xd1, 0x60, 0xad, + 0x47, 0x07, 0xd0, 0x30, 0xa9, 0x40, 0xac, 0xcc, 0x06, 0xf0, 0x02, 0xa9, + 0x60, 0x85, 0x00, 0xbd, 0x01, 0x04, 0x38, 0xe5, 0x00, 0x9d, 0x01, 0x04, + 0xb5, 0x87, 0xe9, 0x01, 0x95, 0x87, 0xb5, 0x6e, 0xe9, 0x00, 0x95, 0x6e, + 0xbc, 0x17, 0x04, 0xb5, 0xcf, 0xd9, 0x9d, 0xc5, 0xf0, 0x06, 0x18, 0x7d, + 0x34, 0x04, 0x95, 0xcf, 0x20, 0x52, 0xf1, 0xb5, 0x1e, 0xd0, 0xc3, 0xa9, + 0x51, 0x85, 0x00, 0xa0, 0x02, 0xa5, 0x09, 0x29, 0x02, 0xf0, 0x02, 0xa0, + 0x82, 0x84, 0x01, 0xbc, 0xe5, 0x06, 0xa2, 0x00, 0xad, 0xb9, 0x03, 0x99, + 0x00, 0x02, 0xa5, 0x00, 0x99, 0x01, 0x02, 0xe6, 0x00, 0xa5, 0x01, 0x99, + 0x02, 0x02, 0xad, 0xae, 0x03, 0x99, 0x03, 0x02, 0x18, 0x69, 0x08, 0x8d, + 0xae, 0x03, 0xc8, 0xc8, 0xc8, 0xc8, 0xe8, 0xe0, 0x03, 0x90, 0xd9, 0xa6, + 0x08, 0x20, 0xaf, 0xf1, 0xbc, 0xe5, 0x06, 0xad, 0xd1, 0x03, 0x4a, 0x48, + 0x90, 0x05, 0xa9, 0xf8, 0x99, 0x0c, 0x02, 0x68, 0x4a, 0x48, 0x90, 0x05, + 0xa9, 0xf8, 0x99, 0x08, 0x02, 0x68, 0x4a, 0x48, 0x90, 0x05, 0xa9, 0xf8, + 0x99, 0x04, 0x02, 0x68, 0x4a, 0x90, 0x05, 0xa9, 0xf8, 0x99, 0x00, 0x02, + 0x60, 0xd6, 0xa0, 0xd0, 0x0c, 0xa9, 0x08, 0x95, 0xa0, 0xf6, 0x58, 0xb5, + 0x58, 0xc9, 0x03, 0xb0, 0x18, 0x20, 0x52, 0xf1, 0xad, 0xb9, 0x03, 0x8d, + 0xba, 0x03, 0xad, 0xae, 0x03, 0x8d, 0xaf, 0x03, 0xbc, 0xe5, 0x06, 0xb5, + 0x58, 0x20, 0x17, 0xed, 0x60, 0xa9, 0x00, 0x95, 0x0f, 0xa9, 0x08, 0x85, + 0xfe, 0xa9, 0x05, 0x8d, 0x38, 0x01, 0x4c, 0x36, 0xd3, 0x00, 0x00, 0x08, + 0x08, 0x00, 0x08, 0x00, 0x08, 0x54, 0x55, 0x56, 0x57, 0xa9, 0x00, 0x8d, + 0xcb, 0x06, 0xad, 0x46, 0x07, 0xc9, 0x05, 0xb0, 0x2c, 0x20, 0x04, 0x8e, + 0x11, 0xd3, 0xf2, 0xd2, 0x12, 0xd3, 0x4e, 0xd3, 0xa2, 0xd3, 0xa0, 0x05, + 0xad, 0xfa, 0x07, 0xc9, 0x01, 0xf0, 0x0e, 0xa0, 0x03, 0xc9, 0x03, 0xf0, + 0x08, 0xa0, 0x00, 0xc9, 0x06, 0xf0, 0x02, 0xa9, 0xff, 0x8d, 0xd7, 0x06, + 0x94, 0x1e, 0xee, 0x46, 0x07, 0x60, 0xad, 0xf8, 0x07, 0x0d, 0xf9, 0x07, + 0x0d, 0xfa, 0x07, 0xf0, 0xf1, 0xa5, 0x09, 0x29, 0x04, 0xf0, 0x04, 0xa9, + 0x10, 0x85, 0xfe, 0xa0, 0x23, 0xa9, 0xff, 0x8d, 0x39, 0x01, 0x20, 0x5f, + 0x8f, 0xa9, 0x05, 0x8d, 0x39, 0x01, 0xa0, 0x0b, 0xad, 0x53, 0x07, 0xf0, + 0x02, 0xa0, 0x11, 0x20, 0x5f, 0x8f, 0xad, 0x53, 0x07, 0x0a, 0x0a, 0x0a, + 0x0a, 0x09, 0x04, 0x4c, 0x36, 0xbc, 0xb5, 0xcf, 0xc9, 0x72, 0x90, 0x05, + 0xd6, 0xcf, 0x4c, 0x65, 0xd3, 0xad, 0xd7, 0x06, 0xf0, 0x38, 0x30, 0x36, + 0xa9, 0x16, 0x8d, 0xcb, 0x06, 0x20, 0x52, 0xf1, 0xbc, 0xe5, 0x06, 0xa2, + 0x03, 0xad, 0xb9, 0x03, 0x18, 0x7d, 0xcd, 0xd2, 0x99, 0x00, 0x02, 0xbd, + 0xd5, 0xd2, 0x99, 0x01, 0x02, 0xa9, 0x22, 0x99, 0x02, 0x02, 0xad, 0xae, + 0x03, 0x18, 0x7d, 0xd1, 0xd2, 0x99, 0x03, 0x02, 0xc8, 0xc8, 0xc8, 0xc8, + 0xca, 0x10, 0xda, 0xa6, 0x08, 0x60, 0x20, 0x65, 0xd3, 0xa9, 0x06, 0x9d, + 0x96, 0x07, 0xee, 0x46, 0x07, 0x60, 0x20, 0x65, 0xd3, 0xbd, 0x96, 0x07, + 0xd0, 0x05, 0xad, 0xb1, 0x07, 0xf0, 0xef, 0x60, 0xb5, 0x1e, 0xd0, 0x56, + 0xbd, 0x8a, 0x07, 0xd0, 0x51, 0xb5, 0xa0, 0xd0, 0x23, 0xb5, 0x58, 0x30, + 0x14, 0x20, 0x43, 0xe1, 0x10, 0x09, 0xa5, 0x00, 0x49, 0xff, 0x18, 0x69, + 0x01, 0x85, 0x00, 0xa5, 0x00, 0xc9, 0x21, 0x90, 0x35, 0xb5, 0x58, 0x49, + 0xff, 0x18, 0x69, 0x01, 0x95, 0x58, 0xf6, 0xa0, 0xbd, 0x34, 0x04, 0xb4, + 0x58, 0x10, 0x03, 0xbd, 0x17, 0x04, 0x85, 0x00, 0xa5, 0x09, 0x4a, 0x90, + 0x19, 0xad, 0x47, 0x07, 0xd0, 0x14, 0xb5, 0xcf, 0x18, 0x75, 0x58, 0x95, + 0xcf, 0xc5, 0x00, 0xd0, 0x09, 0xa9, 0x00, 0x95, 0xa0, 0xa9, 0x40, 0x9d, + 0x8a, 0x07, 0xa9, 0x20, 0x9d, 0xc5, 0x03, 0x60, 0x85, 0x07, 0xb5, 0x34, + 0xd0, 0x0e, 0xa0, 0x18, 0xb5, 0x58, 0x18, 0x65, 0x07, 0x95, 0x58, 0xb5, + 0xa0, 0x69, 0x00, 0x60, 0xa0, 0x08, 0xb5, 0x58, 0x38, 0xe5, 0x07, 0x95, + 0x58, 0xb5, 0xa0, 0xe9, 0x00, 0x60, 0xb5, 0xb6, 0xc9, 0x03, 0xd0, 0x03, + 0x4c, 0x98, 0xc9, 0xb5, 0x1e, 0x10, 0x01, 0x60, 0xa8, 0xbd, 0xa2, 0x03, + 0x85, 0x00, 0xb5, 0x46, 0xf0, 0x03, 0x4c, 0xbb, 0xd5, 0xa9, 0x2d, 0xd5, + 0xcf, 0x90, 0x0f, 0xc4, 0x00, 0xf0, 0x08, 0x18, 0x69, 0x02, 0x95, 0xcf, + 0x4c, 0xb1, 0xd5, 0x4c, 0x98, 0xd5, 0xd9, 0xcf, 0x00, 0x90, 0x0d, 0xe4, + 0x00, 0xf0, 0xf4, 0x18, 0x69, 0x02, 0x99, 0xcf, 0x00, 0x4c, 0xb1, 0xd5, + 0xb5, 0xcf, 0x48, 0xbd, 0xa2, 0x03, 0x10, 0x18, 0xbd, 0x34, 0x04, 0x18, + 0x69, 0x05, 0x85, 0x00, 0xb5, 0xa0, 0x69, 0x00, 0x30, 0x1a, 0xd0, 0x0c, + 0xa5, 0x00, 0xc9, 0x0b, 0x90, 0x0c, 0xb0, 0x04, 0xc5, 0x08, 0xf0, 0x0c, + 0x20, 0xb7, 0xbf, 0x4c, 0xa7, 0xd4, 0x20, 0xb1, 0xd5, 0x4c, 0xa7, 0xd4, + 0x20, 0xb4, 0xbf, 0xb4, 0x1e, 0x68, 0x38, 0xf5, 0xcf, 0x18, 0x79, 0xcf, + 0x00, 0x99, 0xcf, 0x00, 0xbd, 0xa2, 0x03, 0x30, 0x04, 0xaa, 0x20, 0x21, + 0xdc, 0xa4, 0x08, 0xb9, 0xa0, 0x00, 0x19, 0x34, 0x04, 0xf0, 0x77, 0xae, + 0x00, 0x03, 0xe0, 0x20, 0xb0, 0x70, 0xb9, 0xa0, 0x00, 0x48, 0x48, 0x20, + 0x41, 0xd5, 0xa5, 0x01, 0x9d, 0x01, 0x03, 0xa5, 0x00, 0x9d, 0x02, 0x03, + 0xa9, 0x02, 0x9d, 0x03, 0x03, 0xb9, 0xa0, 0x00, 0x30, 0x0d, 0xa9, 0xa2, + 0x9d, 0x04, 0x03, 0xa9, 0xa3, 0x9d, 0x05, 0x03, 0x4c, 0xff, 0xd4, 0xa9, + 0x24, 0x9d, 0x04, 0x03, 0x9d, 0x05, 0x03, 0xb9, 0x1e, 0x00, 0xa8, 0x68, + 0x49, 0xff, 0x20, 0x41, 0xd5, 0xa5, 0x01, 0x9d, 0x06, 0x03, 0xa5, 0x00, + 0x9d, 0x07, 0x03, 0xa9, 0x02, 0x9d, 0x08, 0x03, 0x68, 0x10, 0x0d, 0xa9, + 0xa2, 0x9d, 0x09, 0x03, 0xa9, 0xa3, 0x9d, 0x0a, 0x03, 0x4c, 0x30, 0xd5, + 0xa9, 0x24, 0x9d, 0x09, 0x03, 0x9d, 0x0a, 0x03, 0xa9, 0x00, 0x9d, 0x0b, + 0x03, 0xad, 0x00, 0x03, 0x18, 0x69, 0x0a, 0x8d, 0x00, 0x03, 0xa6, 0x08, + 0x60, 0x48, 0xb9, 0x87, 0x00, 0x18, 0x69, 0x08, 0xae, 0xcc, 0x06, 0xd0, + 0x03, 0x18, 0x69, 0x10, 0x48, 0xb9, 0x6e, 0x00, 0x69, 0x00, 0x85, 0x02, + 0x68, 0x29, 0xf0, 0x4a, 0x4a, 0x4a, 0x85, 0x00, 0xb6, 0xcf, 0x68, 0x10, + 0x05, 0x8a, 0x18, 0x69, 0x08, 0xaa, 0x8a, 0xae, 0x00, 0x03, 0x0a, 0x2a, + 0x48, 0x2a, 0x29, 0x03, 0x09, 0x20, 0x85, 0x01, 0xa5, 0x02, 0x29, 0x01, + 0x0a, 0x0a, 0x05, 0x01, 0x85, 0x01, 0x68, 0x29, 0xe0, 0x18, 0x65, 0x00, + 0x85, 0x00, 0xb9, 0xcf, 0x00, 0xc9, 0xe8, 0x90, 0x06, 0xa5, 0x00, 0x29, + 0xbf, 0x85, 0x00, 0x60, 0x98, 0xaa, 0x20, 0xaf, 0xf1, 0xa9, 0x06, 0x20, + 0x11, 0xda, 0xad, 0xad, 0x03, 0x9d, 0x17, 0x01, 0xa5, 0xce, 0x9d, 0x1e, + 0x01, 0xa9, 0x01, 0x95, 0x46, 0x20, 0x63, 0xc3, 0x99, 0xa0, 0x00, 0x99, + 0x34, 0x04, 0x60, 0x98, 0x48, 0x20, 0x6b, 0xbf, 0x68, 0xaa, 0x20, 0x6b, + 0xbf, 0xa6, 0x08, 0xbd, 0xa2, 0x03, 0x30, 0x04, 0xaa, 0x20, 0x21, 0xdc, + 0xa6, 0x08, 0x60, 0xb5, 0xa0, 0x1d, 0x34, 0x04, 0xd0, 0x15, 0x9d, 0x17, + 0x04, 0xb5, 0xcf, 0xdd, 0x01, 0x04, 0xb0, 0x0b, 0xa5, 0x09, 0x29, 0x07, + 0xd0, 0x02, 0xf6, 0xcf, 0x4c, 0xfe, 0xd5, 0xb5, 0xcf, 0xd5, 0x58, 0x90, + 0x06, 0x20, 0xb7, 0xbf, 0x4c, 0xfe, 0xd5, 0x20, 0xb4, 0xbf, 0xbd, 0xa2, + 0x03, 0x30, 0x03, 0x20, 0x21, 0xdc, 0x60, 0xa9, 0x0e, 0x20, 0x47, 0xcb, + 0x20, 0x66, 0xcb, 0xbd, 0xa2, 0x03, 0x30, 0x1c, 0xa5, 0x86, 0x18, 0x65, + 0x00, 0x85, 0x86, 0xa5, 0x6d, 0xa4, 0x00, 0x30, 0x05, 0x69, 0x00, 0x4c, + 0x28, 0xd6, 0xe9, 0x00, 0x85, 0x6d, 0x8c, 0xa1, 0x03, 0x20, 0x21, 0xdc, + 0x60, 0xbd, 0xa2, 0x03, 0x30, 0x06, 0x20, 0x88, 0xbf, 0x20, 0x21, 0xdc, + 0x60, 0x20, 0x02, 0xbf, 0x85, 0x00, 0xbd, 0xa2, 0x03, 0x30, 0x07, 0xa9, + 0x10, 0x95, 0x58, 0x20, 0x14, 0xd6, 0x60, 0x20, 0x5b, 0xd6, 0x4c, 0xfe, + 0xd5, 0x20, 0x5b, 0xd6, 0x4c, 0x71, 0xd6, 0xad, 0x47, 0x07, 0xd0, 0x19, + 0xbd, 0x17, 0x04, 0x18, 0x7d, 0x34, 0x04, 0x9d, 0x17, 0x04, 0xb5, 0xcf, + 0x75, 0xa0, 0x95, 0xcf, 0x60, 0xbd, 0xa2, 0x03, 0xf0, 0x03, 0x20, 0x19, + 0xdc, 0x60, 0xb5, 0x16, 0xc9, 0x14, 0xf0, 0x55, 0xad, 0x1c, 0x07, 0xb4, + 0x16, 0xc0, 0x05, 0xf0, 0x04, 0xc0, 0x0d, 0xd0, 0x02, 0x69, 0x38, 0xe9, + 0x48, 0x85, 0x01, 0xad, 0x1a, 0x07, 0xe9, 0x00, 0x85, 0x00, 0xad, 0x1d, + 0x07, 0x69, 0x48, 0x85, 0x03, 0xad, 0x1b, 0x07, 0x69, 0x00, 0x85, 0x02, + 0xb5, 0x87, 0xc5, 0x01, 0xb5, 0x6e, 0xe5, 0x00, 0x30, 0x20, 0xb5, 0x87, + 0xc5, 0x03, 0xb5, 0x6e, 0xe5, 0x02, 0x30, 0x19, 0xb5, 0x1e, 0xc9, 0x05, + 0xf0, 0x13, 0xc0, 0x0d, 0xf0, 0x0f, 0xc0, 0x30, 0xf0, 0x0b, 0xc0, 0x31, + 0xf0, 0x07, 0xc0, 0x32, 0xf0, 0x03, 0x20, 0x98, 0xc9, 0x60, 0xff, 0xff, + 0xff, 0xb5, 0x24, 0xf0, 0x56, 0x0a, 0xb0, 0x53, 0xa5, 0x09, 0x4a, 0xb0, + 0x4e, 0x8a, 0x0a, 0x0a, 0x18, 0x69, 0x1c, 0xa8, 0xa2, 0x04, 0x86, 0x01, + 0x98, 0x48, 0xb5, 0x1e, 0x29, 0x20, 0xd0, 0x34, 0xb5, 0x0f, 0xf0, 0x30, + 0xb5, 0x16, 0xc9, 0x24, 0x90, 0x04, 0xc9, 0x2b, 0x90, 0x26, 0xc9, 0x06, + 0xd0, 0x06, 0xb5, 0x1e, 0xc9, 0x02, 0xb0, 0x1c, 0xbd, 0xd8, 0x03, 0xd0, + 0x17, 0x8a, 0x0a, 0x0a, 0x18, 0x69, 0x04, 0xaa, 0x20, 0x27, 0xe3, 0xa6, + 0x08, 0x90, 0x09, 0xa9, 0x80, 0x95, 0x24, 0xa6, 0x01, 0x20, 0x3e, 0xd7, + 0x68, 0xa8, 0xa6, 0x01, 0xca, 0x10, 0xbb, 0xa6, 0x08, 0x60, 0x06, 0x00, + 0x02, 0x12, 0x11, 0x07, 0x05, 0x2d, 0x20, 0x52, 0xf1, 0xa6, 0x01, 0xb5, + 0x0f, 0x10, 0x0b, 0x29, 0x0f, 0xaa, 0xb5, 0x16, 0xc9, 0x2d, 0xf0, 0x0c, + 0xa6, 0x01, 0xb5, 0x16, 0xc9, 0x02, 0xf0, 0x6b, 0xc9, 0x2d, 0xd0, 0x2d, + 0xce, 0x83, 0x04, 0xd0, 0x62, 0x20, 0x63, 0xc3, 0x95, 0x58, 0x8d, 0xcb, + 0x06, 0xa9, 0xfe, 0x95, 0xa0, 0xac, 0x5f, 0x07, 0xb9, 0x36, 0xd7, 0x95, + 0x16, 0xa9, 0x20, 0xc0, 0x03, 0xb0, 0x02, 0x09, 0x03, 0x95, 0x1e, 0xa9, + 0x80, 0x85, 0xfe, 0xa6, 0x01, 0xa9, 0x09, 0xd0, 0x33, 0xc9, 0x08, 0xf0, + 0x36, 0xc9, 0x0c, 0xf0, 0x32, 0xc9, 0x15, 0xb0, 0x2e, 0xb5, 0x16, 0xc9, + 0x0d, 0xd0, 0x06, 0xb5, 0xcf, 0x69, 0x18, 0x95, 0xcf, 0x20, 0x1b, 0xe0, + 0xb5, 0x1e, 0x29, 0x1f, 0x09, 0x20, 0x95, 0x1e, 0xa9, 0x02, 0xb4, 0x16, + 0xc0, 0x05, 0xd0, 0x02, 0xa9, 0x06, 0xc0, 0x06, 0xd0, 0x02, 0xa9, 0x01, + 0x20, 0x11, 0xda, 0xa9, 0x08, 0x85, 0xff, 0x60, 0xa5, 0x09, 0x4a, 0x90, + 0x36, 0xad, 0x47, 0x07, 0x0d, 0xd6, 0x03, 0xd0, 0x2e, 0x8a, 0x0a, 0x0a, + 0x18, 0x69, 0x24, 0xa8, 0x20, 0x25, 0xe3, 0xa6, 0x08, 0x90, 0x1b, 0xbd, + 0xbe, 0x06, 0xd0, 0x1b, 0xa9, 0x01, 0x9d, 0xbe, 0x06, 0xb5, 0x64, 0x49, + 0xff, 0x18, 0x69, 0x01, 0x95, 0x64, 0xad, 0x9f, 0x07, 0xd0, 0x08, 0x4c, + 0x2c, 0xd9, 0xa9, 0x00, 0x9d, 0xbe, 0x06, 0x60, 0x20, 0x98, 0xc9, 0xa9, + 0x06, 0x20, 0x11, 0xda, 0xa9, 0x20, 0x85, 0xfe, 0xa5, 0x39, 0xc9, 0x02, + 0x90, 0x0e, 0xc9, 0x03, 0xf0, 0x24, 0xa9, 0x23, 0x8d, 0x9f, 0x07, 0xa9, + 0x40, 0x85, 0xfb, 0x60, 0xad, 0x56, 0x07, 0xf0, 0x1b, 0xc9, 0x01, 0xd0, + 0x23, 0xa6, 0x08, 0xa9, 0x02, 0x8d, 0x56, 0x07, 0x20, 0xf1, 0x85, 0xa6, + 0x08, 0xa9, 0x0c, 0x4c, 0x47, 0xd8, 0xa9, 0x0b, 0x9d, 0x10, 0x01, 0x60, + 0xa9, 0x01, 0x8d, 0x56, 0x07, 0xa9, 0x09, 0xa0, 0x00, 0x20, 0x48, 0xd9, + 0x60, 0x18, 0xe8, 0x30, 0xd0, 0x08, 0xf8, 0xa5, 0x09, 0x4a, 0xb0, 0xf4, + 0x20, 0x41, 0xdc, 0xb0, 0x23, 0xbd, 0xd8, 0x03, 0xd0, 0x1e, 0xa5, 0x0e, + 0xc9, 0x08, 0xd0, 0x18, 0xb5, 0x1e, 0x29, 0x20, 0xd0, 0x12, 0x20, 0x52, + 0xdc, 0x20, 0x25, 0xe3, 0xa6, 0x08, 0xb0, 0x09, 0xbd, 0x91, 0x04, 0x29, + 0xfe, 0x9d, 0x91, 0x04, 0x60, 0xb4, 0x16, 0xc0, 0x2e, 0xd0, 0x03, 0x4c, + 0x00, 0xd8, 0xad, 0x9f, 0x07, 0xf0, 0x06, 0x4c, 0x95, 0xd7, 0x0a, 0x06, + 0x04, 0xbd, 0x91, 0x04, 0x29, 0x01, 0x1d, 0xd8, 0x03, 0xd0, 0x59, 0xa9, + 0x01, 0x1d, 0x91, 0x04, 0x9d, 0x91, 0x04, 0xc0, 0x12, 0xf0, 0x4e, 0xc0, + 0x0d, 0xf0, 0x7d, 0xc0, 0x0c, 0xf0, 0x79, 0xc0, 0x33, 0xf0, 0x42, 0xc0, + 0x15, 0xb0, 0x71, 0xad, 0x4e, 0x07, 0xf0, 0x6c, 0xb5, 0x1e, 0x0a, 0xb0, + 0x34, 0xb5, 0x1e, 0x29, 0x07, 0xc9, 0x02, 0x90, 0x2c, 0xb5, 0x16, 0xc9, + 0x06, 0xf0, 0x25, 0xa9, 0x08, 0x85, 0xff, 0xb5, 0x1e, 0x09, 0x80, 0x95, + 0x1e, 0x20, 0x05, 0xda, 0xb9, 0x4f, 0xd8, 0x95, 0x58, 0xa9, 0x03, 0x18, + 0x6d, 0x84, 0x04, 0xbc, 0x96, 0x07, 0xc0, 0x03, 0xb0, 0x03, 0xb9, 0x92, + 0xd8, 0x20, 0x11, 0xda, 0x60, 0xa5, 0x9f, 0x30, 0x02, 0xd0, 0x6a, 0xb5, + 0x16, 0xc9, 0x07, 0x90, 0x09, 0xa5, 0xce, 0x18, 0x69, 0x0c, 0xd5, 0xcf, + 0x90, 0x5b, 0xad, 0x91, 0x07, 0xd0, 0x56, 0xad, 0x9e, 0x07, 0xd0, 0x3d, + 0xad, 0xad, 0x03, 0xcd, 0xae, 0x03, 0x90, 0x03, 0x4c, 0xf6, 0xd9, 0xb5, + 0x46, 0xc9, 0x01, 0xd0, 0x03, 0x4c, 0xff, 0xd9, 0xad, 0x9e, 0x07, 0xd0, + 0x24, 0xae, 0x56, 0x07, 0xf0, 0x22, 0x8d, 0x56, 0x07, 0xa9, 0x08, 0x8d, + 0x9e, 0x07, 0x0a, 0x85, 0xff, 0x20, 0xf1, 0x85, 0xa9, 0x0a, 0xa0, 0x01, + 0x85, 0x0e, 0x84, 0x1d, 0xa0, 0xff, 0x8c, 0x47, 0x07, 0xc8, 0x8c, 0x75, + 0x07, 0xa6, 0x08, 0x60, 0x86, 0x57, 0xe8, 0x86, 0xfc, 0xa9, 0xfc, 0x85, + 0x9f, 0xa9, 0x0b, 0xd0, 0xe1, 0x02, 0x06, 0x05, 0x06, 0xb5, 0x16, 0xc9, + 0x12, 0xf0, 0xbd, 0xa9, 0x04, 0x85, 0xff, 0xb5, 0x16, 0xa0, 0x00, 0xc9, + 0x14, 0xf0, 0x1b, 0xc9, 0x08, 0xf0, 0x17, 0xc9, 0x33, 0xf0, 0x13, 0xc9, + 0x0c, 0xf0, 0x0f, 0xc8, 0xc9, 0x05, 0xf0, 0x0a, 0xc8, 0xc9, 0x11, 0xf0, + 0x05, 0xc8, 0xc9, 0x07, 0xd0, 0x1d, 0xb9, 0x65, 0xd9, 0x20, 0x11, 0xda, + 0xb5, 0x46, 0x48, 0x20, 0x2f, 0xe0, 0x68, 0x95, 0x46, 0xa9, 0x20, 0x95, + 0x1e, 0x20, 0x63, 0xc3, 0x95, 0x58, 0xa9, 0xfd, 0x85, 0x9f, 0x60, 0xc9, + 0x09, 0x90, 0x1d, 0x29, 0x01, 0x95, 0x16, 0xa0, 0x00, 0x94, 0x1e, 0xa9, + 0x03, 0x20, 0x11, 0xda, 0x20, 0x63, 0xc3, 0x20, 0x05, 0xda, 0xb9, 0x51, + 0xd8, 0x95, 0x58, 0x4c, 0xf1, 0xd9, 0x10, 0x0b, 0xa9, 0x04, 0x95, 0x1e, + 0xee, 0x84, 0x04, 0xad, 0x84, 0x04, 0x18, 0x6d, 0x91, 0x07, 0x20, 0x11, + 0xda, 0xee, 0x91, 0x07, 0xac, 0x6a, 0x07, 0xb9, 0xd2, 0xd9, 0x9d, 0x96, + 0x07, 0xa9, 0xfc, 0x85, 0x9f, 0x60, 0xb5, 0x46, 0xc9, 0x01, 0xd0, 0x03, + 0x4c, 0x2c, 0xd9, 0x20, 0x1c, 0xdb, 0x4c, 0x2c, 0xd9, 0xa0, 0x01, 0x20, + 0x43, 0xe1, 0x10, 0x01, 0xc8, 0x94, 0x46, 0x88, 0x60, 0x9d, 0x10, 0x01, + 0xa9, 0x30, 0x9d, 0x2c, 0x01, 0xb5, 0xcf, 0x9d, 0x1e, 0x01, 0xad, 0xae, + 0x03, 0x9d, 0x17, 0x01, 0x60, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, + 0x7f, 0xbf, 0xdf, 0xef, 0xf7, 0xfb, 0xfd, 0xa5, 0x09, 0x4a, 0x90, 0xec, + 0xad, 0x4e, 0x07, 0xf0, 0xe7, 0xb5, 0x16, 0xc9, 0x15, 0xb0, 0x6e, 0xc9, + 0x11, 0xf0, 0x6a, 0xc9, 0x0d, 0xf0, 0x66, 0xbd, 0xd8, 0x03, 0xd0, 0x61, + 0x20, 0x52, 0xdc, 0xca, 0x30, 0x5b, 0x86, 0x01, 0x98, 0x48, 0xb5, 0x0f, + 0xf0, 0x4c, 0xb5, 0x16, 0xc9, 0x15, 0xb0, 0x46, 0xc9, 0x11, 0xf0, 0x42, + 0xc9, 0x0d, 0xf0, 0x3e, 0xbd, 0xd8, 0x03, 0xd0, 0x39, 0x8a, 0x0a, 0x0a, + 0x18, 0x69, 0x04, 0xaa, 0x20, 0x27, 0xe3, 0xa6, 0x08, 0xa4, 0x01, 0x90, + 0x20, 0xb5, 0x1e, 0x19, 0x1e, 0x00, 0x29, 0x80, 0xd0, 0x11, 0xb9, 0x91, + 0x04, 0x3d, 0x25, 0xda, 0xd0, 0x18, 0xb9, 0x91, 0x04, 0x1d, 0x25, 0xda, + 0x99, 0x91, 0x04, 0x20, 0xb4, 0xda, 0x4c, 0xaa, 0xda, 0xb9, 0x91, 0x04, + 0x3d, 0x2c, 0xda, 0x99, 0x91, 0x04, 0x68, 0xa8, 0xa6, 0x01, 0xca, 0x10, + 0xa5, 0xa6, 0x08, 0x60, 0xb9, 0x1e, 0x00, 0x15, 0x1e, 0x29, 0x20, 0xd0, + 0x33, 0xb5, 0x1e, 0xc9, 0x06, 0x90, 0x2e, 0xb5, 0x16, 0xc9, 0x05, 0xf0, + 0x27, 0xb9, 0x1e, 0x00, 0x0a, 0x90, 0x0a, 0xa9, 0x06, 0x20, 0x11, 0xda, + 0x20, 0x95, 0xd7, 0xa4, 0x01, 0x98, 0xaa, 0x20, 0x95, 0xd7, 0xa6, 0x08, + 0xbd, 0x25, 0x01, 0x18, 0x69, 0x04, 0xa6, 0x01, 0x20, 0x11, 0xda, 0xa6, + 0x08, 0xfe, 0x25, 0x01, 0x60, 0xb9, 0x1e, 0x00, 0xc9, 0x06, 0x90, 0x1d, + 0xb9, 0x16, 0x00, 0xc9, 0x05, 0xf0, 0xf1, 0x20, 0x95, 0xd7, 0xa4, 0x01, + 0xb9, 0x25, 0x01, 0x18, 0x69, 0x04, 0xa6, 0x08, 0x20, 0x11, 0xda, 0xa6, + 0x01, 0xfe, 0x25, 0x01, 0x60, 0x98, 0xaa, 0x20, 0x1c, 0xdb, 0xa6, 0x08, + 0xb5, 0x16, 0xc9, 0x0d, 0xf0, 0x22, 0xc9, 0x11, 0xf0, 0x1e, 0xc9, 0x05, + 0xf0, 0x1a, 0xc9, 0x12, 0xf0, 0x08, 0xc9, 0x0e, 0xf0, 0x04, 0xc9, 0x07, + 0xb0, 0x0e, 0xb5, 0x58, 0x49, 0xff, 0xa8, 0xc8, 0x94, 0x58, 0xb5, 0x46, + 0x49, 0x03, 0x95, 0x46, 0x60, 0xa9, 0xff, 0x9d, 0xa2, 0x03, 0xad, 0x47, + 0x07, 0xd0, 0x29, 0xb5, 0x1e, 0x30, 0x25, 0xb5, 0x16, 0xc9, 0x24, 0xd0, + 0x06, 0xb5, 0x1e, 0xaa, 0x20, 0x5f, 0xdb, 0x20, 0x41, 0xdc, 0xb0, 0x14, + 0x8a, 0x20, 0x54, 0xdc, 0xb5, 0xcf, 0x85, 0x00, 0x8a, 0x48, 0x20, 0x25, + 0xe3, 0x68, 0xaa, 0x90, 0x03, 0x20, 0xbc, 0xdb, 0xa6, 0x08, 0x60, 0xad, + 0x47, 0x07, 0xd0, 0x37, 0x9d, 0xa2, 0x03, 0x20, 0x41, 0xdc, 0xb0, 0x2f, + 0xa9, 0x02, 0x85, 0x00, 0xa6, 0x08, 0x20, 0x52, 0xdc, 0x29, 0x02, 0xd0, + 0x22, 0xb9, 0xad, 0x04, 0xc9, 0x20, 0x90, 0x05, 0x20, 0x25, 0xe3, 0xb0, + 0x19, 0xb9, 0xad, 0x04, 0x18, 0x69, 0x80, 0x99, 0xad, 0x04, 0xb9, 0xaf, + 0x04, 0x18, 0x69, 0x80, 0x99, 0xaf, 0x04, 0xc6, 0x00, 0xd0, 0xd5, 0xa6, + 0x08, 0x60, 0xa6, 0x08, 0xb9, 0xaf, 0x04, 0x38, 0xed, 0xad, 0x04, 0xc9, + 0x04, 0xb0, 0x08, 0xa5, 0x9f, 0x10, 0x04, 0xa9, 0x01, 0x85, 0x9f, 0xad, + 0xaf, 0x04, 0x38, 0xf9, 0xad, 0x04, 0xc9, 0x06, 0xb0, 0x1b, 0xa5, 0x9f, + 0x30, 0x17, 0xa5, 0x00, 0xb4, 0x16, 0xc0, 0x2b, 0xf0, 0x05, 0xc0, 0x2c, + 0xf0, 0x01, 0x8a, 0xa6, 0x08, 0x9d, 0xa2, 0x03, 0xa9, 0x00, 0x85, 0x1d, + 0x60, 0xa9, 0x01, 0x85, 0x00, 0xad, 0xae, 0x04, 0x38, 0xf9, 0xac, 0x04, + 0xc9, 0x08, 0x90, 0x0d, 0xe6, 0x00, 0xb9, 0xae, 0x04, 0x18, 0xed, 0xac, + 0x04, 0xc9, 0x09, 0xb0, 0x03, 0x20, 0x4b, 0xdf, 0xa6, 0x08, 0x60, 0x80, + 0x00, 0xa8, 0xb5, 0xcf, 0x18, 0x79, 0x16, 0xdc, 0x2c, 0xb5, 0xcf, 0xa4, + 0x0e, 0xc0, 0x0b, 0xf0, 0x17, 0xb4, 0xb6, 0xc0, 0x01, 0xd0, 0x11, 0x38, + 0xe9, 0x20, 0x85, 0xce, 0x98, 0xe9, 0x00, 0x85, 0xb5, 0xa9, 0x00, 0x85, + 0x9f, 0x8d, 0x33, 0x04, 0x60, 0xad, 0xd0, 0x03, 0xc9, 0xf0, 0xb0, 0x09, + 0xa4, 0xb5, 0x88, 0xd0, 0x04, 0xa5, 0xce, 0xc9, 0xd0, 0x60, 0xa5, 0x08, + 0x0a, 0x0a, 0x18, 0x69, 0x04, 0xa8, 0xad, 0xd1, 0x03, 0x29, 0x0f, 0xc9, + 0x0f, 0x60, 0x20, 0x10, 0xad, 0x16, 0x07, 0xd0, 0x2e, 0xa5, 0x0e, 0xc9, + 0x0b, 0xf0, 0x28, 0xc9, 0x04, 0x90, 0x24, 0xa9, 0x01, 0xac, 0x04, 0x07, + 0xd0, 0x0a, 0xa5, 0x1d, 0xf0, 0x04, 0xc9, 0x03, 0xd0, 0x04, 0xa9, 0x02, + 0x85, 0x1d, 0xa5, 0xb5, 0xc9, 0x01, 0xd0, 0x0b, 0xa9, 0xff, 0x8d, 0x90, + 0x04, 0xa5, 0xce, 0xc9, 0xcf, 0x90, 0x01, 0x60, 0xa0, 0x02, 0xad, 0x14, + 0x07, 0xd0, 0x0c, 0xad, 0x54, 0x07, 0xd0, 0x07, 0x88, 0xad, 0x04, 0x07, + 0xd0, 0x01, 0x88, 0xb9, 0xad, 0xe3, 0x85, 0xeb, 0xa8, 0xae, 0x54, 0x07, + 0xad, 0x14, 0x07, 0xf0, 0x01, 0xe8, 0xa5, 0xce, 0xdd, 0x62, 0xdc, 0x90, + 0x35, 0x20, 0xe9, 0xe3, 0xf0, 0x30, 0x20, 0xa1, 0xdf, 0xb0, 0x4f, 0xa4, + 0x9f, 0x10, 0x27, 0xa4, 0x04, 0xc0, 0x04, 0x90, 0x21, 0x20, 0x8f, 0xdf, + 0xb0, 0x10, 0xac, 0x4e, 0x07, 0xf0, 0x13, 0xac, 0x84, 0x07, 0xd0, 0x0e, + 0x20, 0xed, 0xbc, 0x4c, 0xf6, 0xdc, 0xc9, 0x26, 0xf0, 0x04, 0xa9, 0x02, + 0x85, 0xff, 0xa9, 0x01, 0x85, 0x9f, 0xa4, 0xeb, 0xa5, 0xce, 0xc9, 0xcf, + 0xb0, 0x60, 0x20, 0xe8, 0xe3, 0x20, 0xa1, 0xdf, 0xb0, 0x14, 0x48, 0x20, + 0xe8, 0xe3, 0x85, 0x00, 0x68, 0x85, 0x01, 0xd0, 0x0c, 0xa5, 0x00, 0xf0, + 0x49, 0x20, 0xa1, 0xdf, 0x90, 0x03, 0x4c, 0x05, 0xde, 0x20, 0x9a, 0xdf, + 0xb0, 0x3c, 0xa4, 0x9f, 0x30, 0x38, 0xc9, 0xc5, 0xd0, 0x03, 0x4c, 0x0e, + 0xde, 0x20, 0xbd, 0xde, 0xf0, 0x2c, 0xac, 0x0e, 0x07, 0xd0, 0x23, 0xa4, + 0x04, 0xc0, 0x05, 0x90, 0x07, 0xa5, 0x45, 0x85, 0x00, 0x4c, 0x4b, 0xdf, + 0x20, 0xc4, 0xde, 0xa9, 0xf0, 0x25, 0xce, 0x85, 0xce, 0x20, 0xe8, 0xde, + 0xa9, 0x00, 0x85, 0x9f, 0x8d, 0x33, 0x04, 0x8d, 0x84, 0x04, 0xa9, 0x00, + 0x85, 0x1d, 0xa4, 0xeb, 0xc8, 0xc8, 0xa9, 0x02, 0x85, 0x00, 0xc8, 0x84, + 0xeb, 0xa5, 0xce, 0xc9, 0x20, 0x90, 0x16, 0xc9, 0xe4, 0xb0, 0x28, 0x20, + 0xec, 0xe3, 0xf0, 0x0d, 0xc9, 0x1c, 0xf0, 0x09, 0xc9, 0x6b, 0xf0, 0x05, + 0x20, 0x9a, 0xdf, 0x90, 0x17, 0xa4, 0xeb, 0xc8, 0xa5, 0xce, 0xc9, 0x08, + 0x90, 0x0d, 0xc9, 0xd0, 0xb0, 0x09, 0x20, 0xec, 0xe3, 0xd0, 0x05, 0xc6, + 0x00, 0xd0, 0xcb, 0x60, 0x20, 0xbd, 0xde, 0xf0, 0x61, 0x20, 0x9a, 0xdf, + 0x90, 0x03, 0x4c, 0x2e, 0xde, 0x20, 0xa1, 0xdf, 0xb0, 0x57, 0x20, 0xdd, + 0xde, 0x90, 0x08, 0xad, 0x0e, 0x07, 0xd0, 0x4a, 0x4c, 0xff, 0xdd, 0xa4, + 0x1d, 0xc0, 0x00, 0xd0, 0x3e, 0xa4, 0x33, 0x88, 0xd0, 0x39, 0xc9, 0x6c, + 0xf0, 0x04, 0xc9, 0x1f, 0xd0, 0x31, 0xad, 0xc4, 0x03, 0xd0, 0x04, 0xa0, + 0x10, 0x84, 0xff, 0x09, 0x20, 0x8d, 0xc4, 0x03, 0xa5, 0x86, 0x29, 0x0f, + 0xf0, 0x0e, 0xa0, 0x00, 0xad, 0x1a, 0x07, 0xf0, 0x01, 0xc8, 0xb9, 0x03, + 0xde, 0x8d, 0xde, 0x06, 0xa5, 0x0e, 0xc9, 0x07, 0xf0, 0x0c, 0xc9, 0x08, + 0xd0, 0x08, 0xa9, 0x02, 0x85, 0x0e, 0x60, 0x20, 0x4b, 0xdf, 0x60, 0xa0, + 0x34, 0x20, 0x1c, 0xde, 0xee, 0x48, 0x07, 0x4c, 0xfe, 0xbb, 0xa9, 0x00, + 0x8d, 0x72, 0x07, 0xa9, 0x02, 0x8d, 0x70, 0x07, 0xa9, 0x18, 0x85, 0x57, + 0xa4, 0x02, 0xa9, 0x00, 0x91, 0x06, 0x4c, 0x4d, 0x8a, 0xf9, 0x07, 0xff, + 0x00, 0x18, 0x22, 0x50, 0x68, 0x90, 0xa4, 0x04, 0xc0, 0x06, 0x90, 0x04, + 0xc0, 0x0a, 0x90, 0x01, 0x60, 0xc9, 0x24, 0xf0, 0x04, 0xc9, 0x25, 0xd0, + 0x39, 0xa5, 0x0e, 0xc9, 0x05, 0xf0, 0x41, 0xa9, 0x01, 0x85, 0x33, 0xee, + 0x23, 0x07, 0xa5, 0x0e, 0xc9, 0x04, 0xf0, 0x1f, 0xa9, 0x33, 0x20, 0x16, + 0x97, 0xa9, 0x80, 0x85, 0xfc, 0x4a, 0x8d, 0x13, 0x07, 0xa2, 0x04, 0xa5, + 0xce, 0x8d, 0x0f, 0x07, 0xdd, 0x29, 0xde, 0xb0, 0x03, 0xca, 0xd0, 0xf8, + 0x8e, 0x0f, 0x01, 0xa9, 0x04, 0x85, 0x0e, 0x4c, 0x88, 0xde, 0xc9, 0x26, + 0xd0, 0x0a, 0xa5, 0xce, 0xc9, 0x20, 0xb0, 0x04, 0xa9, 0x01, 0x85, 0x0e, + 0xa9, 0x03, 0x85, 0x1d, 0xa9, 0x00, 0x85, 0x57, 0x8d, 0x05, 0x07, 0xa5, + 0x86, 0x38, 0xed, 0x1c, 0x07, 0xc9, 0x10, 0xb0, 0x04, 0xa9, 0x02, 0x85, + 0x33, 0xa4, 0x33, 0xa5, 0x06, 0x0a, 0x0a, 0x0a, 0x0a, 0x18, 0x79, 0x24, + 0xde, 0x85, 0x86, 0xa5, 0x06, 0xd0, 0x09, 0xad, 0x1b, 0x07, 0x18, 0x79, + 0x26, 0xde, 0x85, 0x6d, 0x60, 0xc9, 0x5f, 0xf0, 0x02, 0xc9, 0x60, 0x60, + 0x20, 0xdd, 0xde, 0x90, 0x13, 0xa9, 0x70, 0x8d, 0x09, 0x07, 0xa9, 0xf9, + 0x8d, 0xdb, 0x06, 0xa9, 0x03, 0x8d, 0x86, 0x07, 0x4a, 0x8d, 0x0e, 0x07, + 0x60, 0xc9, 0x67, 0xf0, 0x05, 0xc9, 0x68, 0x18, 0xd0, 0x01, 0x38, 0x60, + 0xa5, 0x0b, 0x29, 0x04, 0xf0, 0x5c, 0xa5, 0x00, 0xc9, 0x11, 0xd0, 0x56, + 0xa5, 0x01, 0xc9, 0x10, 0xd0, 0x50, 0xa9, 0x30, 0x8d, 0xde, 0x06, 0xa9, + 0x03, 0x85, 0x0e, 0xa9, 0x10, 0x85, 0xff, 0xa9, 0x20, 0x8d, 0xc4, 0x03, + 0xad, 0xd6, 0x06, 0xf0, 0x39, 0x29, 0x03, 0x0a, 0x0a, 0xaa, 0xa5, 0x86, + 0xc9, 0x60, 0x90, 0x06, 0xe8, 0xc9, 0xa0, 0x90, 0x01, 0xe8, 0xbc, 0xf2, + 0x87, 0x88, 0x8c, 0x5f, 0x07, 0xbe, 0xb4, 0x9c, 0xbd, 0xbc, 0x9c, 0x8d, + 0x50, 0x07, 0xa9, 0x80, 0x85, 0xfc, 0xa9, 0x00, 0x8d, 0x51, 0x07, 0x8d, + 0x60, 0x07, 0x8d, 0x5c, 0x07, 0x8d, 0x52, 0x07, 0xee, 0x5d, 0x07, 0xee, + 0x57, 0x07, 0x60, 0xa9, 0x00, 0xa4, 0x57, 0xa6, 0x00, 0xca, 0xd0, 0x0a, + 0xe8, 0xc0, 0x00, 0x30, 0x28, 0xa9, 0xff, 0x4c, 0x66, 0xdf, 0xa2, 0x02, + 0xc0, 0x01, 0x10, 0x1d, 0xa9, 0x01, 0xa0, 0x10, 0x8c, 0x85, 0x07, 0xa0, + 0x00, 0x84, 0x57, 0xc9, 0x00, 0x10, 0x01, 0x88, 0x84, 0x00, 0x18, 0x65, + 0x86, 0x85, 0x86, 0xa5, 0x6d, 0x65, 0x00, 0x85, 0x6d, 0x8a, 0x49, 0xff, + 0x2d, 0x90, 0x04, 0x8d, 0x90, 0x04, 0x60, 0x10, 0x61, 0x88, 0xc4, 0x20, + 0xb0, 0xdf, 0xdd, 0x8b, 0xdf, 0x60, 0x24, 0x6d, 0x8a, 0xc6, 0x20, 0xb0, + 0xdf, 0xdd, 0x96, 0xdf, 0x60, 0xc9, 0xc2, 0xf0, 0x06, 0xc9, 0xc3, 0xf0, + 0x02, 0x18, 0x60, 0xa9, 0x01, 0x85, 0xfe, 0x60, 0xa8, 0x29, 0xc0, 0x0a, + 0x2a, 0x2a, 0xaa, 0x98, 0x60, 0x01, 0x01, 0x02, 0x02, 0x02, 0x05, 0x10, + 0xf0, 0xb5, 0x1e, 0x29, 0x20, 0xd0, 0xf1, 0x20, 0x5b, 0xe1, 0x90, 0xec, + 0xb4, 0x16, 0xc0, 0x12, 0xd0, 0x06, 0xb5, 0xcf, 0xc9, 0x25, 0x90, 0xe0, + 0xc0, 0x0e, 0xd0, 0x03, 0x4c, 0x63, 0xe1, 0xc0, 0x05, 0xd0, 0x03, 0x4c, + 0x85, 0xe1, 0xc0, 0x12, 0xf0, 0x08, 0xc0, 0x2e, 0xf0, 0x04, 0xc0, 0x07, + 0xb0, 0x74, 0x20, 0xae, 0xe1, 0xd0, 0x03, 0x4c, 0xe2, 0xe0, 0x20, 0xb5, + 0xe1, 0xf0, 0xf8, 0xc9, 0x23, 0xd0, 0x64, 0xa4, 0x02, 0xa9, 0x00, 0x91, + 0x06, 0xb5, 0x16, 0xc9, 0x15, 0xb0, 0x0c, 0xc9, 0x06, 0xd0, 0x03, 0x20, + 0x8e, 0xe1, 0xa9, 0x01, 0x20, 0x11, 0xda, 0xc9, 0x09, 0x90, 0x10, 0xc9, + 0x11, 0xb0, 0x0c, 0xc9, 0x0a, 0x90, 0x04, 0xc9, 0x0d, 0x90, 0x04, 0x29, + 0x01, 0x95, 0x16, 0xb5, 0x1e, 0x29, 0xf0, 0x09, 0x02, 0x95, 0x1e, 0xd6, + 0xcf, 0xd6, 0xcf, 0xb5, 0x16, 0xc9, 0x07, 0xf0, 0x07, 0xa9, 0xfd, 0xac, + 0x4e, 0x07, 0xd0, 0x02, 0xa9, 0xff, 0x95, 0xa0, 0xa0, 0x01, 0x20, 0x43, + 0xe1, 0x10, 0x01, 0xc8, 0xb5, 0x16, 0xc9, 0x33, 0xf0, 0x06, 0xc9, 0x08, + 0xf0, 0x02, 0x94, 0x46, 0x88, 0xb9, 0xbf, 0xdf, 0x95, 0x58, 0x60, 0xa5, + 0x04, 0x38, 0xe9, 0x08, 0xc9, 0x05, 0xb0, 0x72, 0xb5, 0x1e, 0x29, 0x40, + 0xd0, 0x57, 0xb5, 0x1e, 0x0a, 0x90, 0x03, 0x4c, 0xfe, 0xe0, 0xb5, 0x1e, + 0xf0, 0xf9, 0xc9, 0x05, 0xf0, 0x1f, 0xc9, 0x03, 0xb0, 0x1a, 0xb5, 0x1e, + 0xc9, 0x02, 0xd0, 0x15, 0xa9, 0x10, 0xb4, 0x16, 0xc0, 0x12, 0xd0, 0x02, + 0xa9, 0x00, 0x9d, 0x96, 0x07, 0xa9, 0x03, 0x95, 0x1e, 0x20, 0x4f, 0xe1, + 0x60, 0xb5, 0x16, 0xc9, 0x06, 0xf0, 0x22, 0xc9, 0x12, 0xd0, 0x0e, 0xa9, + 0x01, 0x95, 0x46, 0xa9, 0x08, 0x95, 0x58, 0xa5, 0x09, 0x29, 0x07, 0xf0, + 0x10, 0xa0, 0x01, 0x20, 0x43, 0xe1, 0x10, 0x01, 0xc8, 0x98, 0xd5, 0x46, + 0xd0, 0x03, 0x20, 0x24, 0xe1, 0x20, 0x4f, 0xe1, 0xb5, 0x1e, 0x29, 0x80, + 0xd0, 0x05, 0xa9, 0x00, 0x95, 0x1e, 0x60, 0xb5, 0x1e, 0x29, 0xbf, 0x95, + 0x1e, 0x60, 0xb5, 0x16, 0xc9, 0x03, 0xd0, 0x04, 0xb5, 0x1e, 0xf0, 0x38, + 0xb5, 0x1e, 0xa8, 0x0a, 0x90, 0x07, 0xb5, 0x1e, 0x09, 0x40, 0x4c, 0xfc, + 0xe0, 0xb9, 0xb9, 0xdf, 0x95, 0x1e, 0xb5, 0xcf, 0xc9, 0x20, 0x90, 0x1f, + 0xa0, 0x16, 0xa9, 0x02, 0x85, 0xeb, 0xa5, 0xeb, 0xd5, 0x46, 0xd0, 0x0c, + 0xa9, 0x01, 0x20, 0x88, 0xe3, 0xf0, 0x05, 0x20, 0xb5, 0xe1, 0xd0, 0x08, + 0xc6, 0xeb, 0xc8, 0xc0, 0x18, 0x90, 0xe7, 0x60, 0xe0, 0x05, 0xf0, 0x09, + 0xb5, 0x1e, 0x0a, 0x90, 0x04, 0xa9, 0x02, 0x85, 0xff, 0xb5, 0x16, 0xc9, + 0x05, 0xd0, 0x09, 0xa9, 0x00, 0x85, 0x00, 0xa0, 0xfa, 0x4c, 0x37, 0xca, + 0x4c, 0x36, 0xdb, 0xb5, 0x87, 0x38, 0xe5, 0x86, 0x85, 0x00, 0xb5, 0x6e, + 0xe5, 0x6d, 0x60, 0x20, 0x63, 0xc3, 0xb5, 0xcf, 0x29, 0xf0, 0x09, 0x08, + 0x95, 0xcf, 0x60, 0xb5, 0xcf, 0x18, 0x69, 0x3e, 0xc9, 0x44, 0x60, 0x20, + 0x5b, 0xe1, 0x90, 0x1a, 0xb5, 0xa0, 0x18, 0x69, 0x02, 0xc9, 0x03, 0x90, + 0x11, 0x20, 0xae, 0xe1, 0xf0, 0x0c, 0x20, 0xb5, 0xe1, 0xf0, 0x07, 0x20, + 0x4f, 0xe1, 0xa9, 0xfd, 0x95, 0xa0, 0x4c, 0xfe, 0xe0, 0x20, 0xae, 0xe1, + 0xf0, 0x1d, 0xc9, 0x23, 0xd0, 0x08, 0x20, 0x95, 0xd7, 0xa9, 0xfc, 0x95, + 0xa0, 0x60, 0xbd, 0x8a, 0x07, 0xd0, 0x0c, 0xb5, 0x1e, 0x29, 0x88, 0x95, + 0x1e, 0x20, 0x4f, 0xe1, 0x4c, 0xfe, 0xe0, 0xb5, 0x1e, 0x09, 0x01, 0x95, + 0x1e, 0x60, 0xa9, 0x00, 0xa0, 0x15, 0x4c, 0x88, 0xe3, 0xc9, 0x26, 0xf0, + 0x0e, 0xc9, 0xc2, 0xf0, 0x0a, 0xc9, 0xc3, 0xf0, 0x06, 0xc9, 0x5f, 0xf0, + 0x02, 0xc9, 0x60, 0x60, 0xb5, 0xd5, 0xc9, 0x18, 0x90, 0x21, 0x20, 0x9c, + 0xe3, 0xf0, 0x1c, 0x20, 0xb5, 0xe1, 0xf0, 0x17, 0xb5, 0xa6, 0x30, 0x18, + 0xb5, 0x3a, 0xd0, 0x14, 0xa9, 0xfd, 0x95, 0xa6, 0xa9, 0x01, 0x95, 0x3a, + 0xb5, 0xd5, 0x29, 0xf8, 0x95, 0xd5, 0x60, 0xa9, 0x00, 0x95, 0x3a, 0x60, + 0xa9, 0x80, 0x95, 0x24, 0xa9, 0x02, 0x85, 0xff, 0x60, 0x02, 0x08, 0x0e, + 0x20, 0x03, 0x14, 0x0d, 0x20, 0x02, 0x14, 0x0e, 0x20, 0x02, 0x09, 0x0e, + 0x15, 0x00, 0x00, 0x18, 0x06, 0x00, 0x00, 0x20, 0x0d, 0x00, 0x00, 0x30, + 0x0d, 0x00, 0x00, 0x08, 0x08, 0x06, 0x04, 0x0a, 0x08, 0x03, 0x0e, 0x0d, + 0x14, 0x00, 0x02, 0x10, 0x15, 0x04, 0x04, 0x0c, 0x1c, 0x8a, 0x18, 0x69, + 0x07, 0xaa, 0xa0, 0x02, 0xd0, 0x07, 0x8a, 0x18, 0x69, 0x09, 0xaa, 0xa0, + 0x06, 0x20, 0x9c, 0xe2, 0x4c, 0xde, 0xe2, 0xa0, 0x48, 0x84, 0x00, 0xa0, + 0x44, 0x4c, 0x52, 0xe2, 0xa0, 0x08, 0x84, 0x00, 0xa0, 0x04, 0xb5, 0x87, + 0x38, 0xed, 0x1c, 0x07, 0x85, 0x01, 0xb5, 0x6e, 0xed, 0x1a, 0x07, 0x30, + 0x06, 0x05, 0x01, 0xf0, 0x02, 0xa4, 0x00, 0x98, 0x2d, 0xd1, 0x03, 0x9d, + 0xd8, 0x03, 0xd0, 0x19, 0x4c, 0x7c, 0xe2, 0xe8, 0x20, 0xf6, 0xf1, 0xca, + 0xc9, 0xfe, 0xb0, 0x0d, 0x8a, 0x18, 0x69, 0x01, 0xaa, 0xa0, 0x01, 0x20, + 0x9c, 0xe2, 0x4c, 0xde, 0xe2, 0x8a, 0x0a, 0x0a, 0xa8, 0xa9, 0xff, 0x99, + 0xb0, 0x04, 0x99, 0xb1, 0x04, 0x99, 0xb2, 0x04, 0x99, 0xb3, 0x04, 0x60, + 0x86, 0x00, 0xb9, 0xb8, 0x03, 0x85, 0x02, 0xb9, 0xad, 0x03, 0x85, 0x01, + 0x8a, 0x0a, 0x0a, 0x48, 0xa8, 0xbd, 0x99, 0x04, 0x0a, 0x0a, 0xaa, 0xa5, + 0x01, 0x18, 0x7d, 0xfd, 0xe1, 0x99, 0xac, 0x04, 0xa5, 0x01, 0x18, 0x7d, + 0xff, 0xe1, 0x99, 0xae, 0x04, 0xe8, 0xc8, 0xa5, 0x02, 0x18, 0x7d, 0xfd, + 0xe1, 0x99, 0xac, 0x04, 0xa5, 0x02, 0x18, 0x7d, 0xff, 0xe1, 0x99, 0xae, + 0x04, 0x68, 0xa8, 0xa6, 0x00, 0x60, 0xad, 0x1c, 0x07, 0x18, 0x69, 0x80, + 0x85, 0x02, 0xad, 0x1a, 0x07, 0x69, 0x00, 0x85, 0x01, 0xb5, 0x86, 0xc5, + 0x02, 0xb5, 0x6d, 0xe5, 0x01, 0x90, 0x15, 0xb9, 0xae, 0x04, 0x30, 0x0d, + 0xa9, 0xff, 0xbe, 0xac, 0x04, 0x30, 0x03, 0x99, 0xac, 0x04, 0x99, 0xae, + 0x04, 0xa6, 0x08, 0x60, 0xb9, 0xac, 0x04, 0x10, 0x11, 0xc9, 0xa0, 0x90, + 0x0d, 0xa9, 0x00, 0xbe, 0xae, 0x04, 0x10, 0x03, 0x99, 0xae, 0x04, 0x99, + 0xac, 0x04, 0xa6, 0x08, 0x60, 0xa2, 0x00, 0x84, 0x06, 0xa9, 0x01, 0x85, + 0x07, 0xb9, 0xac, 0x04, 0xdd, 0xac, 0x04, 0xb0, 0x2a, 0xdd, 0xae, 0x04, + 0x90, 0x12, 0xf0, 0x42, 0xb9, 0xae, 0x04, 0xd9, 0xac, 0x04, 0x90, 0x3a, + 0xdd, 0xac, 0x04, 0xb0, 0x35, 0xa4, 0x06, 0x60, 0xbd, 0xae, 0x04, 0xdd, + 0xac, 0x04, 0x90, 0x2a, 0xb9, 0xae, 0x04, 0xdd, 0xac, 0x04, 0xb0, 0x22, + 0xa4, 0x06, 0x60, 0xdd, 0xac, 0x04, 0xf0, 0x1a, 0xdd, 0xae, 0x04, 0x90, + 0x15, 0xf0, 0x13, 0xd9, 0xae, 0x04, 0x90, 0x0a, 0xf0, 0x08, 0xb9, 0xae, + 0x04, 0xdd, 0xac, 0x04, 0xb0, 0x04, 0x18, 0xa4, 0x06, 0x60, 0xe8, 0xc8, + 0xc6, 0x07, 0x10, 0xa9, 0x38, 0xa4, 0x06, 0x60, 0x48, 0x8a, 0x18, 0x69, + 0x01, 0xaa, 0x68, 0x4c, 0xa5, 0xe3, 0x8a, 0x18, 0x69, 0x0d, 0xaa, 0xa0, + 0x1b, 0x4c, 0xa3, 0xe3, 0xa0, 0x1a, 0x8a, 0x18, 0x69, 0x07, 0xaa, 0xa9, + 0x00, 0x20, 0xf0, 0xe3, 0xa6, 0x08, 0xc9, 0x00, 0x60, 0x00, 0x07, 0x0e, + 0x08, 0x03, 0x0c, 0x02, 0x02, 0x0d, 0x0d, 0x08, 0x03, 0x0c, 0x02, 0x02, + 0x0d, 0x0d, 0x08, 0x03, 0x0c, 0x02, 0x02, 0x0d, 0x0d, 0x08, 0x00, 0x10, + 0x04, 0x14, 0x04, 0x04, 0x04, 0x20, 0x20, 0x08, 0x18, 0x08, 0x18, 0x02, + 0x20, 0x20, 0x08, 0x18, 0x08, 0x18, 0x12, 0x20, 0x20, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x14, 0x14, 0x06, 0x06, 0x08, 0x10, 0xc8, 0xa9, 0x00, 0x2c, + 0xa9, 0x01, 0xa2, 0x00, 0x48, 0x84, 0x04, 0xb9, 0xb0, 0xe3, 0x18, 0x75, + 0x86, 0x85, 0x05, 0xb5, 0x6d, 0x69, 0x00, 0x29, 0x01, 0x4a, 0x05, 0x05, + 0x6a, 0x4a, 0x4a, 0x4a, 0x20, 0xe1, 0x9b, 0xa4, 0x04, 0xb5, 0xce, 0x18, + 0x79, 0xcc, 0xe3, 0x29, 0xf0, 0x38, 0xe9, 0x20, 0x85, 0x02, 0xa8, 0xb1, + 0x06, 0x85, 0x03, 0xa4, 0x04, 0x68, 0xd0, 0x05, 0xb5, 0xce, 0x4c, 0x2b, + 0xe4, 0xb5, 0x86, 0x29, 0x0f, 0x85, 0x04, 0xa5, 0x03, 0x60, 0xff, 0x00, + 0x30, 0x84, 0x00, 0xad, 0xb9, 0x03, 0x18, 0x79, 0x33, 0xe4, 0xbe, 0x9a, + 0x03, 0xbc, 0xe5, 0x06, 0x84, 0x02, 0x20, 0xae, 0xe4, 0xad, 0xae, 0x03, + 0x99, 0x03, 0x02, 0x99, 0x0b, 0x02, 0x99, 0x13, 0x02, 0x18, 0x69, 0x06, + 0x99, 0x07, 0x02, 0x99, 0x0f, 0x02, 0x99, 0x17, 0x02, 0xa9, 0x21, 0x99, + 0x02, 0x02, 0x99, 0x0a, 0x02, 0x99, 0x12, 0x02, 0x09, 0x40, 0x99, 0x06, + 0x02, 0x99, 0x0e, 0x02, 0x99, 0x16, 0x02, 0xa2, 0x05, 0xa9, 0xe1, 0x99, + 0x01, 0x02, 0xc8, 0xc8, 0xc8, 0xc8, 0xca, 0x10, 0xf4, 0xa4, 0x02, 0xa5, + 0x00, 0xd0, 0x05, 0xa9, 0xe0, 0x99, 0x01, 0x02, 0xa2, 0x00, 0xad, 0x9d, + 0x03, 0x38, 0xf9, 0x00, 0x02, 0xc9, 0x64, 0x90, 0x05, 0xa9, 0xf8, 0x99, + 0x00, 0x02, 0xc8, 0xc8, 0xc8, 0xc8, 0xe8, 0xe0, 0x06, 0xd0, 0xe7, 0xa4, + 0x00, 0x60, 0xa2, 0x06, 0x99, 0x00, 0x02, 0x18, 0x69, 0x08, 0xc8, 0xc8, + 0xc8, 0xc8, 0xca, 0xd0, 0xf3, 0xa4, 0x02, 0x60, 0x04, 0x00, 0x04, 0x00, + 0x00, 0x04, 0x00, 0x04, 0x00, 0x08, 0x00, 0x08, 0x08, 0x00, 0x08, 0x00, + 0x80, 0x82, 0x81, 0x83, 0x81, 0x83, 0x80, 0x82, 0x03, 0x03, 0xc3, 0xc3, + 0xbc, 0xf3, 0x06, 0xad, 0x47, 0x07, 0xd0, 0x08, 0xb5, 0x2a, 0x29, 0x7f, + 0xc9, 0x01, 0xf0, 0x04, 0xa2, 0x00, 0xf0, 0x07, 0xa5, 0x09, 0x4a, 0x4a, + 0x29, 0x03, 0xaa, 0xad, 0xbe, 0x03, 0x18, 0x7d, 0xc4, 0xe4, 0x99, 0x00, + 0x02, 0x18, 0x7d, 0xcc, 0xe4, 0x99, 0x04, 0x02, 0xad, 0xb3, 0x03, 0x18, + 0x7d, 0xc0, 0xe4, 0x99, 0x03, 0x02, 0x18, 0x7d, 0xc8, 0xe4, 0x99, 0x07, + 0x02, 0xbd, 0xd0, 0xe4, 0x99, 0x01, 0x02, 0xbd, 0xd4, 0xe4, 0x99, 0x05, + 0x02, 0xbd, 0xd8, 0xe4, 0x99, 0x02, 0x02, 0x99, 0x06, 0x02, 0xa6, 0x08, + 0xad, 0xd6, 0x03, 0x29, 0xfc, 0xf0, 0x09, 0xa9, 0x00, 0x95, 0x2a, 0xa9, + 0xf8, 0x20, 0xc1, 0xe5, 0x60, 0xf9, 0x50, 0xf7, 0x50, 0xfa, 0xfb, 0xf8, + 0xfb, 0xf6, 0xfb, 0xbc, 0xe5, 0x06, 0xad, 0xae, 0x03, 0x99, 0x03, 0x02, + 0x18, 0x69, 0x08, 0x99, 0x07, 0x02, 0x99, 0x0b, 0x02, 0x18, 0x69, 0x0c, + 0x85, 0x05, 0xb5, 0xcf, 0x20, 0xc1, 0xe5, 0x69, 0x08, 0x99, 0x08, 0x02, + 0xad, 0x0d, 0x01, 0x85, 0x02, 0xa9, 0x01, 0x85, 0x03, 0x85, 0x04, 0x99, + 0x02, 0x02, 0x99, 0x06, 0x02, 0x99, 0x0a, 0x02, 0xa9, 0x7e, 0x99, 0x01, + 0x02, 0x99, 0x09, 0x02, 0xa9, 0x7f, 0x99, 0x05, 0x02, 0xad, 0x0f, 0x07, + 0xf0, 0x15, 0x98, 0x18, 0x69, 0x0c, 0xa8, 0xad, 0x0f, 0x01, 0x0a, 0xaa, + 0xbd, 0x41, 0xe5, 0x85, 0x00, 0xbd, 0x42, 0xe5, 0x20, 0xb2, 0xeb, 0xa6, + 0x08, 0xbc, 0xe5, 0x06, 0xad, 0xd1, 0x03, 0x29, 0x0e, 0xf0, 0x14, 0xa9, + 0xf8, 0x99, 0x14, 0x02, 0x99, 0x10, 0x02, 0x99, 0x0c, 0x02, 0x99, 0x08, + 0x02, 0x99, 0x04, 0x02, 0x99, 0x00, 0x02, 0x60, 0xbc, 0xe5, 0x06, 0x84, + 0x02, 0xc8, 0xc8, 0xc8, 0xad, 0xae, 0x03, 0x20, 0xae, 0xe4, 0xa6, 0x08, + 0xb5, 0xcf, 0x20, 0xbb, 0xe5, 0xac, 0x4e, 0x07, 0xc0, 0x03, 0xf0, 0x05, + 0xac, 0xcc, 0x06, 0xf0, 0x02, 0xa9, 0xf8, 0xbc, 0xe5, 0x06, 0x99, 0x10, + 0x02, 0x99, 0x14, 0x02, 0xa9, 0x5b, 0xae, 0x43, 0x07, 0xf0, 0x02, 0xa9, + 0x75, 0xa6, 0x08, 0xc8, 0x20, 0xb5, 0xe5, 0xa9, 0x02, 0xc8, 0x20, 0xb5, + 0xe5, 0xe8, 0x20, 0xf6, 0xf1, 0xca, 0xbc, 0xe5, 0x06, 0x0a, 0x48, 0x90, + 0x05, 0xa9, 0xf8, 0x99, 0x00, 0x02, 0x68, 0x0a, 0x48, 0x90, 0x05, 0xa9, + 0xf8, 0x99, 0x04, 0x02, 0x68, 0x0a, 0x48, 0x90, 0x05, 0xa9, 0xf8, 0x99, + 0x08, 0x02, 0x68, 0x0a, 0x48, 0x90, 0x05, 0xa9, 0xf8, 0x99, 0x0c, 0x02, + 0x68, 0x0a, 0x48, 0x90, 0x05, 0xa9, 0xf8, 0x99, 0x10, 0x02, 0x68, 0x0a, + 0x90, 0x05, 0xa9, 0xf8, 0x99, 0x14, 0x02, 0xad, 0xd1, 0x03, 0x0a, 0x90, + 0x03, 0x20, 0xb3, 0xe5, 0x60, 0xa5, 0x09, 0x4a, 0xb0, 0x02, 0xd6, 0xdb, + 0xb5, 0xdb, 0x20, 0xc1, 0xe5, 0xad, 0xb3, 0x03, 0x99, 0x03, 0x02, 0x18, + 0x69, 0x08, 0x99, 0x07, 0x02, 0xa9, 0x02, 0x99, 0x02, 0x02, 0x99, 0x06, + 0x02, 0xa9, 0xf7, 0x99, 0x01, 0x02, 0xa9, 0xfb, 0x99, 0x05, 0x02, 0x4c, + 0xbd, 0xe6, 0x60, 0x61, 0x62, 0x63, 0xbc, 0xf3, 0x06, 0xb5, 0x2a, 0xc9, + 0x02, 0xb0, 0xc6, 0xb5, 0xdb, 0x99, 0x00, 0x02, 0x18, 0x69, 0x08, 0x99, + 0x04, 0x02, 0xad, 0xb3, 0x03, 0x99, 0x03, 0x02, 0x99, 0x07, 0x02, 0xa5, + 0x09, 0x4a, 0x29, 0x03, 0xaa, 0xbd, 0x82, 0xe6, 0xc8, 0x20, 0xc1, 0xe5, + 0x88, 0xa9, 0x02, 0x99, 0x02, 0x02, 0xa9, 0x82, 0x99, 0x06, 0x02, 0xa6, + 0x08, 0x60, 0x76, 0x77, 0x78, 0x79, 0xd6, 0xd6, 0xd9, 0xd9, 0x8d, 0x8d, + 0xe4, 0xe4, 0x76, 0x77, 0x78, 0x79, 0x02, 0x01, 0x02, 0x01, 0xac, 0xea, + 0x06, 0xad, 0xb9, 0x03, 0x18, 0x69, 0x08, 0x85, 0x02, 0xad, 0xae, 0x03, + 0x85, 0x05, 0xa6, 0x39, 0xbd, 0xce, 0xe6, 0x0d, 0xca, 0x03, 0x85, 0x04, + 0x8a, 0x48, 0x0a, 0x0a, 0xaa, 0xa9, 0x01, 0x85, 0x07, 0x85, 0x03, 0xbd, + 0xbe, 0xe6, 0x85, 0x00, 0xbd, 0xbf, 0xe6, 0x20, 0xb2, 0xeb, 0xc6, 0x07, + 0x10, 0xf1, 0xac, 0xea, 0x06, 0x68, 0xf0, 0x2f, 0xc9, 0x03, 0xf0, 0x2b, + 0x85, 0x00, 0xa5, 0x09, 0x4a, 0x29, 0x03, 0x0d, 0xca, 0x03, 0x99, 0x02, + 0x02, 0x99, 0x06, 0x02, 0xa6, 0x00, 0xca, 0xf0, 0x06, 0x99, 0x0a, 0x02, + 0x99, 0x0e, 0x02, 0xb9, 0x06, 0x02, 0x09, 0x40, 0x99, 0x06, 0x02, 0xb9, + 0x0e, 0x02, 0x09, 0x40, 0x99, 0x0e, 0x02, 0x4c, 0x64, 0xeb, 0xfc, 0xfc, + 0xaa, 0xab, 0xac, 0xad, 0xfc, 0xfc, 0xae, 0xaf, 0xb0, 0xb1, 0xfc, 0xa5, + 0xa6, 0xa7, 0xa8, 0xa9, 0xfc, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0x69, 0xa5, + 0x6a, 0xa7, 0xa8, 0xa9, 0x6b, 0xa0, 0x6c, 0xa2, 0xa3, 0xa4, 0xfc, 0xfc, + 0x96, 0x97, 0x98, 0x99, 0xfc, 0xfc, 0x9a, 0x9b, 0x9c, 0x9d, 0xfc, 0xfc, + 0x8f, 0x8e, 0x8e, 0x8f, 0xfc, 0xfc, 0x95, 0x94, 0x94, 0x95, 0xfc, 0xfc, + 0xdc, 0xdc, 0xdf, 0xdf, 0xdc, 0xdc, 0xdd, 0xdd, 0xde, 0xde, 0xfc, 0xfc, + 0xb2, 0xb3, 0xb4, 0xb5, 0xfc, 0xfc, 0xb6, 0xb3, 0xb7, 0xb5, 0xfc, 0xfc, + 0x70, 0x71, 0x72, 0x73, 0xfc, 0xfc, 0x6e, 0x6e, 0x6f, 0x6f, 0xfc, 0xfc, + 0x6d, 0x6d, 0x6f, 0x6f, 0xfc, 0xfc, 0x6f, 0x6f, 0x6e, 0x6e, 0xfc, 0xfc, + 0x6f, 0x6f, 0x6d, 0x6d, 0xfc, 0xfc, 0xf4, 0xf4, 0xf5, 0xf5, 0xfc, 0xfc, + 0xf4, 0xf4, 0xf5, 0xf5, 0xfc, 0xfc, 0xf5, 0xf5, 0xf4, 0xf4, 0xfc, 0xfc, + 0xf5, 0xf5, 0xf4, 0xf4, 0xfc, 0xfc, 0xfc, 0xfc, 0xef, 0xef, 0xb9, 0xb8, + 0xbb, 0xba, 0xbc, 0xbc, 0xfc, 0xfc, 0xbd, 0xbd, 0xbc, 0xbc, 0x7a, 0x7b, + 0xda, 0xdb, 0xd8, 0xd8, 0xcd, 0xcd, 0xce, 0xce, 0xcf, 0xcf, 0x7d, 0x7c, + 0xd1, 0x8c, 0xd3, 0xd2, 0x7d, 0x7c, 0x89, 0x88, 0x8b, 0x8a, 0xd5, 0xd4, + 0xe3, 0xe2, 0xd3, 0xd2, 0xd5, 0xd4, 0xe3, 0xe2, 0x8b, 0x8a, 0xe5, 0xe5, + 0xe6, 0xe6, 0xeb, 0xeb, 0xec, 0xec, 0xed, 0xed, 0xee, 0xee, 0xfc, 0xfc, + 0xd0, 0xd0, 0xd7, 0xd7, 0xbf, 0xbe, 0xc1, 0xc0, 0xc2, 0xfc, 0xc4, 0xc3, + 0xc6, 0xc5, 0xc8, 0xc7, 0xbf, 0xbe, 0xca, 0xc9, 0xc2, 0xfc, 0xc4, 0xc3, + 0xc6, 0xc5, 0xcc, 0xcb, 0xfc, 0xfc, 0xe8, 0xe7, 0xea, 0xe9, 0xf2, 0xf2, + 0xf3, 0xf3, 0xf2, 0xf2, 0xf1, 0xf1, 0xf1, 0xf1, 0xfc, 0xfc, 0xf0, 0xf0, + 0xfc, 0xfc, 0xfc, 0xfc, 0x0c, 0x0c, 0x00, 0x0c, 0x0c, 0xa8, 0x54, 0x3c, + 0xea, 0x18, 0x48, 0x48, 0xcc, 0xc0, 0x18, 0x18, 0x18, 0x90, 0x24, 0xff, + 0x48, 0x9c, 0xd2, 0xd8, 0xf0, 0xf6, 0xfc, 0x01, 0x02, 0x03, 0x02, 0x01, + 0x01, 0x03, 0x03, 0x03, 0x01, 0x01, 0x02, 0x02, 0x21, 0x01, 0x02, 0x01, + 0x01, 0x02, 0xff, 0x02, 0x02, 0x01, 0x01, 0x02, 0x02, 0x02, 0x08, 0x18, + 0x18, 0x19, 0x1a, 0x19, 0x18, 0xb5, 0xcf, 0x85, 0x02, 0xad, 0xae, 0x03, + 0x85, 0x05, 0xbc, 0xe5, 0x06, 0x84, 0xeb, 0xa9, 0x00, 0x8d, 0x09, 0x01, + 0xb5, 0x46, 0x85, 0x03, 0xbd, 0xc5, 0x03, 0x85, 0x04, 0xb5, 0x16, 0xc9, + 0x0d, 0xd0, 0x0a, 0xb4, 0x58, 0x30, 0x06, 0xbc, 0x8a, 0x07, 0xf0, 0x01, + 0x60, 0xb5, 0x1e, 0x85, 0xed, 0x29, 0x1f, 0xa8, 0xb5, 0x16, 0xc9, 0x35, + 0xd0, 0x08, 0xa0, 0x00, 0xa9, 0x01, 0x85, 0x03, 0xa9, 0x15, 0xc9, 0x33, + 0xd0, 0x13, 0xc6, 0x02, 0xa9, 0x03, 0xbc, 0x8a, 0x07, 0xf0, 0x02, 0x09, + 0x20, 0x85, 0x04, 0xa0, 0x00, 0x84, 0xed, 0xa9, 0x08, 0xc9, 0x32, 0xd0, + 0x08, 0xa0, 0x03, 0xae, 0x0e, 0x07, 0xbd, 0x78, 0xe8, 0x85, 0xef, 0x84, + 0xec, 0xa6, 0x08, 0xc9, 0x0c, 0xd0, 0x07, 0xb5, 0xa0, 0x30, 0x03, 0xee, + 0x09, 0x01, 0xad, 0x6a, 0x03, 0xf0, 0x09, 0xa0, 0x16, 0xc9, 0x01, 0xf0, + 0x01, 0xc8, 0x84, 0xef, 0xa4, 0xef, 0xc0, 0x06, 0xd0, 0x1d, 0xb5, 0x1e, + 0xc9, 0x02, 0x90, 0x04, 0xa2, 0x04, 0x86, 0xec, 0x29, 0x20, 0x0d, 0x47, + 0x07, 0xd0, 0x0c, 0xa5, 0x09, 0x29, 0x08, 0xd0, 0x06, 0xa5, 0x03, 0x49, + 0x03, 0x85, 0x03, 0xb9, 0x5b, 0xe8, 0x05, 0x04, 0x85, 0x04, 0xb9, 0x40, + 0xe8, 0xaa, 0xa4, 0xec, 0xad, 0x6a, 0x03, 0xf0, 0x30, 0xc9, 0x01, 0xd0, + 0x13, 0xad, 0x63, 0x03, 0x10, 0x02, 0xa2, 0xde, 0xa5, 0xed, 0x29, 0x20, + 0xf0, 0x03, 0x8e, 0x09, 0x01, 0x4c, 0x4b, 0xea, 0xad, 0x63, 0x03, 0x29, + 0x01, 0xf0, 0x02, 0xa2, 0xe4, 0xa5, 0xed, 0x29, 0x20, 0xf0, 0xee, 0xa5, + 0x02, 0x38, 0xe9, 0x10, 0x85, 0x02, 0x4c, 0x46, 0xe9, 0xe0, 0x24, 0xd0, + 0x11, 0xc0, 0x05, 0xd0, 0x0a, 0xa2, 0x30, 0xa9, 0x02, 0x85, 0x03, 0xa9, + 0x05, 0x85, 0xec, 0x4c, 0xca, 0xe9, 0xe0, 0x90, 0xd0, 0x12, 0xa5, 0xed, + 0x29, 0x20, 0xd0, 0x09, 0xad, 0x8f, 0x07, 0xc9, 0x10, 0xb0, 0x02, 0xa2, + 0x96, 0x4c, 0x37, 0xea, 0xa5, 0xef, 0xc9, 0x04, 0xb0, 0x10, 0xc0, 0x02, + 0x90, 0x0c, 0xa2, 0x5a, 0xa4, 0xef, 0xc0, 0x02, 0xd0, 0x04, 0xa2, 0x7e, + 0xe6, 0x02, 0xa5, 0xec, 0xc9, 0x04, 0xd0, 0x1e, 0xa2, 0x72, 0xe6, 0x02, + 0xa4, 0xef, 0xc0, 0x02, 0xf0, 0x04, 0xa2, 0x66, 0xe6, 0x02, 0xc0, 0x06, + 0xd0, 0x0c, 0xa2, 0x54, 0xa5, 0xed, 0x29, 0x20, 0xd0, 0x04, 0xa2, 0x8a, + 0xc6, 0x02, 0xa4, 0x08, 0xa5, 0xef, 0xc9, 0x05, 0xd0, 0x0c, 0xa5, 0xed, + 0xf0, 0x24, 0x29, 0x08, 0xf0, 0x5d, 0xa2, 0xb4, 0xd0, 0x1c, 0xe0, 0x48, + 0xf0, 0x18, 0xb9, 0x96, 0x07, 0xc9, 0x05, 0xb0, 0x4e, 0xe0, 0x3c, 0xd0, + 0x0d, 0xc9, 0x01, 0xf0, 0x46, 0xe6, 0x02, 0xe6, 0x02, 0xe6, 0x02, 0x4c, + 0x29, 0xea, 0xa5, 0xef, 0xc9, 0x06, 0xf0, 0x37, 0xc9, 0x08, 0xf0, 0x33, + 0xc9, 0x0c, 0xf0, 0x2f, 0xc9, 0x18, 0xb0, 0x2b, 0xa0, 0x00, 0xc9, 0x15, + 0xd0, 0x10, 0xc8, 0xad, 0x5f, 0x07, 0xc9, 0x07, 0xb0, 0x1d, 0xa2, 0xa2, + 0xa9, 0x03, 0x85, 0xec, 0xd0, 0x15, 0xa5, 0x09, 0x39, 0x76, 0xe8, 0xd0, + 0x0e, 0xa5, 0xed, 0x29, 0xa0, 0x0d, 0x47, 0x07, 0xd0, 0x05, 0x8a, 0x18, + 0x69, 0x06, 0xaa, 0xa5, 0xed, 0x29, 0x20, 0xf0, 0x0e, 0xa5, 0xef, 0xc9, + 0x04, 0x90, 0x08, 0xa0, 0x01, 0x8c, 0x09, 0x01, 0x88, 0x84, 0xec, 0xa4, + 0xeb, 0x20, 0xaa, 0xeb, 0x20, 0xaa, 0xeb, 0x20, 0xaa, 0xeb, 0xa6, 0x08, + 0xbc, 0xe5, 0x06, 0xa5, 0xef, 0xc9, 0x08, 0xd0, 0x03, 0x4c, 0x64, 0xeb, + 0xad, 0x09, 0x01, 0xf0, 0x3d, 0xb9, 0x02, 0x02, 0x09, 0x80, 0xc8, 0xc8, + 0x20, 0xb5, 0xe5, 0x88, 0x88, 0x98, 0xaa, 0xa5, 0xef, 0xc9, 0x05, 0xf0, + 0x0d, 0xc9, 0x11, 0xf0, 0x09, 0xc9, 0x15, 0xb0, 0x05, 0x8a, 0x18, 0x69, + 0x08, 0xaa, 0xbd, 0x01, 0x02, 0x48, 0xbd, 0x05, 0x02, 0x48, 0xb9, 0x11, + 0x02, 0x9d, 0x01, 0x02, 0xb9, 0x15, 0x02, 0x9d, 0x05, 0x02, 0x68, 0x99, + 0x15, 0x02, 0x68, 0x99, 0x11, 0x02, 0xad, 0x6a, 0x03, 0xd0, 0xb6, 0xa5, + 0xef, 0xa6, 0xec, 0xc9, 0x05, 0xd0, 0x03, 0x4c, 0x64, 0xeb, 0xc9, 0x07, + 0xf0, 0x1d, 0xc9, 0x0d, 0xf0, 0x19, 0xc9, 0x0c, 0xf0, 0x15, 0xc9, 0x12, + 0xd0, 0x04, 0xe0, 0x05, 0xd0, 0x48, 0xc9, 0x15, 0xd0, 0x05, 0xa9, 0x42, + 0x99, 0x16, 0x02, 0xe0, 0x02, 0x90, 0x3b, 0xad, 0x6a, 0x03, 0xd0, 0x36, + 0xb9, 0x02, 0x02, 0x29, 0xa3, 0x99, 0x02, 0x02, 0x99, 0x0a, 0x02, 0x99, + 0x12, 0x02, 0x09, 0x40, 0xe0, 0x05, 0xd0, 0x02, 0x09, 0x80, 0x99, 0x06, + 0x02, 0x99, 0x0e, 0x02, 0x99, 0x16, 0x02, 0xe0, 0x04, 0xd0, 0x13, 0xb9, + 0x0a, 0x02, 0x09, 0x80, 0x99, 0x0a, 0x02, 0x99, 0x12, 0x02, 0x09, 0x40, + 0x99, 0x0e, 0x02, 0x99, 0x16, 0x02, 0xa5, 0xef, 0xc9, 0x11, 0xd0, 0x36, + 0xad, 0x09, 0x01, 0xd0, 0x21, 0xb9, 0x12, 0x02, 0x29, 0x81, 0x99, 0x12, + 0x02, 0xb9, 0x16, 0x02, 0x09, 0x41, 0x99, 0x16, 0x02, 0xae, 0x8f, 0x07, + 0xe0, 0x10, 0xb0, 0x30, 0x99, 0x0e, 0x02, 0x29, 0x81, 0x99, 0x0a, 0x02, + 0x90, 0x26, 0xb9, 0x02, 0x02, 0x29, 0x81, 0x99, 0x02, 0x02, 0xb9, 0x06, + 0x02, 0x09, 0x41, 0x99, 0x06, 0x02, 0xa5, 0xef, 0xc9, 0x18, 0x90, 0x10, + 0xa9, 0x82, 0x99, 0x0a, 0x02, 0x99, 0x12, 0x02, 0x09, 0x40, 0x99, 0x0e, + 0x02, 0x99, 0x16, 0x02, 0xa6, 0x08, 0xad, 0xd1, 0x03, 0x4a, 0x4a, 0x4a, + 0x48, 0x90, 0x05, 0xa9, 0x04, 0x20, 0xc1, 0xeb, 0x68, 0x4a, 0x48, 0x90, + 0x05, 0xa9, 0x00, 0x20, 0xc1, 0xeb, 0x68, 0x4a, 0x4a, 0x48, 0x90, 0x05, + 0xa9, 0x10, 0x20, 0xb7, 0xeb, 0x68, 0x4a, 0x48, 0x90, 0x05, 0xa9, 0x08, + 0x20, 0xb7, 0xeb, 0x68, 0x4a, 0x90, 0x12, 0x20, 0xb7, 0xeb, 0xb5, 0x16, + 0xc9, 0x0c, 0xf0, 0x09, 0xb5, 0xb6, 0xc9, 0x02, 0xd0, 0x03, 0x20, 0x98, + 0xc9, 0x60, 0xbd, 0x3e, 0xe7, 0x85, 0x00, 0xbd, 0x3f, 0xe7, 0x85, 0x01, + 0x4c, 0x82, 0xf2, 0x18, 0x7d, 0xe5, 0x06, 0xa8, 0xa9, 0xf8, 0x4c, 0xc1, + 0xe5, 0x18, 0x7d, 0xe5, 0x06, 0xa8, 0x20, 0x4a, 0xec, 0x99, 0x10, 0x02, + 0x60, 0x85, 0x85, 0x86, 0x86, 0xad, 0xbc, 0x03, 0x85, 0x02, 0xad, 0xb1, + 0x03, 0x85, 0x05, 0xa9, 0x03, 0x85, 0x04, 0x4a, 0x85, 0x03, 0xbc, 0xec, + 0x06, 0xa2, 0x00, 0xbd, 0xcd, 0xeb, 0x85, 0x00, 0xbd, 0xce, 0xeb, 0x20, + 0xb2, 0xeb, 0xe0, 0x04, 0xd0, 0xf1, 0xa6, 0x08, 0xbc, 0xec, 0x06, 0xad, + 0x4e, 0x07, 0xc9, 0x01, 0xf0, 0x08, 0xa9, 0x86, 0x99, 0x01, 0x02, 0x99, + 0x05, 0x02, 0xbd, 0xe8, 0x03, 0xc9, 0xc4, 0xd0, 0x24, 0xa9, 0x87, 0xc8, + 0x20, 0xbb, 0xe5, 0x88, 0xa9, 0x03, 0xae, 0x4e, 0x07, 0xca, 0xf0, 0x01, + 0x4a, 0xa6, 0x08, 0x99, 0x02, 0x02, 0x09, 0x40, 0x99, 0x06, 0x02, 0x09, + 0x80, 0x99, 0x0e, 0x02, 0x29, 0x83, 0x99, 0x0a, 0x02, 0xad, 0xd4, 0x03, + 0x48, 0x29, 0x04, 0xf0, 0x08, 0xa9, 0xf8, 0x99, 0x04, 0x02, 0x99, 0x0c, + 0x02, 0x68, 0x29, 0x08, 0xf0, 0x08, 0xa9, 0xf8, 0x99, 0x00, 0x02, 0x99, + 0x08, 0x02, 0x60, 0xa9, 0x02, 0x85, 0x00, 0xa9, 0x75, 0xa4, 0x0e, 0xc0, + 0x05, 0xf0, 0x06, 0xa9, 0x03, 0x85, 0x00, 0xa9, 0x84, 0xbc, 0xec, 0x06, + 0xc8, 0x20, 0xbb, 0xe5, 0xa5, 0x09, 0x0a, 0x0a, 0x0a, 0x0a, 0x29, 0xc0, + 0x05, 0x00, 0xc8, 0x20, 0xbb, 0xe5, 0x88, 0x88, 0xad, 0xbc, 0x03, 0x20, + 0xc1, 0xe5, 0xad, 0xb1, 0x03, 0x99, 0x03, 0x02, 0xbd, 0xf1, 0x03, 0x38, + 0xed, 0x1c, 0x07, 0x85, 0x00, 0x38, 0xed, 0xb1, 0x03, 0x65, 0x00, 0x69, + 0x06, 0x99, 0x07, 0x02, 0xad, 0xbd, 0x03, 0x99, 0x08, 0x02, 0x99, 0x0c, + 0x02, 0xad, 0xb2, 0x03, 0x99, 0x0b, 0x02, 0xa5, 0x00, 0x38, 0xed, 0xb2, + 0x03, 0x65, 0x00, 0x69, 0x06, 0x99, 0x0f, 0x02, 0xad, 0xd4, 0x03, 0x20, + 0x46, 0xec, 0xad, 0xd4, 0x03, 0x0a, 0x90, 0x05, 0xa9, 0xf8, 0x20, 0xc1, + 0xe5, 0xa5, 0x00, 0x10, 0x10, 0xb9, 0x03, 0x02, 0xd9, 0x07, 0x02, 0x90, + 0x08, 0xa9, 0xf8, 0x99, 0x04, 0x02, 0x99, 0x0c, 0x02, 0x60, 0xbc, 0xf1, + 0x06, 0xad, 0xba, 0x03, 0x99, 0x00, 0x02, 0xad, 0xaf, 0x03, 0x99, 0x03, + 0x02, 0xa5, 0x09, 0x4a, 0x4a, 0x48, 0x29, 0x01, 0x49, 0x64, 0x99, 0x01, + 0x02, 0x68, 0x4a, 0x4a, 0xa9, 0x02, 0x90, 0x02, 0x09, 0xc0, 0x99, 0x02, + 0x02, 0x60, 0x68, 0x67, 0x66, 0xbc, 0xec, 0x06, 0xb5, 0x24, 0xf6, 0x24, + 0x4a, 0x29, 0x07, 0xc9, 0x03, 0xb0, 0x4a, 0xaa, 0xbd, 0x06, 0xed, 0xc8, + 0x20, 0xbb, 0xe5, 0x88, 0xa6, 0x08, 0xad, 0xba, 0x03, 0x38, 0xe9, 0x04, + 0x99, 0x00, 0x02, 0x99, 0x08, 0x02, 0x18, 0x69, 0x08, 0x99, 0x04, 0x02, + 0x99, 0x0c, 0x02, 0xad, 0xaf, 0x03, 0x38, 0xe9, 0x04, 0x99, 0x03, 0x02, + 0x99, 0x07, 0x02, 0x18, 0x69, 0x08, 0x99, 0x0b, 0x02, 0x99, 0x0f, 0x02, + 0xa9, 0x02, 0x99, 0x02, 0x02, 0xa9, 0x82, 0x99, 0x06, 0x02, 0xa9, 0x42, + 0x99, 0x0a, 0x02, 0xa9, 0xc2, 0x99, 0x0e, 0x02, 0x60, 0xa9, 0x00, 0x95, + 0x24, 0x60, 0xbc, 0xe5, 0x06, 0xa9, 0x5b, 0xc8, 0x20, 0xb5, 0xe5, 0xc8, + 0xa9, 0x02, 0x20, 0xb5, 0xe5, 0x88, 0x88, 0xad, 0xae, 0x03, 0x99, 0x03, + 0x02, 0x99, 0x0f, 0x02, 0x18, 0x69, 0x08, 0x99, 0x07, 0x02, 0x99, 0x13, + 0x02, 0x18, 0x69, 0x08, 0x99, 0x0b, 0x02, 0x99, 0x17, 0x02, 0xb5, 0xcf, + 0xaa, 0x48, 0xe0, 0x20, 0xb0, 0x02, 0xa9, 0xf8, 0x20, 0xbe, 0xe5, 0x68, + 0x18, 0x69, 0x80, 0xaa, 0xe0, 0x20, 0xb0, 0x02, 0xa9, 0xf8, 0x99, 0x0c, + 0x02, 0x99, 0x10, 0x02, 0x99, 0x14, 0x02, 0xad, 0xd1, 0x03, 0x48, 0x29, + 0x08, 0xf0, 0x08, 0xa9, 0xf8, 0x99, 0x00, 0x02, 0x99, 0x0c, 0x02, 0x68, + 0x48, 0x29, 0x04, 0xf0, 0x08, 0xa9, 0xf8, 0x99, 0x04, 0x02, 0x99, 0x10, + 0x02, 0x68, 0x29, 0x02, 0xf0, 0x08, 0xa9, 0xf8, 0x99, 0x08, 0x02, 0x99, + 0x14, 0x02, 0xa6, 0x08, 0x60, 0xa4, 0xb5, 0x88, 0xd0, 0x20, 0xad, 0xd3, + 0x03, 0x29, 0x08, 0xd0, 0x19, 0xbc, 0xee, 0x06, 0xad, 0xb0, 0x03, 0x99, + 0x03, 0x02, 0xad, 0xbb, 0x03, 0x99, 0x00, 0x02, 0xa9, 0x74, 0x99, 0x01, + 0x02, 0xa9, 0x02, 0x99, 0x02, 0x02, 0x60, 0x20, 0x28, 0xc8, 0x18, 0x00, + 0x40, 0x50, 0x58, 0x80, 0x88, 0xb8, 0x78, 0x60, 0xa0, 0xb0, 0xb8, 0x00, + 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, + 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, + 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, + 0x25, 0x26, 0x27, 0x08, 0x09, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x30, 0x2c, 0x2d, 0x08, 0x09, 0x0a, 0x0b, 0x2e, + 0x2f, 0x2c, 0x2d, 0x08, 0x09, 0x28, 0x29, 0x2a, 0x2b, 0x5c, 0x5d, 0x08, + 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x5e, 0x5f, 0xfc, 0xfc, 0x08, 0x09, 0x58, + 0x59, 0x5a, 0x5a, 0x08, 0x09, 0x28, 0x29, 0x2a, 0x2b, 0x0e, 0x0f, 0xfc, + 0xfc, 0xfc, 0xfc, 0x32, 0x33, 0x34, 0x35, 0xfc, 0xfc, 0xfc, 0xfc, 0x36, + 0x37, 0x38, 0x39, 0xfc, 0xfc, 0xfc, 0xfc, 0x3a, 0x37, 0x3b, 0x3c, 0xfc, + 0xfc, 0xfc, 0xfc, 0x3d, 0x3e, 0x3f, 0x40, 0xfc, 0xfc, 0xfc, 0xfc, 0x32, + 0x41, 0x42, 0x43, 0xfc, 0xfc, 0xfc, 0xfc, 0x32, 0x33, 0x44, 0x45, 0xfc, + 0xfc, 0xfc, 0xfc, 0x32, 0x33, 0x44, 0x47, 0xfc, 0xfc, 0xfc, 0xfc, 0x32, + 0x33, 0x48, 0x49, 0xfc, 0xfc, 0xfc, 0xfc, 0x32, 0x33, 0x90, 0x91, 0xfc, + 0xfc, 0xfc, 0xfc, 0x3a, 0x37, 0x92, 0x93, 0xfc, 0xfc, 0xfc, 0xfc, 0x9e, + 0x9e, 0x9f, 0x9f, 0xfc, 0xfc, 0xfc, 0xfc, 0x3a, 0x37, 0x4f, 0x4f, 0xfc, + 0xfc, 0x00, 0x01, 0x4c, 0x4d, 0x4e, 0x4e, 0x00, 0x01, 0x4c, 0x4d, 0x4a, + 0x4a, 0x4b, 0x4b, 0x31, 0x46, 0xad, 0x9e, 0x07, 0xf0, 0x05, 0xa5, 0x09, + 0x4a, 0xb0, 0x40, 0xa5, 0x0e, 0xc9, 0x0b, 0xf0, 0x47, 0xad, 0x0b, 0x07, + 0xd0, 0x3c, 0xac, 0x04, 0x07, 0xf0, 0x31, 0xa5, 0x1d, 0xc9, 0x00, 0xf0, + 0x2b, 0x20, 0x34, 0xef, 0xa5, 0x09, 0x29, 0x04, 0xd0, 0x21, 0xaa, 0xac, + 0xe4, 0x06, 0xa5, 0x33, 0x4a, 0xb0, 0x04, 0xc8, 0xc8, 0xc8, 0xc8, 0xad, + 0x54, 0x07, 0xf0, 0x09, 0xb9, 0x19, 0x02, 0xcd, 0xb5, 0xee, 0xf0, 0x07, + 0xe8, 0xbd, 0xe7, 0xee, 0x99, 0x19, 0x02, 0x60, 0x20, 0xec, 0xef, 0x4c, + 0x45, 0xef, 0x20, 0xb0, 0xf0, 0x4c, 0x45, 0xef, 0xa0, 0x0e, 0xb9, 0x07, + 0xee, 0x8d, 0xd5, 0x06, 0xa9, 0x04, 0x20, 0xbe, 0xef, 0x20, 0xe9, 0xf0, + 0xad, 0x11, 0x07, 0xf0, 0x25, 0xa0, 0x00, 0xad, 0x81, 0x07, 0xcd, 0x11, + 0x07, 0x8c, 0x11, 0x07, 0xb0, 0x18, 0x8d, 0x11, 0x07, 0xa0, 0x07, 0xb9, + 0x07, 0xee, 0x8d, 0xd5, 0x06, 0xa0, 0x04, 0xa5, 0x57, 0x05, 0x0c, 0xf0, + 0x01, 0x88, 0x98, 0x20, 0xbe, 0xef, 0xad, 0xd0, 0x03, 0x4a, 0x4a, 0x4a, + 0x4a, 0x85, 0x00, 0xa2, 0x03, 0xad, 0xe4, 0x06, 0x18, 0x69, 0x18, 0xa8, + 0xa9, 0xf8, 0x46, 0x00, 0x90, 0x03, 0x20, 0xc1, 0xe5, 0x98, 0x38, 0xe9, + 0x08, 0xa8, 0xca, 0x10, 0xef, 0x60, 0x58, 0x01, 0x00, 0x60, 0xff, 0x04, + 0xa2, 0x05, 0xbd, 0x9e, 0xef, 0x95, 0x02, 0xca, 0x10, 0xf8, 0xa2, 0xb8, + 0xa0, 0x04, 0x20, 0xdc, 0xef, 0xad, 0x26, 0x02, 0x09, 0x40, 0x8d, 0x22, + 0x02, 0x60, 0x85, 0x07, 0xad, 0xad, 0x03, 0x8d, 0x55, 0x07, 0x85, 0x05, + 0xad, 0xb8, 0x03, 0x85, 0x02, 0xa5, 0x33, 0x85, 0x03, 0xad, 0xc4, 0x03, + 0x85, 0x04, 0xae, 0xd5, 0x06, 0xac, 0xe4, 0x06, 0xbd, 0x17, 0xee, 0x85, + 0x00, 0xbd, 0x18, 0xee, 0x20, 0xb2, 0xeb, 0xc6, 0x07, 0xd0, 0xf1, 0x60, + 0xa5, 0x1d, 0xc9, 0x03, 0xf0, 0x52, 0xc9, 0x02, 0xf0, 0x3e, 0xc9, 0x01, + 0xd0, 0x11, 0xad, 0x04, 0x07, 0xd0, 0x51, 0xa0, 0x06, 0xad, 0x14, 0x07, + 0xd0, 0x22, 0xa0, 0x00, 0x4c, 0x28, 0xf0, 0xa0, 0x06, 0xad, 0x14, 0x07, + 0xd0, 0x16, 0xa0, 0x02, 0xa5, 0x57, 0x05, 0x0c, 0xf0, 0x0e, 0xad, 0x00, + 0x07, 0xc9, 0x09, 0x90, 0x1b, 0xa5, 0x45, 0x25, 0x33, 0xd0, 0x15, 0xc8, + 0x20, 0x91, 0xf0, 0xa9, 0x00, 0x8d, 0x0d, 0x07, 0xb9, 0x07, 0xee, 0x60, + 0xa0, 0x04, 0x20, 0x91, 0xf0, 0x4c, 0x62, 0xf0, 0xa0, 0x04, 0x20, 0x91, + 0xf0, 0x4c, 0x68, 0xf0, 0xa0, 0x05, 0xa5, 0x9f, 0xf0, 0xde, 0x20, 0x91, + 0xf0, 0x4c, 0x6d, 0xf0, 0xa0, 0x01, 0x20, 0x91, 0xf0, 0xad, 0x82, 0x07, + 0x0d, 0x0d, 0x07, 0xd0, 0x0b, 0xa5, 0x0a, 0x0a, 0xb0, 0x06, 0xad, 0x0d, + 0x07, 0x4c, 0xd0, 0xf0, 0xa9, 0x03, 0x4c, 0x6f, 0xf0, 0xa9, 0x02, 0x85, + 0x00, 0x20, 0x62, 0xf0, 0x48, 0xad, 0x81, 0x07, 0xd0, 0x15, 0xad, 0x0c, + 0x07, 0x8d, 0x81, 0x07, 0xad, 0x0d, 0x07, 0x18, 0x69, 0x01, 0xc5, 0x00, + 0x90, 0x02, 0xa9, 0x00, 0x8d, 0x0d, 0x07, 0x68, 0x60, 0xad, 0x54, 0x07, + 0xf0, 0x05, 0x98, 0x18, 0x69, 0x08, 0xa8, 0x60, 0x00, 0x01, 0x00, 0x01, + 0x00, 0x01, 0x02, 0x00, 0x01, 0x02, 0x02, 0x00, 0x02, 0x00, 0x02, 0x00, + 0x02, 0x00, 0x02, 0x00, 0xac, 0x0d, 0x07, 0xa5, 0x09, 0x29, 0x03, 0xd0, + 0x0d, 0xc8, 0xc0, 0x0a, 0x90, 0x05, 0xa0, 0x00, 0x8c, 0x0b, 0x07, 0x8c, + 0x0d, 0x07, 0xad, 0x54, 0x07, 0xd0, 0x0c, 0xb9, 0x9c, 0xf0, 0xa0, 0x0f, + 0x0a, 0x0a, 0x0a, 0x79, 0x07, 0xee, 0x60, 0x98, 0x18, 0x69, 0x0a, 0xaa, + 0xa0, 0x09, 0xbd, 0x9c, 0xf0, 0xd0, 0x02, 0xa0, 0x01, 0xb9, 0x07, 0xee, + 0x60, 0xac, 0xe4, 0x06, 0xa5, 0x0e, 0xc9, 0x0b, 0xf0, 0x13, 0xad, 0xd5, + 0x06, 0xc9, 0x50, 0xf0, 0x1e, 0xc9, 0xb8, 0xf0, 0x1a, 0xc9, 0xc0, 0xf0, + 0x16, 0xc9, 0xc8, 0xd0, 0x24, 0xb9, 0x12, 0x02, 0x29, 0x3f, 0x99, 0x12, + 0x02, 0xb9, 0x16, 0x02, 0x29, 0x3f, 0x09, 0x40, 0x99, 0x16, 0x02, 0xb9, + 0x1a, 0x02, 0x29, 0x3f, 0x99, 0x1a, 0x02, 0xb9, 0x1e, 0x02, 0x29, 0x3f, + 0x09, 0x40, 0x99, 0x1e, 0x02, 0x60, 0xa2, 0x00, 0xa0, 0x00, 0x4c, 0x42, + 0xf1, 0xa0, 0x01, 0x20, 0xa8, 0xf1, 0xa0, 0x03, 0x4c, 0x42, 0xf1, 0xa0, + 0x00, 0x20, 0xa8, 0xf1, 0xa0, 0x02, 0x20, 0x71, 0xf1, 0xa6, 0x08, 0x60, + 0xa0, 0x02, 0x20, 0xa8, 0xf1, 0xa0, 0x06, 0x4c, 0x42, 0xf1, 0xa9, 0x01, + 0xa0, 0x01, 0x4c, 0x65, 0xf1, 0xa9, 0x09, 0xa0, 0x04, 0x20, 0x65, 0xf1, + 0xe8, 0xe8, 0xa9, 0x09, 0xc8, 0x86, 0x00, 0x18, 0x65, 0x00, 0xaa, 0x20, + 0x71, 0xf1, 0xa6, 0x08, 0x60, 0xb5, 0xce, 0x99, 0xb8, 0x03, 0xb5, 0x86, + 0x38, 0xed, 0x1c, 0x07, 0x99, 0xad, 0x03, 0x60, 0xa2, 0x00, 0xa0, 0x00, + 0x4c, 0xc0, 0xf1, 0xa0, 0x00, 0x20, 0xa8, 0xf1, 0xa0, 0x02, 0x4c, 0xc0, + 0xf1, 0xa0, 0x01, 0x20, 0xa8, 0xf1, 0xa0, 0x03, 0x4c, 0xc0, 0xf1, 0xa0, + 0x02, 0x20, 0xa8, 0xf1, 0xa0, 0x06, 0x4c, 0xc0, 0xf1, 0x07, 0x16, 0x0d, + 0x8a, 0x18, 0x79, 0xa5, 0xf1, 0xaa, 0x60, 0xa9, 0x01, 0xa0, 0x01, 0x4c, + 0xba, 0xf1, 0xa9, 0x09, 0xa0, 0x04, 0x86, 0x00, 0x18, 0x65, 0x00, 0xaa, + 0x98, 0x48, 0x20, 0xd7, 0xf1, 0x0a, 0x0a, 0x0a, 0x0a, 0x05, 0x00, 0x85, + 0x00, 0x68, 0xa8, 0xa5, 0x00, 0x99, 0xd0, 0x03, 0xa6, 0x08, 0x60, 0x20, + 0xf6, 0xf1, 0x4a, 0x4a, 0x4a, 0x4a, 0x85, 0x00, 0x4c, 0x39, 0xf2, 0x7f, + 0x3f, 0x1f, 0x0f, 0x07, 0x03, 0x01, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, + 0xfc, 0xfe, 0xff, 0x07, 0x0f, 0x07, 0x86, 0x04, 0xa0, 0x01, 0xb9, 0x1c, + 0x07, 0x38, 0xf5, 0x86, 0x85, 0x07, 0xb9, 0x1a, 0x07, 0xf5, 0x6d, 0xbe, + 0xf3, 0xf1, 0xc9, 0x00, 0x30, 0x10, 0xbe, 0xf4, 0xf1, 0xc9, 0x01, 0x10, + 0x09, 0xa9, 0x38, 0x85, 0x06, 0xa9, 0x08, 0x20, 0x6d, 0xf2, 0xbd, 0xe3, + 0xf1, 0xa6, 0x04, 0xc9, 0x00, 0xd0, 0x03, 0x88, 0x10, 0xd0, 0x60, 0x00, + 0x08, 0x0c, 0x0e, 0x0f, 0x07, 0x03, 0x01, 0x00, 0x04, 0x00, 0x04, 0xff, + 0x00, 0x86, 0x04, 0xa0, 0x01, 0xb9, 0x37, 0xf2, 0x38, 0xf5, 0xce, 0x85, + 0x07, 0xa9, 0x01, 0xf5, 0xb5, 0xbe, 0x34, 0xf2, 0xc9, 0x00, 0x30, 0x10, + 0xbe, 0x35, 0xf2, 0xc9, 0x01, 0x10, 0x09, 0xa9, 0x20, 0x85, 0x06, 0xa9, + 0x04, 0x20, 0x6d, 0xf2, 0xbd, 0x2b, 0xf2, 0xa6, 0x04, 0xc9, 0x00, 0xd0, + 0x03, 0x88, 0x10, 0xd1, 0x60, 0x85, 0x05, 0xa5, 0x07, 0xc5, 0x06, 0xb0, + 0x0c, 0x4a, 0x4a, 0x4a, 0x29, 0x07, 0xc0, 0x01, 0xb0, 0x02, 0x65, 0x05, + 0xaa, 0x60, 0xa5, 0x03, 0x4a, 0x4a, 0xa5, 0x00, 0x90, 0x0c, 0x99, 0x05, + 0x02, 0xa5, 0x01, 0x99, 0x01, 0x02, 0xa9, 0x40, 0xd0, 0x0a, 0x99, 0x01, + 0x02, 0xa5, 0x01, 0x99, 0x05, 0x02, 0xa9, 0x00, 0x05, 0x04, 0x99, 0x02, + 0x02, 0x99, 0x06, 0x02, 0xa5, 0x02, 0x99, 0x00, 0x02, 0x99, 0x04, 0x02, + 0xa5, 0x05, 0x99, 0x03, 0x02, 0x18, 0x69, 0x08, 0x99, 0x07, 0x02, 0xa5, + 0x02, 0x18, 0x69, 0x08, 0x85, 0x02, 0x98, 0x18, 0x69, 0x08, 0xa8, 0xe8, + 0xe8, 0x60, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xad, 0x70, 0x07, 0xd0, + 0x04, 0x8d, 0x15, 0x40, 0x60, 0xa9, 0xff, 0x8d, 0x17, 0x40, 0xa9, 0x0f, + 0x8d, 0x15, 0x40, 0xad, 0xc6, 0x07, 0xd0, 0x06, 0xa5, 0xfa, 0xc9, 0x01, + 0xd0, 0x5d, 0xad, 0xb2, 0x07, 0xd0, 0x23, 0xa5, 0xfa, 0xf0, 0x66, 0x8d, + 0xb2, 0x07, 0x8d, 0xc6, 0x07, 0xa9, 0x00, 0x8d, 0x15, 0x40, 0x85, 0xf1, + 0x85, 0xf2, 0x85, 0xf3, 0xa9, 0x0f, 0x8d, 0x15, 0x40, 0xa9, 0x2a, 0x8d, + 0xbb, 0x07, 0xa9, 0x44, 0xd0, 0x11, 0xad, 0xbb, 0x07, 0xc9, 0x24, 0xf0, + 0x08, 0xc9, 0x1e, 0xf0, 0xf1, 0xc9, 0x18, 0xd0, 0x09, 0xa9, 0x64, 0xa2, + 0x84, 0xa0, 0x7f, 0x20, 0x88, 0xf3, 0xce, 0xbb, 0x07, 0xd0, 0x2a, 0xa9, + 0x00, 0x8d, 0x15, 0x40, 0xad, 0xb2, 0x07, 0xc9, 0x02, 0xd0, 0x05, 0xa9, + 0x00, 0x8d, 0xc6, 0x07, 0xa9, 0x00, 0x8d, 0xb2, 0x07, 0xf0, 0x12, 0x20, + 0x1b, 0xf4, 0x20, 0x7c, 0xf5, 0x20, 0x67, 0xf6, 0x20, 0x94, 0xf6, 0xa9, + 0x00, 0x85, 0xfb, 0x85, 0xfc, 0xa9, 0x00, 0x85, 0xff, 0x85, 0xfe, 0x85, + 0xfd, 0x85, 0xfa, 0xac, 0xc0, 0x07, 0xa5, 0xf4, 0x29, 0x03, 0xf0, 0x07, + 0xee, 0xc0, 0x07, 0xc0, 0x30, 0x90, 0x06, 0x98, 0xf0, 0x03, 0xce, 0xc0, + 0x07, 0x8c, 0x11, 0x40, 0x60, 0x8c, 0x01, 0x40, 0x8e, 0x00, 0x40, 0x60, + 0x20, 0x81, 0xf3, 0xa2, 0x00, 0xa8, 0xb9, 0x01, 0xff, 0xf0, 0x0b, 0x9d, + 0x02, 0x40, 0xb9, 0x00, 0xff, 0x09, 0x08, 0x9d, 0x03, 0x40, 0x60, 0x8e, + 0x04, 0x40, 0x8c, 0x05, 0x40, 0x60, 0x20, 0x9f, 0xf3, 0xa2, 0x04, 0xd0, + 0xe0, 0xa2, 0x08, 0xd0, 0xdc, 0x9f, 0x9b, 0x98, 0x96, 0x95, 0x94, 0x92, + 0x90, 0x90, 0x9a, 0x97, 0x95, 0x93, 0x92, 0xa9, 0x40, 0x8d, 0xbb, 0x07, + 0xa9, 0x62, 0x20, 0x8b, 0xf3, 0xa2, 0x99, 0xd0, 0x25, 0xa9, 0x26, 0xd0, + 0x02, 0xa9, 0x18, 0xa2, 0x82, 0xa0, 0xa7, 0x20, 0x88, 0xf3, 0xa9, 0x28, + 0x8d, 0xbb, 0x07, 0xad, 0xbb, 0x07, 0xc9, 0x25, 0xd0, 0x06, 0xa2, 0x5f, + 0xa0, 0xf6, 0xd0, 0x08, 0xc9, 0x20, 0xd0, 0x29, 0xa2, 0x48, 0xa0, 0xbc, + 0x20, 0x81, 0xf3, 0xd0, 0x20, 0xa9, 0x05, 0xa0, 0x99, 0xd0, 0x04, 0xa9, + 0x0a, 0xa0, 0x93, 0xa2, 0x9e, 0x8d, 0xbb, 0x07, 0xa9, 0x0c, 0x20, 0x88, + 0xf3, 0xad, 0xbb, 0x07, 0xc9, 0x06, 0xd0, 0x05, 0xa9, 0xbb, 0x8d, 0x01, + 0x40, 0xd0, 0x60, 0xa4, 0xff, 0xf0, 0x20, 0x84, 0xf1, 0x30, 0xaa, 0x46, + 0xff, 0xb0, 0xaa, 0x46, 0xff, 0xb0, 0xd4, 0x46, 0xff, 0xb0, 0x2c, 0x46, + 0xff, 0xb0, 0x4a, 0x46, 0xff, 0xb0, 0x7f, 0x46, 0xff, 0xb0, 0xbe, 0x46, + 0xff, 0xb0, 0x80, 0xa5, 0xf1, 0xf0, 0x17, 0x30, 0x9a, 0x4a, 0xb0, 0x97, + 0x4a, 0xb0, 0xc2, 0x4a, 0xb0, 0x1b, 0x4a, 0xb0, 0x3c, 0x4a, 0xb0, 0x67, + 0x4a, 0xb0, 0xb6, 0x4a, 0xb0, 0x48, 0x60, 0xa9, 0x0e, 0x8d, 0xbb, 0x07, + 0xa0, 0x9c, 0xa2, 0x9e, 0xa9, 0x26, 0x20, 0x88, 0xf3, 0xac, 0xbb, 0x07, + 0xb9, 0xb0, 0xf3, 0x8d, 0x00, 0x40, 0xc0, 0x06, 0xd0, 0x05, 0xa9, 0x9e, + 0x8d, 0x02, 0x40, 0xd0, 0x25, 0xa9, 0x0e, 0xa0, 0xcb, 0xa2, 0x9f, 0x8d, + 0xbb, 0x07, 0xa9, 0x28, 0x20, 0x88, 0xf3, 0xd0, 0x15, 0xac, 0xbb, 0x07, + 0xc0, 0x08, 0xd0, 0x09, 0xa9, 0xa0, 0x8d, 0x02, 0x40, 0xa9, 0x9f, 0xd0, + 0x02, 0xa9, 0x90, 0x8d, 0x00, 0x40, 0xce, 0xbb, 0x07, 0xd0, 0x0e, 0xa2, + 0x00, 0x86, 0xf1, 0xa2, 0x0e, 0x8e, 0x15, 0x40, 0xa2, 0x0f, 0x8e, 0x15, + 0x40, 0x60, 0xa9, 0x2f, 0x8d, 0xbb, 0x07, 0xad, 0xbb, 0x07, 0x4a, 0xb0, + 0x10, 0x4a, 0xb0, 0x0d, 0x29, 0x02, 0xf0, 0x09, 0xa0, 0x91, 0xa2, 0x9a, + 0xa9, 0x44, 0x20, 0x88, 0xf3, 0x4c, 0xa2, 0xf4, 0x58, 0x02, 0x54, 0x56, + 0x4e, 0x44, 0x4c, 0x52, 0x4c, 0x48, 0x3e, 0x36, 0x3e, 0x36, 0x30, 0x28, + 0x4a, 0x50, 0x4a, 0x64, 0x3c, 0x32, 0x3c, 0x32, 0x2c, 0x24, 0x3a, 0x64, + 0x3a, 0x34, 0x2c, 0x22, 0x2c, 0x22, 0x1c, 0x14, 0x14, 0x04, 0x22, 0x24, + 0x16, 0x04, 0x24, 0x26, 0x18, 0x04, 0x26, 0x28, 0x1a, 0x04, 0x28, 0x2a, + 0x1c, 0x04, 0x2a, 0x2c, 0x1e, 0x04, 0x2c, 0x2e, 0x20, 0x04, 0x2e, 0x30, + 0x22, 0x04, 0x30, 0x32, 0xa9, 0x35, 0xa2, 0x8d, 0xd0, 0x04, 0xa9, 0x06, + 0xa2, 0x98, 0x8d, 0xbd, 0x07, 0xa0, 0x7f, 0xa9, 0x42, 0x20, 0xa6, 0xf3, + 0xad, 0xbd, 0x07, 0xc9, 0x30, 0xd0, 0x05, 0xa9, 0x54, 0x8d, 0x06, 0x40, + 0xd0, 0x2e, 0xa9, 0x20, 0x8d, 0xbd, 0x07, 0xa0, 0x94, 0xa9, 0x5e, 0xd0, + 0x0b, 0xad, 0xbd, 0x07, 0xc9, 0x18, 0xd0, 0x1c, 0xa0, 0x93, 0xa9, 0x18, + 0xd0, 0x7f, 0xa9, 0x36, 0x8d, 0xbd, 0x07, 0xad, 0xbd, 0x07, 0x4a, 0xb0, + 0x0b, 0xa8, 0xb9, 0xd9, 0xf4, 0xa2, 0x5d, 0xa0, 0x7f, 0x20, 0xa6, 0xf3, + 0xce, 0xbd, 0x07, 0xd0, 0x0e, 0xa2, 0x00, 0x86, 0xf2, 0xa2, 0x0d, 0x8e, + 0x15, 0x40, 0xa2, 0x0f, 0x8e, 0x15, 0x40, 0x60, 0xa5, 0xf2, 0x29, 0x40, + 0xd0, 0x65, 0xa4, 0xfe, 0xf0, 0x20, 0x84, 0xf2, 0x30, 0x3e, 0x46, 0xfe, + 0xb0, 0x8a, 0x46, 0xfe, 0xb0, 0x6a, 0x46, 0xfe, 0xb0, 0x6a, 0x46, 0xfe, + 0xb0, 0xa0, 0x46, 0xfe, 0xb0, 0x80, 0x46, 0xfe, 0xb0, 0xb0, 0x46, 0xfe, + 0xb0, 0x3c, 0xa5, 0xf2, 0xf0, 0x17, 0x30, 0x27, 0x4a, 0xb0, 0x13, 0x4a, + 0xb0, 0x5d, 0x4a, 0xb0, 0x5a, 0x4a, 0xb0, 0x8d, 0x4a, 0xb0, 0x07, 0x4a, + 0xb0, 0x99, 0x4a, 0xb0, 0x26, 0x60, 0x4c, 0x2c, 0xf5, 0x4c, 0x68, 0xf5, + 0xa9, 0x38, 0x8d, 0xbd, 0x07, 0xa0, 0xc4, 0xa9, 0x18, 0xd0, 0x0b, 0xad, + 0xbd, 0x07, 0xc9, 0x08, 0xd0, 0x8e, 0xa0, 0xa4, 0xa9, 0x5a, 0xa2, 0x9f, + 0xd0, 0x83, 0xa9, 0x30, 0x8d, 0xbd, 0x07, 0xad, 0xbd, 0x07, 0xa2, 0x03, + 0x4a, 0xb0, 0xd6, 0xca, 0xd0, 0xfa, 0xa8, 0xb9, 0xd3, 0xf4, 0xa2, 0x82, + 0xa0, 0x7f, 0xd0, 0xe4, 0xa9, 0x10, 0xd0, 0x02, 0xa9, 0x20, 0x8d, 0xbd, + 0x07, 0xa9, 0x7f, 0x8d, 0x05, 0x40, 0xa9, 0x00, 0x8d, 0xbe, 0x07, 0xee, + 0xbe, 0x07, 0xad, 0xbe, 0x07, 0x4a, 0xa8, 0xcc, 0xbd, 0x07, 0xf0, 0x0c, + 0xa9, 0x9d, 0x8d, 0x04, 0x40, 0xb9, 0xf8, 0xf4, 0x20, 0xa9, 0xf3, 0x60, + 0x4c, 0x6d, 0xf5, 0x01, 0x0e, 0x0e, 0x0d, 0x0b, 0x06, 0x0c, 0x0f, 0x0a, + 0x09, 0x03, 0x0d, 0x08, 0x0d, 0x06, 0x0c, 0xa9, 0x20, 0x8d, 0xbf, 0x07, + 0xad, 0xbf, 0x07, 0x4a, 0x90, 0x12, 0xa8, 0xbe, 0x2b, 0xf6, 0xb9, 0xea, + 0xff, 0x8d, 0x0c, 0x40, 0x8e, 0x0e, 0x40, 0xa9, 0x18, 0x8d, 0x0f, 0x40, + 0xce, 0xbf, 0x07, 0xd0, 0x09, 0xa9, 0xf0, 0x8d, 0x0c, 0x40, 0xa9, 0x00, + 0x85, 0xf3, 0x60, 0xa4, 0xfd, 0xf0, 0x0a, 0x84, 0xf3, 0x46, 0xfd, 0xb0, + 0xca, 0x46, 0xfd, 0xb0, 0x0b, 0xa5, 0xf3, 0xf0, 0x06, 0x4a, 0xb0, 0xc4, + 0x4a, 0xb0, 0x06, 0x60, 0xa9, 0x40, 0x8d, 0xbf, 0x07, 0xad, 0xbf, 0x07, + 0x4a, 0xa8, 0xa2, 0x0f, 0xb9, 0xc9, 0xff, 0xd0, 0xbc, 0x4c, 0x3a, 0xf7, + 0xa5, 0xfc, 0xd0, 0x0c, 0xa5, 0xfb, 0xd0, 0x2c, 0xad, 0xb1, 0x07, 0x05, + 0xf4, 0xd0, 0xee, 0x60, 0x8d, 0xb1, 0x07, 0xc9, 0x01, 0xd0, 0x06, 0x20, + 0xa7, 0xf4, 0x20, 0x71, 0xf5, 0xa6, 0xf4, 0x8e, 0xc5, 0x07, 0xa0, 0x00, + 0x8c, 0xc4, 0x07, 0x84, 0xf4, 0xc9, 0x40, 0xd0, 0x30, 0xa2, 0x08, 0x8e, + 0xc4, 0x07, 0xd0, 0x29, 0xc9, 0x04, 0xd0, 0x03, 0x20, 0xa7, 0xf4, 0xa0, + 0x10, 0x8c, 0xc7, 0x07, 0xa0, 0x00, 0x8c, 0xb1, 0x07, 0x85, 0xf4, 0xc9, + 0x01, 0xd0, 0x0e, 0xee, 0xc7, 0x07, 0xac, 0xc7, 0x07, 0xc0, 0x32, 0xd0, + 0x0c, 0xa0, 0x11, 0xd0, 0xe4, 0xa0, 0x08, 0x84, 0xf7, 0xc8, 0x4a, 0x90, + 0xfc, 0xb9, 0x0c, 0xf9, 0xa8, 0xb9, 0x0d, 0xf9, 0x85, 0xf0, 0xb9, 0x0e, + 0xf9, 0x85, 0xf5, 0xb9, 0x0f, 0xf9, 0x85, 0xf6, 0xb9, 0x10, 0xf9, 0x85, + 0xf9, 0xb9, 0x11, 0xf9, 0x85, 0xf8, 0xb9, 0x12, 0xf9, 0x8d, 0xb0, 0x07, + 0x8d, 0xc1, 0x07, 0xa9, 0x01, 0x8d, 0xb4, 0x07, 0x8d, 0xb6, 0x07, 0x8d, + 0xb9, 0x07, 0x8d, 0xba, 0x07, 0xa9, 0x00, 0x85, 0xf7, 0x8d, 0xca, 0x07, + 0xa9, 0x0b, 0x8d, 0x15, 0x40, 0xa9, 0x0f, 0x8d, 0x15, 0x40, 0xce, 0xb4, + 0x07, 0xd0, 0x5f, 0xa4, 0xf7, 0xe6, 0xf7, 0xb1, 0xf5, 0xf0, 0x04, 0x10, + 0x3d, 0xd0, 0x2f, 0xad, 0xb1, 0x07, 0xc9, 0x40, 0xd0, 0x05, 0xad, 0xc5, + 0x07, 0xd0, 0x1d, 0x29, 0x04, 0xd0, 0x1c, 0xa5, 0xf4, 0x29, 0x5f, 0xd0, + 0x13, 0xa9, 0x00, 0x85, 0xf4, 0x8d, 0xb1, 0x07, 0x8d, 0x08, 0x40, 0xa9, + 0x90, 0x8d, 0x00, 0x40, 0x8d, 0x04, 0x40, 0x60, 0x4c, 0xd4, 0xf6, 0x4c, + 0xa4, 0xf6, 0x20, 0xcb, 0xf8, 0x8d, 0xb3, 0x07, 0xa4, 0xf7, 0xe6, 0xf7, + 0xb1, 0xf5, 0xa6, 0xf2, 0xd0, 0x0e, 0x20, 0xa9, 0xf3, 0xf0, 0x03, 0x20, + 0xd8, 0xf8, 0x8d, 0xb5, 0x07, 0x20, 0x9f, 0xf3, 0xad, 0xb3, 0x07, 0x8d, + 0xb4, 0x07, 0xa5, 0xf2, 0xd0, 0x1a, 0xad, 0xb1, 0x07, 0x29, 0x91, 0xd0, + 0x13, 0xac, 0xb5, 0x07, 0xf0, 0x03, 0xce, 0xb5, 0x07, 0x20, 0xf4, 0xf8, + 0x8d, 0x04, 0x40, 0xa2, 0x7f, 0x8e, 0x05, 0x40, 0xa4, 0xf8, 0xf0, 0x5a, + 0xce, 0xb6, 0x07, 0xd0, 0x32, 0xa4, 0xf8, 0xe6, 0xf8, 0xb1, 0xf5, 0xd0, + 0x0f, 0xa9, 0x83, 0x8d, 0x00, 0x40, 0xa9, 0x94, 0x8d, 0x01, 0x40, 0x8d, + 0xca, 0x07, 0xd0, 0xe9, 0x20, 0xc5, 0xf8, 0x8d, 0xb6, 0x07, 0xa4, 0xf1, + 0xd0, 0x34, 0x8a, 0x29, 0x3e, 0x20, 0x8b, 0xf3, 0xf0, 0x03, 0x20, 0xd8, + 0xf8, 0x8d, 0xb7, 0x07, 0x20, 0x81, 0xf3, 0xa5, 0xf1, 0xd0, 0x1f, 0xad, + 0xb1, 0x07, 0x29, 0x91, 0xd0, 0x0e, 0xac, 0xb7, 0x07, 0xf0, 0x03, 0xce, + 0xb7, 0x07, 0x20, 0xf4, 0xf8, 0x8d, 0x00, 0x40, 0xad, 0xca, 0x07, 0xd0, + 0x02, 0xa9, 0x7f, 0x8d, 0x01, 0x40, 0xa5, 0xf9, 0xce, 0xb9, 0x07, 0xd0, + 0x4c, 0xa4, 0xf9, 0xe6, 0xf9, 0xb1, 0xf5, 0xf0, 0x41, 0x10, 0x13, 0x20, + 0xcb, 0xf8, 0x8d, 0xb8, 0x07, 0xa9, 0x1f, 0x8d, 0x08, 0x40, 0xa4, 0xf9, + 0xe6, 0xf9, 0xb1, 0xf5, 0xf0, 0x2c, 0x20, 0xad, 0xf3, 0xae, 0xb8, 0x07, + 0x8e, 0xb9, 0x07, 0xad, 0xb1, 0x07, 0x29, 0x6e, 0xd0, 0x06, 0xa5, 0xf4, + 0x29, 0x0a, 0xf0, 0x19, 0x8a, 0xc9, 0x12, 0xb0, 0x0f, 0xad, 0xb1, 0x07, + 0x29, 0x08, 0xf0, 0x04, 0xa9, 0x0f, 0xd0, 0x06, 0xa9, 0x1f, 0xd0, 0x02, + 0xa9, 0xff, 0x8d, 0x08, 0x40, 0xa5, 0xf4, 0x29, 0xf3, 0xf0, 0x51, 0xce, + 0xba, 0x07, 0xd0, 0x4c, 0xac, 0xb0, 0x07, 0xee, 0xb0, 0x07, 0xb1, 0xf5, + 0xd0, 0x08, 0xad, 0xc1, 0x07, 0x8d, 0xb0, 0x07, 0xd0, 0xee, 0x20, 0xc5, + 0xf8, 0x8d, 0xba, 0x07, 0x8a, 0x29, 0x3e, 0xf0, 0x24, 0xc9, 0x30, 0xf0, + 0x18, 0xc9, 0x20, 0xf0, 0x0c, 0x29, 0x10, 0xf0, 0x18, 0xa9, 0x1c, 0xa2, + 0x03, 0xa0, 0x18, 0xd0, 0x12, 0xa9, 0x1c, 0xa2, 0x0c, 0xa0, 0x18, 0xd0, + 0x0a, 0xa9, 0x1c, 0xa2, 0x03, 0xa0, 0x58, 0xd0, 0x02, 0xa9, 0x10, 0x8d, + 0x0c, 0x40, 0x8e, 0x0e, 0x40, 0x8c, 0x0f, 0x40, 0x60, 0xaa, 0x6a, 0x8a, + 0x2a, 0x2a, 0x2a, 0x29, 0x07, 0x18, 0x65, 0xf0, 0x6d, 0xc4, 0x07, 0xa8, + 0xb9, 0x66, 0xff, 0x60, 0xad, 0xb1, 0x07, 0x29, 0x08, 0xf0, 0x04, 0xa9, + 0x04, 0xd0, 0x0c, 0xa5, 0xf4, 0x29, 0x7d, 0xf0, 0x04, 0xa9, 0x08, 0xd0, + 0x02, 0xa9, 0x28, 0xa2, 0x82, 0xa0, 0x7f, 0x60, 0xad, 0xb1, 0x07, 0x29, + 0x08, 0xf0, 0x04, 0xb9, 0x96, 0xff, 0x60, 0xa5, 0xf4, 0x29, 0x7d, 0xf0, + 0x04, 0xb9, 0x9a, 0xff, 0x60, 0xb9, 0xa2, 0xff, 0x60, 0xa5, 0x59, 0x54, + 0x64, 0x59, 0x3c, 0x31, 0x4b, 0x69, 0x5e, 0x46, 0x4f, 0x36, 0x8d, 0x36, + 0x4b, 0x8d, 0x69, 0x69, 0x6f, 0x75, 0x6f, 0x7b, 0x6f, 0x75, 0x6f, 0x7b, + 0x81, 0x87, 0x81, 0x8d, 0x69, 0x69, 0x93, 0x99, 0x93, 0x9f, 0x93, 0x99, + 0x93, 0x9f, 0x81, 0x87, 0x81, 0x8d, 0x93, 0x99, 0x93, 0x9f, 0x08, 0x72, + 0xfc, 0x27, 0x18, 0x20, 0xb8, 0xf9, 0x2e, 0x1a, 0x40, 0x20, 0xb0, 0xfc, + 0x3d, 0x21, 0x20, 0xc4, 0xfc, 0x3f, 0x1d, 0x18, 0x11, 0xfd, 0x00, 0x00, + 0x08, 0x1c, 0xfa, 0x00, 0x00, 0xa4, 0xfb, 0x93, 0x62, 0x10, 0xc8, 0xfe, + 0x24, 0x14, 0x18, 0x45, 0xfc, 0x1e, 0x14, 0x08, 0x52, 0xfd, 0xa0, 0x70, + 0x68, 0x08, 0x51, 0xfe, 0x4c, 0x24, 0x18, 0x01, 0xfa, 0x2d, 0x1c, 0xb8, + 0x18, 0x49, 0xfa, 0x20, 0x12, 0x70, 0x18, 0x75, 0xfa, 0x1b, 0x10, 0x44, + 0x18, 0x9d, 0xfa, 0x11, 0x0a, 0x1c, 0x18, 0xc2, 0xfa, 0x2d, 0x10, 0x58, + 0x18, 0xdb, 0xfa, 0x14, 0x0d, 0x3f, 0x18, 0xf9, 0xfa, 0x15, 0x0d, 0x21, + 0x18, 0x25, 0xfb, 0x18, 0x10, 0x7a, 0x18, 0x4b, 0xfb, 0x19, 0x0f, 0x54, + 0x18, 0x74, 0xfb, 0x1e, 0x12, 0x2b, 0x18, 0x72, 0xfb, 0x1e, 0x0f, 0x2d, + 0x84, 0x2c, 0x2c, 0x2c, 0x82, 0x04, 0x2c, 0x04, 0x85, 0x2c, 0x84, 0x2c, + 0x2c, 0x2a, 0x2a, 0x2a, 0x82, 0x04, 0x2a, 0x04, 0x85, 0x2a, 0x84, 0x2a, + 0x2a, 0x00, 0x1f, 0x1f, 0x1f, 0x98, 0x1f, 0x1f, 0x98, 0x9e, 0x98, 0x1f, + 0x1d, 0x1d, 0x1d, 0x94, 0x1d, 0x1d, 0x94, 0x9c, 0x94, 0x1d, 0x86, 0x18, + 0x85, 0x26, 0x30, 0x84, 0x04, 0x26, 0x30, 0x86, 0x14, 0x85, 0x22, 0x2c, + 0x84, 0x04, 0x22, 0x2c, 0x21, 0xd0, 0xc4, 0xd0, 0x31, 0xd0, 0xc4, 0xd0, + 0x00, 0x85, 0x2c, 0x22, 0x1c, 0x84, 0x26, 0x2a, 0x82, 0x28, 0x26, 0x04, + 0x87, 0x22, 0x34, 0x3a, 0x82, 0x40, 0x04, 0x36, 0x84, 0x3a, 0x34, 0x82, + 0x2c, 0x30, 0x85, 0x2a, 0x00, 0x5d, 0x55, 0x4d, 0x15, 0x19, 0x96, 0x15, + 0xd5, 0xe3, 0xeb, 0x2d, 0xa6, 0x2b, 0x27, 0x9c, 0x9e, 0x59, 0x85, 0x22, + 0x1c, 0x14, 0x84, 0x1e, 0x22, 0x82, 0x20, 0x1e, 0x04, 0x87, 0x1c, 0x2c, + 0x34, 0x82, 0x36, 0x04, 0x30, 0x34, 0x04, 0x2c, 0x04, 0x26, 0x2a, 0x85, + 0x22, 0x84, 0x04, 0x82, 0x3a, 0x38, 0x36, 0x32, 0x04, 0x34, 0x04, 0x24, + 0x26, 0x2c, 0x04, 0x26, 0x2c, 0x30, 0x00, 0x05, 0xb4, 0xb2, 0xb0, 0x2b, + 0xac, 0x84, 0x9c, 0x9e, 0xa2, 0x84, 0x94, 0x9c, 0x9e, 0x85, 0x14, 0x22, + 0x84, 0x2c, 0x85, 0x1e, 0x82, 0x2c, 0x84, 0x2c, 0x1e, 0x84, 0x04, 0x82, + 0x3a, 0x38, 0x36, 0x32, 0x04, 0x34, 0x04, 0x64, 0x04, 0x64, 0x86, 0x64, + 0x00, 0x05, 0xb4, 0xb2, 0xb0, 0x2b, 0xac, 0x84, 0x37, 0xb6, 0xb6, 0x45, + 0x85, 0x14, 0x1c, 0x82, 0x22, 0x84, 0x2c, 0x4e, 0x82, 0x4e, 0x84, 0x4e, + 0x22, 0x84, 0x04, 0x85, 0x32, 0x85, 0x30, 0x86, 0x2c, 0x04, 0x00, 0x05, + 0xa4, 0x05, 0x9e, 0x05, 0x9d, 0x85, 0x84, 0x14, 0x85, 0x24, 0x28, 0x2c, + 0x82, 0x22, 0x84, 0x22, 0x14, 0x21, 0xd0, 0xc4, 0xd0, 0x31, 0xd0, 0xc4, + 0xd0, 0x00, 0x82, 0x2c, 0x84, 0x2c, 0x2c, 0x82, 0x2c, 0x30, 0x04, 0x34, + 0x2c, 0x04, 0x26, 0x86, 0x22, 0x00, 0xa4, 0x25, 0x25, 0xa4, 0x29, 0xa2, + 0x1d, 0x9c, 0x95, 0x82, 0x2c, 0x2c, 0x04, 0x2c, 0x04, 0x2c, 0x30, 0x85, + 0x34, 0x04, 0x04, 0x00, 0xa4, 0x25, 0x25, 0xa4, 0xa8, 0x63, 0x04, 0x85, + 0x0e, 0x1a, 0x84, 0x24, 0x85, 0x22, 0x14, 0x84, 0x0c, 0x82, 0x34, 0x84, + 0x34, 0x34, 0x82, 0x2c, 0x84, 0x34, 0x86, 0x3a, 0x04, 0x00, 0xa0, 0x21, + 0x21, 0xa0, 0x21, 0x2b, 0x05, 0xa3, 0x82, 0x18, 0x84, 0x18, 0x18, 0x82, + 0x18, 0x18, 0x04, 0x86, 0x3a, 0x22, 0x31, 0x90, 0x31, 0x90, 0x31, 0x71, + 0x31, 0x90, 0x90, 0x90, 0x00, 0x82, 0x34, 0x84, 0x2c, 0x85, 0x22, 0x84, + 0x24, 0x82, 0x26, 0x36, 0x04, 0x36, 0x86, 0x26, 0x00, 0xac, 0x27, 0x5d, + 0x1d, 0x9e, 0x2d, 0xac, 0x9f, 0x85, 0x14, 0x82, 0x20, 0x84, 0x22, 0x2c, + 0x1e, 0x1e, 0x82, 0x2c, 0x2c, 0x1e, 0x04, 0x87, 0x2a, 0x40, 0x40, 0x40, + 0x3a, 0x36, 0x82, 0x34, 0x2c, 0x04, 0x26, 0x86, 0x22, 0x00, 0xe3, 0xf7, + 0xf7, 0xf7, 0xf5, 0xf1, 0xac, 0x27, 0x9e, 0x9d, 0x85, 0x18, 0x82, 0x1e, + 0x84, 0x22, 0x2a, 0x22, 0x22, 0x82, 0x2c, 0x2c, 0x22, 0x04, 0x86, 0x04, + 0x82, 0x2a, 0x36, 0x04, 0x36, 0x87, 0x36, 0x34, 0x30, 0x86, 0x2c, 0x04, + 0x00, 0x00, 0x68, 0x6a, 0x6c, 0x45, 0xa2, 0x31, 0xb0, 0xf1, 0xed, 0xeb, + 0xa2, 0x1d, 0x9c, 0x95, 0x86, 0x04, 0x85, 0x22, 0x82, 0x22, 0x87, 0x22, + 0x26, 0x2a, 0x84, 0x2c, 0x22, 0x86, 0x14, 0x51, 0x90, 0x31, 0x11, 0x00, + 0x80, 0x22, 0x28, 0x22, 0x26, 0x22, 0x24, 0x22, 0x26, 0x22, 0x28, 0x22, + 0x2a, 0x22, 0x28, 0x22, 0x26, 0x22, 0x28, 0x22, 0x26, 0x22, 0x24, 0x22, + 0x26, 0x22, 0x28, 0x22, 0x2a, 0x22, 0x28, 0x22, 0x26, 0x20, 0x26, 0x20, + 0x24, 0x20, 0x26, 0x20, 0x28, 0x20, 0x26, 0x20, 0x28, 0x20, 0x26, 0x20, + 0x24, 0x20, 0x26, 0x20, 0x24, 0x20, 0x26, 0x20, 0x28, 0x20, 0x26, 0x20, + 0x28, 0x20, 0x26, 0x20, 0x24, 0x28, 0x30, 0x28, 0x32, 0x28, 0x30, 0x28, + 0x2e, 0x28, 0x30, 0x28, 0x2e, 0x28, 0x2c, 0x28, 0x2e, 0x28, 0x30, 0x28, + 0x32, 0x28, 0x30, 0x28, 0x2e, 0x28, 0x30, 0x28, 0x2e, 0x28, 0x2c, 0x28, + 0x2e, 0x00, 0x04, 0x70, 0x6e, 0x6c, 0x6e, 0x70, 0x72, 0x70, 0x6e, 0x70, + 0x6e, 0x6c, 0x6e, 0x70, 0x72, 0x70, 0x6e, 0x6e, 0x6c, 0x6e, 0x70, 0x6e, + 0x70, 0x6e, 0x6c, 0x6e, 0x6c, 0x6e, 0x70, 0x6e, 0x70, 0x6e, 0x6c, 0x76, + 0x78, 0x76, 0x74, 0x76, 0x74, 0x72, 0x74, 0x76, 0x78, 0x76, 0x74, 0x76, + 0x74, 0x72, 0x74, 0x84, 0x1a, 0x83, 0x18, 0x20, 0x84, 0x1e, 0x83, 0x1c, + 0x28, 0x26, 0x1c, 0x1a, 0x1c, 0x82, 0x2c, 0x04, 0x04, 0x22, 0x04, 0x04, + 0x84, 0x1c, 0x87, 0x26, 0x2a, 0x26, 0x84, 0x24, 0x28, 0x24, 0x80, 0x22, + 0x00, 0x9c, 0x05, 0x94, 0x05, 0x0d, 0x9f, 0x1e, 0x9c, 0x98, 0x9d, 0x82, + 0x22, 0x04, 0x04, 0x1c, 0x04, 0x04, 0x84, 0x14, 0x86, 0x1e, 0x80, 0x16, + 0x80, 0x14, 0x81, 0x1c, 0x30, 0x04, 0x30, 0x30, 0x04, 0x1e, 0x32, 0x04, + 0x32, 0x32, 0x04, 0x20, 0x34, 0x04, 0x34, 0x34, 0x04, 0x36, 0x04, 0x84, + 0x36, 0x00, 0x46, 0xa4, 0x64, 0xa4, 0x48, 0xa6, 0x66, 0xa6, 0x4a, 0xa8, + 0x68, 0xa8, 0x6a, 0x44, 0x2b, 0x81, 0x2a, 0x42, 0x04, 0x42, 0x42, 0x04, + 0x2c, 0x64, 0x04, 0x64, 0x64, 0x04, 0x2e, 0x46, 0x04, 0x46, 0x46, 0x04, + 0x22, 0x04, 0x84, 0x22, 0x87, 0x04, 0x06, 0x0c, 0x14, 0x1c, 0x22, 0x86, + 0x2c, 0x22, 0x87, 0x04, 0x60, 0x0e, 0x14, 0x1a, 0x24, 0x86, 0x2c, 0x24, + 0x87, 0x04, 0x08, 0x10, 0x18, 0x1e, 0x28, 0x86, 0x30, 0x30, 0x80, 0x64, + 0x00, 0xcd, 0xd5, 0xdd, 0xe3, 0xed, 0xf5, 0xbb, 0xb5, 0xcf, 0xd5, 0xdb, + 0xe5, 0xed, 0xf3, 0xbd, 0xb3, 0xd1, 0xd9, 0xdf, 0xe9, 0xf1, 0xf7, 0xbf, + 0xff, 0xff, 0xff, 0x34, 0x00, 0x86, 0x04, 0x87, 0x14, 0x1c, 0x22, 0x86, + 0x34, 0x84, 0x2c, 0x04, 0x04, 0x04, 0x87, 0x14, 0x1a, 0x24, 0x86, 0x32, + 0x84, 0x2c, 0x04, 0x86, 0x04, 0x87, 0x18, 0x1e, 0x28, 0x86, 0x36, 0x87, + 0x30, 0x30, 0x30, 0x80, 0x2c, 0x82, 0x14, 0x2c, 0x62, 0x26, 0x10, 0x28, + 0x80, 0x04, 0x82, 0x14, 0x2c, 0x62, 0x26, 0x10, 0x28, 0x80, 0x04, 0x82, + 0x08, 0x1e, 0x5e, 0x18, 0x60, 0x1a, 0x80, 0x04, 0x82, 0x08, 0x1e, 0x5e, + 0x18, 0x60, 0x1a, 0x86, 0x04, 0x83, 0x1a, 0x18, 0x16, 0x84, 0x14, 0x1a, + 0x18, 0x0e, 0x0c, 0x16, 0x83, 0x14, 0x20, 0x1e, 0x1c, 0x28, 0x26, 0x87, + 0x24, 0x1a, 0x12, 0x10, 0x62, 0x0e, 0x80, 0x04, 0x04, 0x00, 0x82, 0x18, + 0x1c, 0x20, 0x22, 0x26, 0x28, 0x81, 0x2a, 0x2a, 0x2a, 0x04, 0x2a, 0x04, + 0x83, 0x2a, 0x82, 0x22, 0x86, 0x34, 0x32, 0x34, 0x81, 0x04, 0x22, 0x26, + 0x2a, 0x2c, 0x30, 0x86, 0x34, 0x83, 0x32, 0x82, 0x36, 0x84, 0x34, 0x85, + 0x04, 0x81, 0x22, 0x86, 0x30, 0x2e, 0x30, 0x81, 0x04, 0x22, 0x26, 0x2a, + 0x2c, 0x2e, 0x86, 0x30, 0x83, 0x22, 0x82, 0x36, 0x84, 0x34, 0x85, 0x04, + 0x81, 0x22, 0x86, 0x3a, 0x3a, 0x3a, 0x82, 0x3a, 0x81, 0x40, 0x82, 0x04, + 0x81, 0x3a, 0x86, 0x36, 0x36, 0x36, 0x82, 0x36, 0x81, 0x3a, 0x82, 0x04, + 0x81, 0x36, 0x86, 0x34, 0x82, 0x26, 0x2a, 0x36, 0x81, 0x34, 0x34, 0x85, + 0x34, 0x81, 0x2a, 0x86, 0x2c, 0x00, 0x84, 0x90, 0xb0, 0x84, 0x50, 0x50, + 0xb0, 0x00, 0x98, 0x96, 0x94, 0x92, 0x94, 0x96, 0x58, 0x58, 0x58, 0x44, + 0x5c, 0x44, 0x9f, 0xa3, 0xa1, 0xa3, 0x85, 0xa3, 0xe0, 0xa6, 0x23, 0xc4, + 0x9f, 0x9d, 0x9f, 0x85, 0x9f, 0xd2, 0xa6, 0x23, 0xc4, 0xb5, 0xb1, 0xaf, + 0x85, 0xb1, 0xaf, 0xad, 0x85, 0x95, 0x9e, 0xa2, 0xaa, 0x6a, 0x6a, 0x6b, + 0x5e, 0x9d, 0x84, 0x04, 0x04, 0x82, 0x22, 0x86, 0x22, 0x82, 0x14, 0x22, + 0x2c, 0x12, 0x22, 0x2a, 0x14, 0x22, 0x2c, 0x1c, 0x22, 0x2c, 0x14, 0x22, + 0x2c, 0x12, 0x22, 0x2a, 0x14, 0x22, 0x2c, 0x1c, 0x22, 0x2c, 0x18, 0x22, + 0x2a, 0x16, 0x20, 0x28, 0x18, 0x22, 0x2a, 0x12, 0x22, 0x2a, 0x18, 0x22, + 0x2a, 0x12, 0x22, 0x2a, 0x14, 0x22, 0x2c, 0x0c, 0x22, 0x2c, 0x14, 0x22, + 0x34, 0x12, 0x22, 0x30, 0x10, 0x22, 0x2e, 0x16, 0x22, 0x34, 0x18, 0x26, + 0x36, 0x16, 0x26, 0x36, 0x14, 0x26, 0x36, 0x12, 0x22, 0x36, 0x5c, 0x22, + 0x34, 0x0c, 0x22, 0x22, 0x81, 0x1e, 0x1e, 0x85, 0x1e, 0x81, 0x12, 0x86, + 0x14, 0x81, 0x2c, 0x22, 0x1c, 0x2c, 0x22, 0x1c, 0x85, 0x2c, 0x04, 0x81, + 0x2e, 0x24, 0x1e, 0x2e, 0x24, 0x1e, 0x85, 0x2e, 0x04, 0x81, 0x32, 0x28, + 0x22, 0x32, 0x28, 0x22, 0x85, 0x32, 0x87, 0x36, 0x36, 0x36, 0x84, 0x3a, + 0x00, 0x5c, 0x54, 0x4c, 0x5c, 0x54, 0x4c, 0x5c, 0x1c, 0x1c, 0x5c, 0x5c, + 0x5c, 0x5c, 0x5e, 0x56, 0x4e, 0x5e, 0x56, 0x4e, 0x5e, 0x1e, 0x1e, 0x5e, + 0x5e, 0x5e, 0x5e, 0x62, 0x5a, 0x50, 0x62, 0x5a, 0x50, 0x62, 0x22, 0x22, + 0x62, 0xe7, 0xe7, 0xe7, 0x2b, 0x86, 0x14, 0x81, 0x14, 0x80, 0x14, 0x14, + 0x81, 0x14, 0x14, 0x14, 0x14, 0x86, 0x16, 0x81, 0x16, 0x80, 0x16, 0x16, + 0x81, 0x16, 0x16, 0x16, 0x16, 0x81, 0x28, 0x22, 0x1a, 0x28, 0x22, 0x1a, + 0x28, 0x80, 0x28, 0x28, 0x81, 0x28, 0x87, 0x2c, 0x2c, 0x2c, 0x84, 0x30, + 0x83, 0x04, 0x84, 0x0c, 0x83, 0x62, 0x10, 0x84, 0x12, 0x83, 0x1c, 0x22, + 0x1e, 0x22, 0x26, 0x18, 0x1e, 0x04, 0x1c, 0x00, 0xe3, 0xe1, 0xe3, 0x1d, + 0xde, 0xe0, 0x23, 0xec, 0x75, 0x74, 0xf0, 0xf4, 0xf6, 0xea, 0x31, 0x2d, + 0x83, 0x12, 0x14, 0x04, 0x18, 0x1a, 0x1c, 0x14, 0x26, 0x22, 0x1e, 0x1c, + 0x18, 0x1e, 0x22, 0x0c, 0x14, 0xff, 0xff, 0xff, 0x00, 0x88, 0x00, 0x2f, + 0x00, 0x00, 0x02, 0xa6, 0x02, 0x80, 0x02, 0x5c, 0x02, 0x3a, 0x02, 0x1a, + 0x01, 0xdf, 0x01, 0xc4, 0x01, 0xab, 0x01, 0x93, 0x01, 0x7c, 0x01, 0x67, + 0x01, 0x53, 0x01, 0x40, 0x01, 0x2e, 0x01, 0x1d, 0x01, 0x0d, 0x00, 0xfe, + 0x00, 0xef, 0x00, 0xe2, 0x00, 0xd5, 0x00, 0xc9, 0x00, 0xbe, 0x00, 0xb3, + 0x00, 0xa9, 0x00, 0xa0, 0x00, 0x97, 0x00, 0x8e, 0x00, 0x86, 0x00, 0x77, + 0x00, 0x7e, 0x00, 0x71, 0x00, 0x54, 0x00, 0x64, 0x00, 0x5f, 0x00, 0x59, + 0x00, 0x50, 0x00, 0x47, 0x00, 0x43, 0x00, 0x3b, 0x00, 0x35, 0x00, 0x2a, + 0x00, 0x23, 0x04, 0x75, 0x03, 0x57, 0x02, 0xf9, 0x02, 0xcf, 0x01, 0xfc, + 0x00, 0x6a, 0x05, 0x0a, 0x14, 0x28, 0x50, 0x1e, 0x3c, 0x02, 0x04, 0x08, + 0x10, 0x20, 0x40, 0x18, 0x30, 0x0c, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x12, + 0x24, 0x08, 0x36, 0x03, 0x09, 0x06, 0x12, 0x1b, 0x24, 0x0c, 0x24, 0x02, + 0x06, 0x04, 0x0c, 0x12, 0x18, 0x08, 0x12, 0x01, 0x03, 0x02, 0x06, 0x09, + 0x0c, 0x04, 0x98, 0x99, 0x9a, 0x9b, 0x90, 0x94, 0x94, 0x95, 0x95, 0x96, + 0x97, 0x98, 0x90, 0x91, 0x92, 0x92, 0x93, 0x93, 0x93, 0x94, 0x94, 0x94, + 0x94, 0x94, 0x94, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x96, 0x96, 0x96, + 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, 0x96, + 0x96, 0x96, 0x95, 0x95, 0x94, 0x93, 0x15, 0x16, 0x16, 0x17, 0x17, 0x18, + 0x19, 0x19, 0x1a, 0x1a, 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f, 0x1f, 0x1f, + 0x1f, 0x1e, 0x1d, 0x1c, 0x1e, 0x1f, 0x1f, 0x1e, 0x1d, 0x1c, 0x1a, 0x18, + 0x16, 0x14, 0x15, 0x16, 0x16, 0x17, 0x17, 0x18, 0x19, 0x19, 0x1a, 0x1a, + 0x1c, 0x1d, 0x1d, 0x1e, 0x1e, 0x1f, 0x82, 0x80, 0x00, 0x80, 0xf0, 0xff, + 0x03, 0x0f, 0x1f, 0x1f, 0x1c, 0x24, 0x26, 0x66, 0x00, 0x00, 0x00, 0x00, + 0x1f, 0x3f, 0x3f, 0x7f, 0xe0, 0xc0, 0x80, 0xfc, 0x80, 0xc0, 0x00, 0x20, + 0x00, 0x20, 0x60, 0x00, 0xf0, 0xfc, 0xfe, 0xfe, 0x60, 0x70, 0x18, 0x07, + 0x0f, 0x1f, 0x3f, 0x7f, 0x7f, 0x7f, 0x1f, 0x07, 0x00, 0x1e, 0x3f, 0x7f, + 0xfc, 0x7c, 0x00, 0x00, 0xe0, 0xf0, 0xf8, 0xf8, 0xfc, 0xfc, 0xf8, 0xc0, + 0xc2, 0x67, 0x2f, 0x37, 0x7f, 0x7f, 0xff, 0xff, 0x07, 0x07, 0x0f, 0x0f, + 0x7f, 0x7e, 0xfc, 0xf0, 0xf8, 0xf8, 0xf0, 0x70, 0xfd, 0xfe, 0xb4, 0xf8, + 0xf8, 0xf9, 0xfb, 0xff, 0x37, 0x36, 0x5c, 0x00, 0x00, 0x01, 0x03, 0x1f, + 0x1f, 0x3f, 0xff, 0xff, 0xfc, 0x70, 0x70, 0x38, 0x08, 0x24, 0xe3, 0xf0, + 0xf8, 0x70, 0x70, 0x38, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00, 0x00, + 0x1f, 0x1f, 0x1f, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x07, + 0x0f, 0x0f, 0x0e, 0x12, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x1f, + 0x00, 0x00, 0xf0, 0xe0, 0xc0, 0xfe, 0x40, 0x60, 0x00, 0x00, 0x00, 0x10, + 0x30, 0x00, 0xf8, 0xfe, 0x13, 0x33, 0x30, 0x18, 0x04, 0x0f, 0x1f, 0x1f, + 0x1f, 0x3f, 0x3f, 0x1f, 0x07, 0x08, 0x17, 0x17, 0x00, 0x10, 0x7e, 0x3e, + 0x00, 0x00, 0xc0, 0xe0, 0xff, 0xff, 0xfe, 0xfe, 0xfc, 0xe0, 0x40, 0xa0, + 0x3f, 0x3f, 0x3f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x37, 0x27, 0x23, 0x03, + 0x01, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf0, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, + 0xcc, 0xff, 0xff, 0xff, 0xff, 0x70, 0x00, 0x08, 0xff, 0xff, 0xff, 0xfe, + 0xf0, 0xc0, 0x80, 0x00, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xc0, 0x80, 0x00, + 0xfc, 0xfc, 0xf8, 0x78, 0x78, 0x78, 0x7e, 0x7e, 0x10, 0x60, 0x80, 0x00, + 0x78, 0x78, 0x7e, 0x7e, 0x00, 0x03, 0x0f, 0x1f, 0x1f, 0x1c, 0x24, 0x26, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x3f, 0x3f, 0x00, 0xe0, 0xc0, 0x80, + 0xfc, 0x80, 0xc0, 0x00, 0x00, 0x00, 0x20, 0x60, 0x00, 0xf0, 0xfc, 0xfe, + 0x66, 0x60, 0x30, 0x18, 0x0f, 0x1f, 0x3f, 0x3f, 0x7f, 0x7f, 0x3f, 0x1f, + 0x00, 0x16, 0x2f, 0x2f, 0x20, 0xfc, 0x7c, 0x00, 0x00, 0xe0, 0xe0, 0xf0, + 0xfe, 0xfc, 0xfc, 0xf8, 0xc0, 0x60, 0x20, 0x30, 0x3f, 0x3f, 0x3f, 0x3f, + 0x3f, 0x3f, 0x3f, 0x1f, 0x2f, 0x2f, 0x2f, 0x0f, 0x07, 0x03, 0x00, 0x00, + 0xf0, 0x90, 0x00, 0x08, 0x0c, 0x1c, 0xfc, 0xf8, 0x10, 0xf0, 0xf0, 0xf0, + 0xf0, 0xe0, 0xc0, 0xe0, 0x0f, 0x0f, 0x07, 0x07, 0x07, 0x0f, 0x0f, 0x03, + 0x01, 0x03, 0x01, 0x04, 0x07, 0x0f, 0x0f, 0x03, 0xf8, 0xf0, 0xe0, 0xf0, + 0xb0, 0x80, 0xe0, 0xe0, 0xf8, 0xf0, 0xe0, 0x70, 0xb0, 0x80, 0xe0, 0xe0, + 0x03, 0x3f, 0x7f, 0x19, 0x09, 0x09, 0x28, 0x5c, 0x00, 0x30, 0x70, 0x7f, + 0xff, 0xff, 0xf7, 0xf3, 0xf8, 0xe0, 0xe0, 0xfc, 0x26, 0x30, 0x80, 0x10, + 0x00, 0x18, 0x10, 0x00, 0xf8, 0xf8, 0xfe, 0xff, 0x3e, 0x1e, 0x3f, 0x38, + 0x30, 0x30, 0x00, 0x3a, 0xe7, 0x0f, 0x0f, 0x1f, 0x1f, 0x1f, 0x0f, 0x07, + 0x78, 0x1e, 0x80, 0xfe, 0x7e, 0x7e, 0x7f, 0x7f, 0xff, 0xfe, 0xfc, 0xc6, + 0x8e, 0xee, 0xff, 0xff, 0x3c, 0x3f, 0x1f, 0x0f, 0x07, 0x3f, 0x21, 0x20, + 0x03, 0x00, 0x00, 0x0e, 0x07, 0x3f, 0x3f, 0x3f, 0xff, 0xff, 0xff, 0xfe, + 0xfe, 0xfe, 0xfc, 0x70, 0xff, 0x7f, 0x3f, 0x0e, 0xc0, 0xc0, 0xe0, 0xe0, + 0x0f, 0x9f, 0xcf, 0xff, 0x7f, 0x3f, 0x1e, 0x0e, 0x00, 0x80, 0xc8, 0xfe, + 0x7f, 0x3f, 0x1e, 0x0e, 0x20, 0xc0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, + 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x0f, + 0x1f, 0x1f, 0x1c, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x3f, + 0x00, 0x04, 0xe6, 0xe0, 0xff, 0xff, 0x8f, 0x83, 0x0e, 0x1f, 0x1f, 0x1f, + 0x1f, 0x03, 0xff, 0xff, 0x26, 0x26, 0x60, 0x78, 0x18, 0x0f, 0x7f, 0xff, + 0x3f, 0x3f, 0x7f, 0x7f, 0x1f, 0x00, 0x7e, 0xff, 0x01, 0x21, 0xfe, 0x7a, + 0x06, 0xfe, 0xfc, 0xfc, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xde, 0x5c, 0x6c, + 0xff, 0xcf, 0x87, 0x07, 0x07, 0x0f, 0x1f, 0x1f, 0xff, 0xff, 0xfe, 0xfc, + 0xf8, 0xb0, 0x60, 0x00, 0xf8, 0xf8, 0xf0, 0xb8, 0xf8, 0xf9, 0xfb, 0xff, + 0x28, 0x30, 0x18, 0x40, 0x00, 0x01, 0x03, 0x0f, 0x1f, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xc0, 0x80, 0x10, 0xec, 0xe3, 0xe0, 0xe0, 0xe0, 0xc0, 0x80, + 0xff, 0xff, 0xff, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0f, 0x0f, 0x0f, + 0x00, 0x00, 0x00, 0x00, 0x13, 0x33, 0x30, 0x18, 0x04, 0x0f, 0x1f, 0x1f, + 0x1f, 0x3f, 0x3f, 0x1f, 0x07, 0x09, 0x13, 0x17, 0x00, 0x10, 0x7e, 0x30, + 0xe0, 0xf0, 0xf0, 0xe0, 0xff, 0xff, 0xfe, 0xff, 0xfe, 0xfc, 0xf8, 0xe0, + 0x1f, 0x1f, 0x0f, 0x0f, 0x0f, 0x1f, 0x1f, 0x1f, 0x17, 0x17, 0x03, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf0, 0xf0, 0xf8, 0xf8, 0xb8, 0xf8, 0xf8, 0xf8, + 0xd0, 0x90, 0x18, 0x08, 0x40, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, + 0xf6, 0xc6, 0x84, 0x00, 0x30, 0xf0, 0xf0, 0xf1, 0xf6, 0xc6, 0x84, 0x00, + 0xf0, 0xe0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x1f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x0f, 0x1f, + 0x1f, 0x1f, 0x3f, 0x3e, 0x7c, 0x78, 0xf0, 0xe0, 0xf0, 0xf0, 0xf8, 0xf8, + 0xb8, 0xf8, 0xf8, 0xf0, 0xb0, 0x90, 0x18, 0x08, 0x40, 0x00, 0x00, 0x00, + 0xe0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf8, 0xf0, 0xc0, 0xe0, 0xfc, 0xfe, + 0xff, 0x7f, 0x03, 0x00, 0x1f, 0x1f, 0x1f, 0x3f, 0x3e, 0x3c, 0x38, 0x18, + 0x00, 0x00, 0x10, 0x38, 0x3e, 0x3c, 0x38, 0x18, 0x00, 0x03, 0x07, 0x07, + 0x0a, 0x0b, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x07, 0x0f, 0x0f, 0x0f, 0x03, + 0x00, 0xe0, 0xfc, 0x20, 0x20, 0x10, 0x3c, 0x00, 0x00, 0x00, 0x00, 0xf0, + 0xfc, 0xfe, 0xfc, 0xf8, 0x07, 0x07, 0x07, 0x1f, 0x1f, 0x3e, 0x21, 0x01, + 0x07, 0x0f, 0x1b, 0x18, 0x10, 0x30, 0x21, 0x01, 0xe0, 0xe0, 0xe0, 0xf0, + 0xf0, 0xe0, 0xc0, 0xe0, 0xa8, 0xfc, 0xf8, 0x00, 0x00, 0x00, 0xc0, 0xe0, + 0x07, 0x0f, 0x0e, 0x14, 0x16, 0x18, 0x00, 0x3f, 0x00, 0x00, 0x0f, 0x1f, + 0x1f, 0x1f, 0x07, 0x3c, 0xc0, 0xf8, 0x40, 0x40, 0x20, 0x78, 0x00, 0xc0, + 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0xf8, 0xf0, 0xc0, 0x3f, 0x0e, 0x0f, 0x1f, + 0x3f, 0x7c, 0x70, 0x38, 0xfc, 0xed, 0xc0, 0x00, 0x00, 0x60, 0x70, 0x38, + 0xf0, 0xf8, 0xe4, 0xfc, 0xfc, 0x7c, 0x00, 0x00, 0x7e, 0x1e, 0x04, 0x0c, + 0x0c, 0x0c, 0x00, 0x00, 0x07, 0x0f, 0x0e, 0x14, 0x16, 0x18, 0x00, 0x0f, + 0x00, 0x00, 0x0f, 0x1f, 0x1f, 0x1f, 0x07, 0x0d, 0x1f, 0x1f, 0x1f, 0x1c, + 0x0c, 0x07, 0x07, 0x07, 0x1e, 0x1c, 0x1e, 0x0f, 0x07, 0x00, 0x07, 0x07, + 0xe0, 0x60, 0xf0, 0x70, 0xe0, 0xe0, 0xf0, 0x80, 0x60, 0x90, 0x00, 0x80, + 0x00, 0xe0, 0xf0, 0x80, 0x07, 0x1f, 0x3f, 0x12, 0x13, 0x08, 0x1f, 0x31, + 0x00, 0x10, 0x3f, 0x7f, 0x7f, 0x3f, 0x03, 0x0f, 0xc0, 0xf0, 0x40, 0x00, + 0x30, 0x18, 0xc0, 0xf8, 0x00, 0x00, 0xe0, 0xf8, 0xfc, 0xf8, 0xb0, 0x38, + 0x31, 0x39, 0x1f, 0x1f, 0x0f, 0x5f, 0x7e, 0x3c, 0x1f, 0x07, 0x00, 0x0e, + 0x0f, 0x53, 0x7c, 0x3c, 0xf8, 0xf8, 0xf0, 0xe0, 0xe0, 0xc0, 0x00, 0x00, + 0xf8, 0xf8, 0xf0, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0xe0, 0xfc, 0x27, + 0x27, 0x11, 0x3e, 0x04, 0x07, 0x07, 0x03, 0xf7, 0xff, 0xff, 0xfe, 0xfc, + 0x3f, 0x7f, 0x3f, 0x0f, 0x1f, 0x3f, 0x7f, 0x4f, 0x3e, 0x7f, 0xff, 0xe2, + 0x50, 0x38, 0x70, 0x40, 0xf8, 0xf9, 0xf9, 0xb7, 0xff, 0xff, 0xe0, 0x00, + 0xe8, 0x71, 0x01, 0x4b, 0x03, 0x03, 0x00, 0x00, 0x07, 0x07, 0x0f, 0x3f, + 0x3f, 0x3f, 0x26, 0x04, 0x05, 0x03, 0x01, 0x30, 0x30, 0x30, 0x26, 0x04, + 0xf0, 0xf0, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0xfe, 0xfc, 0xe0, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x07, 0x07, 0x0f, 0x1f, 0x3f, 0x0f, 0x1c, 0x18, + 0x05, 0x03, 0x01, 0x10, 0x30, 0x0c, 0x1c, 0x18, 0xe0, 0xe0, 0xe0, 0xe0, + 0xc0, 0x80, 0x00, 0x00, 0xc0, 0xe0, 0xf0, 0x78, 0x18, 0x08, 0x00, 0x00, + 0x07, 0x0f, 0x1f, 0x0f, 0x3f, 0x0f, 0x1c, 0x18, 0x07, 0x0f, 0x3e, 0x7c, + 0x30, 0x0c, 0x1c, 0x18, 0xe0, 0xe0, 0xe0, 0x40, 0xc0, 0x80, 0x00, 0x00, + 0x60, 0x60, 0x60, 0x80, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xff, 0xff, 0xfb, + 0x0f, 0x0f, 0x0f, 0x1f, 0x73, 0xf3, 0xf0, 0xf4, 0xf0, 0xf0, 0x70, 0x60, + 0x3f, 0x7e, 0x7c, 0x7c, 0x3c, 0x3c, 0xfc, 0xfc, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x3c, 0xfc, 0xfc, 0x60, 0x70, 0x18, 0x08, 0x0f, 0x1f, 0x3f, 0x7f, + 0x7f, 0x7f, 0x1f, 0x07, 0x0b, 0x1b, 0x3b, 0x7b, 0xfc, 0x7c, 0x00, 0x20, + 0xf0, 0xf8, 0xfc, 0xfe, 0xfc, 0xfc, 0xf8, 0xe0, 0xd0, 0xd8, 0xdc, 0xde, + 0x0b, 0x0f, 0x1f, 0x1e, 0x3c, 0x3c, 0x3c, 0x7c, 0xc4, 0xe0, 0xe0, 0x40, + 0x00, 0x3c, 0x3c, 0x7c, 0x1f, 0x3f, 0x0d, 0x07, 0x0f, 0x0e, 0x1c, 0x3c, + 0x1d, 0x3c, 0x3a, 0x38, 0x30, 0x00, 0x1c, 0x3c, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x22, 0x55, 0x55, 0x55, 0x55, 0x55, 0x77, 0x22, + 0x00, 0x07, 0x1f, 0xff, 0x07, 0x1f, 0x0f, 0x06, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0x76, + 0x00, 0x00, 0xcf, 0x07, 0x7f, 0x00, 0x00, 0x00, 0x20, 0xf8, 0xff, 0xc3, + 0xfd, 0xfe, 0xf0, 0x40, 0x00, 0x00, 0x3c, 0xfc, 0xfe, 0xe0, 0x00, 0x00, + 0x40, 0xe0, 0x40, 0x40, 0x41, 0x41, 0x4f, 0x47, 0x40, 0xe0, 0x40, 0x3f, + 0x3e, 0x3e, 0x30, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0xc0, + 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0x18, 0x38, 0x43, 0x46, 0x44, 0x40, + 0x40, 0x40, 0x40, 0x40, 0x3c, 0x39, 0x3b, 0x3f, 0x00, 0x00, 0x00, 0x00, + 0x80, 0xc0, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x38, 0xb8, 0xf8, + 0x00, 0x00, 0x00, 0x00, 0x31, 0x30, 0x38, 0x7c, 0x7f, 0xff, 0xff, 0xfb, + 0x3f, 0x3f, 0x0f, 0x77, 0x77, 0xf7, 0xf7, 0xf7, 0x10, 0x7e, 0x3e, 0x00, + 0x1e, 0xfe, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfa, 0xfa, 0xf3, 0xe7, + 0xff, 0xff, 0xe3, 0xc3, 0x87, 0x48, 0x3c, 0xfc, 0xf0, 0xf8, 0xfc, 0x7c, + 0x78, 0x38, 0x3c, 0xfc, 0x00, 0xff, 0xc3, 0x83, 0x83, 0xff, 0xff, 0xff, + 0xff, 0x00, 0xc3, 0x81, 0x81, 0xc3, 0xff, 0x00, 0x1f, 0x1f, 0x0f, 0x07, + 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xf0, 0xfb, 0xff, 0xff, 0xfe, 0x3e, 0x0c, 0x04, 0x00, 0x0b, 0x1f, 0x1f, + 0x1e, 0x3e, 0x0c, 0x04, 0x1f, 0x1f, 0x0f, 0x0f, 0x07, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb, 0xff, 0xff, 0xff, + 0xff, 0x00, 0x00, 0x00, 0x03, 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x00, + 0x00, 0x18, 0x3c, 0x7e, 0x6e, 0xdf, 0xdf, 0xdf, 0x00, 0x18, 0x3c, 0x7e, + 0x76, 0xfb, 0xfb, 0xfb, 0x00, 0x18, 0x18, 0x3c, 0x3c, 0x3c, 0x3c, 0x1c, + 0x00, 0x10, 0x10, 0x20, 0x20, 0x20, 0x20, 0x20, 0x00, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, + 0x00, 0x08, 0x08, 0x04, 0x04, 0x04, 0x04, 0x04, 0x00, 0x10, 0x10, 0x38, + 0x38, 0x38, 0x38, 0x38, 0x3c, 0x7e, 0x77, 0xfb, 0x9f, 0x5f, 0x8e, 0x20, + 0x00, 0x18, 0x3c, 0x0e, 0x0e, 0x04, 0x00, 0x00, 0x5c, 0x2e, 0x8f, 0x3f, + 0x7b, 0x77, 0x7e, 0x3c, 0x00, 0x00, 0x04, 0x06, 0x1e, 0x3c, 0x18, 0x00, + 0x13, 0x4f, 0x3f, 0xbf, 0x3f, 0x7a, 0xf8, 0xf8, 0x00, 0x00, 0x01, 0x0a, + 0x17, 0x0f, 0x2f, 0x1f, 0x00, 0x08, 0x05, 0x0f, 0x2f, 0x1d, 0x1c, 0x3c, + 0x00, 0x00, 0x00, 0x00, 0x05, 0x07, 0x0f, 0x07, 0x00, 0x00, 0x00, 0x00, + 0x02, 0x0b, 0x07, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x04, 0x04, 0x00, 0x60, 0xf0, 0xf8, + 0x7c, 0x3e, 0x7e, 0x7f, 0x02, 0x02, 0x02, 0x05, 0x71, 0x7f, 0x7f, 0x7f, + 0x3f, 0x5f, 0x7f, 0x3e, 0x0e, 0x0a, 0x51, 0x20, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x1f, + 0x02, 0x02, 0x00, 0x01, 0x13, 0x3f, 0x7f, 0x7f, 0x3f, 0x7f, 0x7f, 0xfe, + 0xec, 0xca, 0x51, 0x20, 0x00, 0x40, 0x60, 0x70, 0x73, 0x27, 0x0f, 0x1f, + 0x00, 0x40, 0x63, 0x77, 0x7c, 0x38, 0xf8, 0xe4, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x07, 0x0f, 0x1f, 0x00, 0x00, 0x03, 0x07, 0x0c, 0x18, 0xf8, 0xe4, + 0x7f, 0x7f, 0x3f, 0x3f, 0x1f, 0x1f, 0x0f, 0x07, 0x03, 0x44, 0x28, 0x10, + 0x08, 0x04, 0x03, 0x04, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x77, 0x77, 0xf5, + 0x03, 0x07, 0x0f, 0x1f, 0x27, 0x7b, 0x78, 0xfb, 0xc0, 0xe0, 0xf0, 0xf8, + 0xfc, 0xee, 0xee, 0xaf, 0xc0, 0xe0, 0xf0, 0xf8, 0xe4, 0xde, 0x1e, 0xdf, + 0xf1, 0xff, 0x78, 0x00, 0x00, 0x18, 0x1c, 0x0e, 0xff, 0xff, 0x7f, 0x0f, + 0x0f, 0x07, 0x03, 0x00, 0x8f, 0xff, 0x1e, 0x00, 0x0c, 0x3e, 0x7e, 0x7c, + 0xff, 0xff, 0xfe, 0xf0, 0xf0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x24, 0x24, 0x18, 0x00, 0x00, + 0x00, 0x02, 0x41, 0x41, 0x61, 0x33, 0x06, 0x3c, 0x3c, 0x7e, 0xff, 0xff, + 0xff, 0xff, 0x7e, 0x3c, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0x7f, 0xff, + 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x63, 0x41, 0xc1, 0xc0, 0xe0, 0xf0, 0xf8, + 0xfc, 0xfe, 0xfe, 0xff, 0xc0, 0x80, 0x00, 0x00, 0x8c, 0xfe, 0xfe, 0xf3, + 0xff, 0xff, 0xff, 0x78, 0x00, 0x00, 0x00, 0x00, 0xc1, 0xe3, 0xff, 0x47, + 0x0f, 0x0f, 0x0f, 0x07, 0xff, 0xff, 0xff, 0x1e, 0x00, 0x20, 0x20, 0x40, + 0xf1, 0xf9, 0xff, 0xe2, 0xf0, 0xf0, 0xf0, 0xe0, 0x16, 0x1f, 0x3f, 0x7f, + 0x3d, 0x1d, 0x3f, 0x1f, 0x16, 0x1f, 0x00, 0x00, 0x05, 0x0d, 0x3f, 0x1f, + 0x80, 0x80, 0xc0, 0xe0, 0xf0, 0xf0, 0xf0, 0xf8, 0x80, 0x80, 0x00, 0x00, + 0x00, 0xa0, 0xa0, 0xe0, 0x3c, 0xfa, 0xb1, 0x72, 0xf2, 0xdb, 0xdf, 0x5f, + 0x00, 0x04, 0x4e, 0x8c, 0x0c, 0x7f, 0xff, 0xff, 0x00, 0x00, 0x00, 0x01, + 0x01, 0x01, 0x06, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x7f, 0x3f, 0x1f, + 0x0f, 0x07, 0x03, 0x01, 0x00, 0x7c, 0xd6, 0x92, 0xba, 0xee, 0xfe, 0x38, + 0xff, 0x83, 0x29, 0x6d, 0x45, 0x11, 0x01, 0xc7, 0x00, 0x15, 0x3f, 0x62, + 0x5f, 0xff, 0x9f, 0x7d, 0x08, 0x08, 0x02, 0x1f, 0x22, 0x02, 0x02, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x08, 0x08, 0x08, 0x08, + 0x08, 0x08, 0x08, 0x08, 0x2f, 0x1e, 0x2f, 0x2f, 0x2f, 0x15, 0x0d, 0x0e, + 0x10, 0x1e, 0x10, 0x50, 0x10, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0x00, 0x00, + 0x1c, 0x3e, 0x7f, 0xff, 0xff, 0xfe, 0x7c, 0x38, 0x1c, 0x2a, 0x77, 0xee, + 0xdd, 0xaa, 0x74, 0x28, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xfe, 0x00, 0xef, 0xef, 0xef, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0x00, 0xef, 0xef, 0xef, 0x00, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x7f, 0x5f, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, 0x68, 0x4e, 0xe0, 0xe0, 0xe0, 0xf0, 0xf8, 0xfc, + 0xb8, 0x9e, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0x7c, 0x3f, 0x5c, 0x39, 0x3b, + 0xbb, 0xf9, 0xfc, 0xfe, 0x00, 0x23, 0x57, 0x4f, 0x57, 0x27, 0xc3, 0x21, + 0xc0, 0xf0, 0xf0, 0xf0, 0xf0, 0xe0, 0xc0, 0x00, 0x00, 0x30, 0x70, 0x70, + 0xf0, 0xe0, 0xc0, 0x00, 0xfe, 0xfc, 0x61, 0x0f, 0xff, 0xfe, 0xf0, 0xe0, + 0x13, 0x0f, 0x1e, 0xf0, 0xfc, 0xf8, 0xf0, 0xe0, 0x6e, 0x40, 0xe0, 0xe0, + 0xe0, 0xe0, 0xe0, 0xc0, 0xbe, 0x90, 0x80, 0xc0, 0xc0, 0x80, 0x00, 0x00, + 0x01, 0x01, 0x03, 0x03, 0x07, 0x7f, 0x7f, 0x3f, 0x01, 0x01, 0x03, 0x03, + 0x07, 0x7f, 0x7d, 0x3d, 0x06, 0x07, 0x3f, 0x3c, 0x19, 0x7b, 0x7f, 0x3f, + 0x06, 0x04, 0x30, 0x23, 0x06, 0x64, 0x60, 0x00, 0x3f, 0x7f, 0x7f, 0x1f, + 0x3f, 0x3f, 0x07, 0x06, 0x00, 0x60, 0x60, 0x00, 0x20, 0x30, 0x04, 0x06, + 0x03, 0x07, 0x0f, 0x0f, 0x0f, 0x0f, 0x07, 0x03, 0x00, 0x01, 0x01, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0xa0, 0xe1, 0xff, 0xff, 0xff, + 0xfe, 0xff, 0xff, 0x40, 0x01, 0x03, 0x03, 0x03, 0x0f, 0x0f, 0x0f, 0x1f, + 0x1f, 0x1f, 0x0f, 0x07, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xe0, 0xf8, 0xf8, 0xf8, 0xff, 0xfe, 0xf0, 0xc0, 0xe0, 0xfe, 0xff, 0x7f, + 0x03, 0x02, 0x00, 0x00, 0x01, 0x0f, 0x0f, 0x1f, 0x39, 0x33, 0x37, 0x7f, + 0x01, 0x0d, 0x08, 0x00, 0x36, 0x2c, 0x08, 0x60, 0x7f, 0x3f, 0x3f, 0x3f, + 0x1f, 0x0f, 0x0f, 0x01, 0x60, 0x00, 0x20, 0x30, 0x00, 0x08, 0x0d, 0x01, + 0x00, 0x00, 0x03, 0x03, 0x47, 0x67, 0x77, 0x77, 0x01, 0x01, 0x03, 0x43, + 0x67, 0x77, 0x7b, 0x78, 0x00, 0x00, 0x00, 0x00, 0x88, 0x98, 0xf8, 0xf0, + 0x00, 0x00, 0x80, 0x84, 0xcc, 0xdc, 0xbc, 0x3c, 0x7e, 0x7f, 0xff, 0x1f, + 0x07, 0x30, 0x1c, 0x0c, 0x33, 0x07, 0x07, 0xe3, 0x38, 0x3f, 0x1c, 0x0c, + 0x7e, 0x38, 0xf6, 0xed, 0xdf, 0x38, 0x70, 0x60, 0x98, 0xc7, 0xc8, 0x92, + 0x30, 0xf8, 0x70, 0x60, 0x00, 0x00, 0x00, 0x03, 0x03, 0x47, 0x67, 0x77, + 0x00, 0x01, 0x01, 0x03, 0x43, 0x67, 0x77, 0x7b, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x88, 0x98, 0xf8, 0x00, 0x00, 0x00, 0x80, 0x84, 0xcc, 0xdc, 0xbc, + 0x77, 0x7e, 0x7f, 0xff, 0x1f, 0x07, 0x70, 0xf0, 0x78, 0x33, 0x07, 0x07, + 0xe3, 0x38, 0x7f, 0xf0, 0xf0, 0x7e, 0x38, 0xf6, 0xed, 0xdf, 0x38, 0x3c, + 0x3c, 0x98, 0xc7, 0xc8, 0x92, 0x30, 0xf8, 0x3c, 0x03, 0x07, 0x0a, 0x1a, + 0x1c, 0x1e, 0x0b, 0x08, 0x00, 0x10, 0x7f, 0x7f, 0x7f, 0x1f, 0x0f, 0x0f, + 0x1c, 0x3f, 0x3f, 0x3d, 0x3f, 0x1f, 0x00, 0x00, 0x03, 0x33, 0x39, 0x3a, + 0x38, 0x18, 0x00, 0x00, 0x00, 0x00, 0x04, 0x4c, 0x4e, 0x4e, 0x46, 0x6f, + 0x10, 0x38, 0x3c, 0x74, 0x76, 0x76, 0x7e, 0x7d, 0x00, 0x1f, 0x3f, 0x3f, + 0x4f, 0x5f, 0x7f, 0x7f, 0x00, 0x00, 0x11, 0x0a, 0x34, 0x2a, 0x51, 0x20, + 0x7f, 0x67, 0xa3, 0xb0, 0xd8, 0xde, 0xdc, 0xc8, 0x7f, 0x67, 0x63, 0x70, + 0x38, 0x3e, 0x7c, 0xb8, 0x7f, 0x7f, 0x7f, 0x1f, 0x47, 0x70, 0x70, 0x39, + 0x51, 0x0a, 0x04, 0xea, 0x79, 0x7f, 0x70, 0x39, 0xe8, 0xe8, 0xe0, 0xc0, + 0x10, 0x70, 0xe0, 0xc0, 0x58, 0x38, 0x10, 0x30, 0xf0, 0xf0, 0xe0, 0xc0, + 0x00, 0x00, 0x00, 0x20, 0x66, 0x66, 0x66, 0x62, 0x00, 0x08, 0x1c, 0x3c, + 0x7a, 0x7a, 0x7a, 0x7e, 0x00, 0x00, 0x1f, 0x3f, 0x7f, 0x4f, 0x5f, 0x7f, + 0x00, 0x00, 0x00, 0x11, 0x0a, 0x34, 0x2a, 0x51, 0x77, 0x7f, 0x3f, 0xb7, + 0xb3, 0xdb, 0xda, 0xd8, 0x7f, 0x7d, 0x3f, 0x37, 0x33, 0x3b, 0x3a, 0x78, + 0x7f, 0x7f, 0x7f, 0x7f, 0x1f, 0x07, 0x70, 0xf0, 0x20, 0x51, 0x0a, 0x04, + 0xea, 0x39, 0x7f, 0xf0, 0xcc, 0xe8, 0xe8, 0xe0, 0xc0, 0x18, 0x7c, 0x3e, + 0xbc, 0x58, 0x38, 0x10, 0x30, 0xf8, 0xfc, 0x3e, 0x03, 0x0f, 0x1f, 0x3f, + 0x3b, 0x3f, 0x7f, 0x7f, 0x00, 0x00, 0x00, 0x06, 0x0e, 0x0c, 0x00, 0x00, + 0x80, 0xf0, 0xf8, 0xfc, 0xfe, 0xfe, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x0f, 0x18, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0x0f, 0x03, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xf8, 0x3e, 0x3b, 0x18, 0xfe, 0xfb, 0xff, 0xff, + 0xf6, 0xe0, 0xc0, 0x00, 0x10, 0x14, 0x10, 0x10, 0x38, 0x78, 0xf8, 0x30, + 0x00, 0x03, 0x0f, 0x1f, 0x3f, 0x3b, 0x3f, 0x7f, 0x00, 0x00, 0x00, 0x00, + 0x06, 0x0e, 0x0c, 0x00, 0x00, 0xc0, 0xf0, 0xf8, 0xfc, 0xfe, 0xfe, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x7f, 0xff, 0x0f, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x7e, 0xf3, + 0xfe, 0xfe, 0xfb, 0xff, 0xff, 0xf6, 0xe0, 0xc0, 0x18, 0x10, 0x14, 0x10, + 0x10, 0x38, 0x7c, 0xde, 0x00, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x08, + 0x00, 0x0d, 0x1e, 0x1e, 0x1e, 0x1f, 0x0f, 0x07, 0x78, 0xf0, 0xf8, 0xe4, + 0xc0, 0xca, 0xca, 0xc0, 0x78, 0xf0, 0x00, 0x1a, 0x3f, 0x35, 0x35, 0x3f, + 0x0f, 0x1f, 0x9f, 0xff, 0xff, 0x7f, 0x74, 0x20, 0x00, 0x00, 0x80, 0xe0, + 0xe0, 0x70, 0x73, 0x21, 0xe4, 0xff, 0xfe, 0xfc, 0x9c, 0x1e, 0x00, 0x00, + 0x1a, 0x07, 0x0c, 0x18, 0x78, 0xfe, 0xfc, 0xf0, 0x00, 0x01, 0x03, 0x03, + 0x07, 0x03, 0x01, 0x00, 0x00, 0x01, 0x02, 0x00, 0x38, 0x7c, 0x7e, 0x3f, + 0x00, 0x5f, 0x7f, 0x7f, 0x3f, 0x3f, 0x14, 0x00, 0x3f, 0x40, 0x60, 0x60, + 0x20, 0x30, 0x13, 0x01, 0xc0, 0xe0, 0xf0, 0x30, 0x38, 0x3c, 0x3c, 0xfc, + 0xc0, 0xe0, 0x30, 0xd0, 0xd0, 0xd0, 0xd0, 0x00, 0x07, 0x0f, 0x1f, 0x22, + 0x20, 0x25, 0x25, 0x1f, 0x07, 0x0f, 0x02, 0x1d, 0x1f, 0x1a, 0x1a, 0x02, + 0xfe, 0xfe, 0x7e, 0x3a, 0x02, 0x01, 0x41, 0x41, 0x38, 0x7c, 0xfc, 0xfc, + 0xfc, 0xfe, 0xbe, 0xbe, 0x1f, 0x3f, 0x7e, 0x5c, 0x40, 0x80, 0x82, 0x82, + 0x1c, 0x3e, 0x3f, 0x3f, 0x3f, 0x7f, 0x7d, 0x7d, 0x82, 0x80, 0xa0, 0x44, + 0x43, 0x40, 0x21, 0x1e, 0x7d, 0x7f, 0x5f, 0x3b, 0x3c, 0x3f, 0x1e, 0x00, + 0x1c, 0x3f, 0x3e, 0x3c, 0x40, 0x80, 0x82, 0x82, 0x1c, 0x3e, 0x3f, 0x1f, + 0x3f, 0x7f, 0x7d, 0x7d, 0x00, 0x00, 0x80, 0x80, 0x92, 0x9d, 0xc7, 0xef, + 0x00, 0x00, 0x00, 0x60, 0x62, 0x65, 0x3f, 0x1f, 0x00, 0x23, 0x33, 0x3f, + 0x3f, 0x7f, 0x7f, 0x7f, 0x70, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x02, 0x07, + 0xfe, 0xf8, 0xa0, 0x00, 0x00, 0x00, 0x80, 0x80, 0xcf, 0x7a, 0x5a, 0x10, + 0x00, 0x00, 0xc0, 0x80, 0x7e, 0x7f, 0x7d, 0x3f, 0x1e, 0x8f, 0x8f, 0x19, + 0x85, 0x84, 0x86, 0xc6, 0xe7, 0x73, 0x73, 0xe1, 0xe0, 0x0e, 0x73, 0xf3, + 0xf9, 0xf9, 0xf8, 0x70, 0x80, 0x4e, 0x77, 0xf3, 0xfb, 0xf9, 0xfa, 0x78, + 0x0e, 0x66, 0xe2, 0xf6, 0xff, 0xff, 0x1f, 0x98, 0x11, 0x39, 0x7d, 0x39, + 0x00, 0x00, 0xe0, 0xe7, 0x00, 0x00, 0x00, 0x04, 0x0f, 0x0f, 0x1f, 0x07, + 0x00, 0x00, 0x07, 0x07, 0x16, 0x10, 0x00, 0x38, 0xf3, 0xe7, 0xee, 0xec, + 0xcd, 0xcf, 0xcf, 0xdf, 0xcf, 0x1f, 0x17, 0x10, 0x33, 0x30, 0x30, 0x20, + 0x27, 0x3f, 0x3f, 0x78, 0x3c, 0x1f, 0x1f, 0x73, 0x38, 0x30, 0x40, 0xc7, + 0x07, 0x66, 0xe0, 0x6c, 0x9f, 0x3e, 0x7c, 0xfc, 0xf8, 0xf8, 0xc0, 0x40, + 0x60, 0xc0, 0x80, 0x04, 0x9e, 0xff, 0xf0, 0xf8, 0x7f, 0x7e, 0x78, 0x01, + 0x07, 0x1f, 0x3c, 0x7c, 0x24, 0x01, 0x07, 0xfe, 0xff, 0x7f, 0x3f, 0x7f, + 0xfc, 0xf8, 0xa0, 0xfe, 0xfc, 0xf0, 0x80, 0x00, 0xcf, 0x7a, 0x0a, 0xfe, + 0xfc, 0x00, 0x00, 0x00, 0x7e, 0x7f, 0x7f, 0x3f, 0x1f, 0x8f, 0x8f, 0x18, + 0x85, 0x86, 0x83, 0xc3, 0xe1, 0x70, 0x70, 0xe0, 0x9f, 0x3e, 0x7c, 0xf8, + 0xf8, 0x3c, 0x18, 0xf8, 0x60, 0xc0, 0x80, 0x00, 0x98, 0xfc, 0xfe, 0xff, + 0x7f, 0x7f, 0x78, 0x01, 0x07, 0x13, 0xf1, 0x03, 0x24, 0x00, 0x07, 0xfe, + 0xff, 0x7f, 0xff, 0x03, 0x00, 0x00, 0x1c, 0x1d, 0x1b, 0xc3, 0xe3, 0xe1, + 0x03, 0x0f, 0x23, 0x62, 0x64, 0x3c, 0x1c, 0x1e, 0xe0, 0xcd, 0x1d, 0x4f, + 0xee, 0xff, 0x3f, 0x3f, 0x1f, 0x3d, 0x6d, 0x4f, 0xee, 0xf3, 0x20, 0x03, + 0x3f, 0x3f, 0x00, 0x00, 0x70, 0xb8, 0xfc, 0xfc, 0x07, 0x07, 0x1f, 0x3f, + 0x0f, 0x47, 0x03, 0x00, 0x07, 0x0f, 0x1f, 0x3f, 0x3e, 0x7c, 0x78, 0x78, + 0x00, 0x00, 0x03, 0x07, 0x0f, 0x0f, 0x1f, 0x1f, 0x3f, 0x5c, 0x39, 0x3b, + 0xbf, 0xff, 0xfe, 0xfe, 0x00, 0x23, 0x57, 0x4f, 0x57, 0x2f, 0xdf, 0x21, + 0xc0, 0xc0, 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x80, 0x80, 0x00, 0x00, 0xfe, 0xfc, 0x61, 0x0f, 0x7f, 0x3f, 0x1f, 0x1e, + 0x23, 0x0f, 0x1e, 0xf0, 0x1c, 0x3f, 0x1f, 0x1e, 0xf0, 0x78, 0xe4, 0xc8, + 0xcc, 0xbe, 0xbe, 0x3e, 0x00, 0x80, 0x18, 0x30, 0x34, 0xfe, 0xfe, 0xfe, + 0x00, 0x01, 0x00, 0x07, 0x07, 0x07, 0x07, 0x1f, 0x00, 0x00, 0x01, 0x04, + 0x06, 0x06, 0x07, 0x07, 0x00, 0x00, 0x0f, 0x3f, 0x3f, 0x0f, 0x00, 0x00, + 0x0f, 0x3f, 0x7f, 0xf8, 0xf8, 0x7f, 0x3f, 0x0f, 0x78, 0x7c, 0x7e, 0x7f, + 0x3f, 0x3f, 0x1b, 0x09, 0x1f, 0x1f, 0x1f, 0x0b, 0x01, 0x01, 0x00, 0x00, + 0x0c, 0x00, 0x00, 0x00, 0x07, 0x7f, 0x7c, 0x00, 0x03, 0x1f, 0x3f, 0x3f, + 0x78, 0x00, 0x03, 0xff, 0x01, 0xe1, 0x71, 0x79, 0x3d, 0x3d, 0x1f, 0x03, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x3f, 0x1f, 0x1b, + 0x36, 0x30, 0x7f, 0x3f, 0x23, 0x27, 0x1f, 0x07, 0x0f, 0x1f, 0x7f, 0x3f, + 0xf8, 0xf8, 0xf8, 0xb8, 0x18, 0xd8, 0xd8, 0xb8, 0xe0, 0x80, 0x80, 0x40, + 0xe0, 0xe0, 0xe0, 0xc0, 0x01, 0x02, 0x04, 0x04, 0x08, 0x08, 0x10, 0x10, + 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff, 0x1f, 0x00, 0x0f, 0x13, 0x0d, + 0x0d, 0x13, 0x0c, 0x20, 0x1f, 0x10, 0x0c, 0x12, 0x12, 0x2c, 0x3f, 0x3f, + 0x00, 0x24, 0x00, 0x24, 0x00, 0x04, 0x00, 0x00, 0x37, 0x36, 0x36, 0x36, + 0x16, 0x16, 0x12, 0x02, 0x0f, 0x41, 0x00, 0x88, 0x00, 0x44, 0x00, 0x00, + 0x10, 0x7e, 0xff, 0xff, 0xf6, 0x76, 0x3a, 0x1a, 0x38, 0x7c, 0xfe, 0xfe, + 0x3b, 0x03, 0x03, 0x03, 0x00, 0x00, 0x38, 0x04, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x33, 0x7b, 0x7f, 0xff, 0xfb, 0x03, 0x03, 0x00, 0x00, 0x00, 0x38, + 0x40, 0x00, 0x00, 0x00, 0xdc, 0xc0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xc0, + 0xfc, 0xa0, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x5f, 0x3f, 0x3f, + 0xbb, 0xf8, 0xfe, 0xfe, 0x07, 0x27, 0x57, 0x4f, 0x57, 0x27, 0xc1, 0x21, + 0x1f, 0x0f, 0x0f, 0x1f, 0x1f, 0x1e, 0x38, 0x30, 0x1d, 0x0f, 0x0f, 0x1f, + 0x1f, 0x1e, 0x38, 0x30, 0x00, 0x20, 0x60, 0x60, 0x70, 0xf0, 0xf8, 0xf8, + 0x00, 0x00, 0x38, 0x10, 0x4c, 0x18, 0x86, 0x24, 0xf8, 0xfc, 0xfc, 0x7e, + 0x7e, 0x3e, 0x1f, 0x07, 0x00, 0x42, 0x0a, 0x40, 0x10, 0x02, 0x08, 0x02, + 0x00, 0xc0, 0x70, 0xb8, 0xf4, 0xf2, 0xf5, 0x7b, 0x00, 0x00, 0x80, 0x40, + 0x08, 0x0c, 0x0a, 0x84, 0x00, 0xdf, 0x10, 0xff, 0xdf, 0xff, 0xff, 0xf9, + 0x00, 0x00, 0xcf, 0x20, 0x20, 0x20, 0x26, 0x2e, 0x1f, 0x1f, 0x3e, 0xfc, + 0xf8, 0xf0, 0xc0, 0x00, 0xe0, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xf8, 0xfc, 0xfe, 0xff, 0xff, 0xdf, 0xdf, 0x00, 0x2f, 0x23, 0x21, 0x20, + 0x20, 0x00, 0x00, 0x00, 0xc1, 0xf1, 0x79, 0x7d, 0x3d, 0x3f, 0x1f, 0x03, + 0xc1, 0xb1, 0x59, 0x6d, 0x35, 0x3b, 0x1f, 0x03, 0x02, 0x06, 0x0e, 0x0e, + 0x1e, 0x1e, 0x3e, 0x3e, 0x00, 0x02, 0x00, 0x08, 0x02, 0x00, 0x28, 0x00, + 0x3e, 0x3e, 0x3e, 0x3e, 0x1e, 0x1e, 0x0e, 0x02, 0x04, 0x10, 0x02, 0x10, + 0x04, 0x00, 0x0a, 0x00, 0xc1, 0xf1, 0x79, 0x7d, 0x3d, 0x3f, 0x1f, 0x03, + 0xc1, 0xb1, 0x59, 0x6d, 0x35, 0x3b, 0x1f, 0x03, 0x7c, 0x00, 0x00, 0xff, + 0xc3, 0x7f, 0x1f, 0x03, 0x00, 0x0f, 0x1f, 0xff, 0xfc, 0x63, 0x1f, 0x03, + 0xff, 0xff, 0x7c, 0x00, 0x00, 0x7c, 0xff, 0xff, 0x00, 0x00, 0xfe, 0xc6, + 0xc6, 0xfe, 0x00, 0x00, 0xff, 0xff, 0x00, 0x04, 0x0c, 0x18, 0x30, 0x00, + 0x00, 0x00, 0x06, 0x06, 0x0c, 0x18, 0x70, 0x60, 0xff, 0xff, 0x00, 0x04, + 0x04, 0x04, 0x08, 0x08, 0x00, 0x00, 0x06, 0x06, 0x04, 0x04, 0x08, 0x08, + 0x08, 0x10, 0x10, 0x00, 0x00, 0x10, 0x10, 0x08, 0x08, 0x10, 0x30, 0x30, + 0x30, 0x30, 0x10, 0x08, 0x7f, 0x3f, 0x3f, 0x3e, 0x1f, 0x0f, 0x03, 0x00, + 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x03, 0x0f, 0xff, 0x7f, + 0x7f, 0x7f, 0x7f, 0x7f, 0x03, 0x0e, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x65, 0x25, 0x25, + 0x25, 0x25, 0x77, 0x72, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x62, 0x95, 0x15, 0x25, 0x45, 0x85, 0xf7, 0xf2, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xa2, 0xa5, 0xa5, 0xa5, 0xf5, 0xf5, 0x27, 0x22, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf2, 0x85, 0x85, 0xe5, + 0x15, 0x15, 0xf7, 0xe2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x62, 0x95, 0x55, 0x65, 0xb5, 0x95, 0x97, 0x62, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x20, 0x50, 0x50, 0x50, 0x50, 0x50, 0x70, 0x20, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x66, 0xe6, 0x66, 0x66, 0x66, 0x67, 0xf3, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x5e, 0x59, 0x59, 0x59, 0x5e, 0xd8, 0x98, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x04, 0x08, 0x00, 0x38, 0x4c, 0xc6, 0xc6, 0xc6, 0x64, 0x38, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x18, 0x18, + 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x7c, 0xc6, 0x0e, 0x3c, 0x78, 0xe0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x7e, 0x0c, 0x18, 0x3c, 0x06, 0xc6, 0x7c, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x3c, 0x6c, 0xcc, + 0xfe, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfc, 0xc0, 0xfc, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3c, 0x60, 0xc0, 0xfc, 0xc6, 0xc6, 0x7c, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0x0c, 0x18, + 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x7c, 0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0x78, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, + 0xfe, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfc, 0xc6, 0xc6, 0xfc, 0xc6, 0xc6, 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0xc0, 0xc0, 0xc0, 0x66, 0x3c, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xcc, 0xc6, 0xc6, + 0xc6, 0xcc, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, 0xc0, 0xfc, 0xc0, 0xc0, 0xc0, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x60, 0xc0, 0xce, + 0xc6, 0x66, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x06, 0x06, 0x06, + 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xc6, 0xcc, 0xd8, 0xf0, 0xf8, 0xdc, 0xce, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7e, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xee, 0xfe, 0xfe, + 0xd6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xc6, + 0xfc, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x7c, 0xc6, 0xc6, 0xc6, 0xde, 0xcc, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xfc, 0xc6, 0xc6, 0xce, 0xf8, 0xdc, 0xce, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0xcc, 0xc0, 0x7c, + 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xee, + 0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xc6, 0xc6, 0xd6, 0xfe, 0xfe, 0xee, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xc6, 0xee, 0x7c, 0x38, 0x7c, 0xee, 0xc6, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x3c, + 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xfe, 0x0e, 0x1c, 0x38, 0x70, 0xe0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x7e, + 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x44, 0x28, 0x10, 0x28, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x18, 0x3c, 0x3c, 0x3c, + 0x18, 0x18, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0xff, 0xe3, 0xc1, 0xff, 0x80, 0x80, 0x80, + 0x80, 0x00, 0x1c, 0x3e, 0x80, 0x80, 0x80, 0xc1, 0xe3, 0xff, 0xff, 0xff, + 0x7f, 0x7f, 0x7f, 0x3e, 0x1c, 0x00, 0x00, 0xff, 0x38, 0x7c, 0x7c, 0x7c, + 0x7c, 0x7c, 0x38, 0x00, 0x08, 0x04, 0x04, 0x04, 0x04, 0x04, 0x08, 0x00, + 0x03, 0x06, 0x0c, 0x0c, 0x08, 0x08, 0x04, 0x03, 0x03, 0x05, 0x0b, 0x0b, + 0x0f, 0x0f, 0x07, 0x03, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, + 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x07, 0x38, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x07, 0x3f, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x1c, 0x03, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xe0, 0xfc, 0xff, 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, + 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0x04, 0x0e, 0x0e, 0x0e, + 0x6e, 0x64, 0x60, 0x60, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x07, 0x0f, 0x1f, 0x1f, 0x7f, 0xff, 0xff, 0x7f, 0x07, 0x08, 0x10, 0x00, + 0x60, 0x80, 0x80, 0x40, 0x03, 0x07, 0x1f, 0x3f, 0x3f, 0x3f, 0x79, 0xf7, + 0x03, 0x04, 0x18, 0x20, 0x20, 0x20, 0x46, 0x88, 0xc0, 0xe0, 0xf0, 0xf4, + 0xfe, 0xbf, 0xdf, 0xff, 0xc0, 0x20, 0x10, 0x14, 0x0a, 0x41, 0x21, 0x01, + 0x90, 0xb8, 0xf8, 0xfa, 0xff, 0xff, 0xff, 0xfe, 0x90, 0xa8, 0x48, 0x0a, + 0x05, 0x01, 0x01, 0x02, 0x3b, 0x1d, 0x0e, 0x0f, 0x07, 0x00, 0x00, 0x00, + 0x24, 0x12, 0x09, 0x08, 0x07, 0x00, 0x00, 0x00, 0xff, 0xbf, 0x1c, 0xc0, + 0xf3, 0xff, 0x7e, 0x1c, 0x00, 0x40, 0xe3, 0x3f, 0x0c, 0x81, 0x62, 0x1c, + 0xbf, 0x7f, 0x3d, 0x83, 0xc7, 0xff, 0xff, 0x3c, 0x40, 0x80, 0xc2, 0x7c, + 0x38, 0x00, 0xc3, 0x3c, 0xfc, 0xfe, 0xff, 0xfe, 0xfe, 0xf8, 0x60, 0x00, + 0x04, 0x02, 0x01, 0x00, 0x06, 0x98, 0x60, 0x00, 0xc0, 0x20, 0x10, 0x10, + 0x10, 0x10, 0x20, 0xc0, 0xc0, 0xe0, 0xf0, 0xf0, 0xf0, 0xf0, 0xe0, 0xc0, + 0x00, 0x00, 0x00, 0x00, 0x3f, 0x7f, 0xe0, 0xc0, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1c, 0x3e, 0x88, 0x9c, 0x88, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x7f, 0x7f, 0x7f, 0x3e, 0x1c, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0xfe, 0xfe, + 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x08, 0x14, 0x24, 0xc4, 0x03, 0x40, 0xa1, 0x26, 0x00, 0x08, 0x18, 0x38, + 0xfc, 0xbf, 0x5e, 0xd9, 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x7f, 0x80, 0x80, 0x98, 0x9c, 0x8c, 0x80, 0x80, 0x00, 0x7f, 0x7f, 0x67, + 0x67, 0x7f, 0x7f, 0x7f, 0xff, 0x01, 0x01, 0xff, 0x10, 0x10, 0x10, 0xff, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x01, 0x01, 0x01, 0xff, 0x10, 0x10, 0x10, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x01, 0x01, 0x19, + 0x1d, 0x0d, 0x01, 0x01, 0x00, 0xff, 0xff, 0xe7, 0xe7, 0xff, 0xff, 0xff, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x3f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x3f, 0x60, 0x40, 0xc0, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x7e, 0x3c, 0x80, 0x80, 0x80, 0x80, 0x80, 0x81, 0x42, 0x3c, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7c, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x82, 0x7c, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xfe, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x83, 0xff, + 0xf8, 0xfc, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xf8, 0x04, 0x02, 0x02, + 0x01, 0x01, 0x01, 0x01, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x3c, + 0x01, 0x01, 0x01, 0x01, 0x01, 0x81, 0x42, 0x3c, 0x00, 0x08, 0x08, 0x08, + 0x10, 0x10, 0x10, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x7f, 0x7f, 0x78, 0x73, 0x73, 0x73, 0x7f, 0x7f, 0x80, 0xa0, 0x87, + 0x8f, 0x8e, 0x8e, 0x86, 0x00, 0xff, 0xff, 0x3f, 0x9f, 0x9f, 0x9f, 0x1f, + 0xfe, 0x01, 0x05, 0xc1, 0xe1, 0x71, 0x71, 0xf1, 0x7e, 0x7e, 0x7f, 0x7e, + 0x7e, 0x7f, 0x7f, 0xff, 0x81, 0x81, 0x80, 0x81, 0x81, 0xa0, 0x80, 0xff, + 0x7f, 0x7f, 0xff, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xf1, 0xc1, 0xc1, 0x81, + 0xc1, 0xc5, 0x01, 0xff, 0x7f, 0x80, 0xa0, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x01, 0x05, 0x01, + 0x01, 0x01, 0x01, 0x01, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x80, 0x80, 0x80, 0x80, 0xa0, 0x80, 0x7f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0x7f, 0x01, 0x01, 0x01, 0x01, 0x01, 0x05, 0x01, 0xfe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x00, 0x00, 0x00, 0x00, + 0xfc, 0xfe, 0x07, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x7c, + 0x11, 0x39, 0x11, 0x01, 0x01, 0x01, 0x01, 0x01, 0xfe, 0xfe, 0xfe, 0x7c, + 0x38, 0x00, 0x00, 0x00, 0xef, 0x28, 0x28, 0x28, 0x28, 0x28, 0xef, 0x00, + 0x20, 0xe7, 0xe7, 0xe7, 0xe7, 0xe7, 0xef, 0x00, 0xfe, 0x82, 0x82, 0x82, + 0x82, 0x82, 0xfe, 0x00, 0x02, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0xfe, 0x00, + 0x80, 0x80, 0x80, 0x98, 0x9c, 0x8c, 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x67, + 0x67, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0x83, 0xf3, 0xf3, 0xf3, 0xf3, 0xf3, + 0xff, 0x80, 0xfc, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0xff, 0xff, 0xf0, 0xf6, + 0xf6, 0xf6, 0xf6, 0xf6, 0xff, 0x00, 0x0f, 0x09, 0x09, 0x09, 0x09, 0x09, + 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x57, 0x2f, 0x57, 0x2f, 0x57, + 0xff, 0x01, 0xff, 0xa9, 0xd1, 0xa9, 0xd1, 0xa9, 0xf3, 0xf3, 0xf3, 0xf3, + 0xf3, 0xf3, 0xff, 0x3f, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0x8c, 0xff, 0x3f, + 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xf6, 0xff, 0xff, 0x09, 0x09, 0x09, 0x09, + 0x09, 0x09, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x2f, 0x57, 0x2f, 0x57, + 0x2f, 0x57, 0xff, 0xfc, 0xd1, 0xa9, 0xd1, 0xa9, 0xd1, 0xa9, 0xff, 0xfc, + 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x3c, 0x23, 0x23, 0x23, 0x23, + 0x23, 0x23, 0x23, 0x23, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, 0xfb, + 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0xbc, 0x5c, 0xbc, 0x5c, + 0xbc, 0x5c, 0xbc, 0x5c, 0x44, 0xa4, 0x44, 0xa4, 0x44, 0xa4, 0x44, 0xa4, + 0x1f, 0x20, 0x40, 0x40, 0x80, 0x80, 0x80, 0x81, 0x1f, 0x3f, 0x7f, 0x7f, + 0xff, 0xff, 0xff, 0xfe, 0xff, 0x80, 0x80, 0xc0, 0xff, 0xff, 0xfe, 0xfe, + 0xff, 0x7f, 0x7f, 0x3f, 0x00, 0x00, 0x01, 0x01, 0xff, 0x7f, 0x7f, 0xff, + 0xff, 0x07, 0x03, 0x03, 0xff, 0x80, 0x80, 0x00, 0x00, 0xf8, 0xfc, 0xfc, + 0xff, 0x00, 0x00, 0x00, 0x00, 0x81, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x7e, 0x3c, 0x00, 0xf8, 0xfc, 0xfe, 0xfe, 0xe3, 0xc1, 0x81, 0x81, + 0xf8, 0x04, 0x02, 0x02, 0x1d, 0x3f, 0x7f, 0x7f, 0x83, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x7f, 0x1f, 0xfc, 0x80, 0x80, 0x80, 0x80, 0x80, 0x60, 0x1f, + 0xfc, 0xfc, 0xfc, 0xfc, 0xfe, 0xfe, 0xff, 0xff, 0x03, 0x03, 0x03, 0x03, + 0x01, 0x01, 0x00, 0xff, 0x01, 0x01, 0x01, 0x01, 0x03, 0x03, 0x07, 0xff, + 0xfe, 0xfe, 0xfe, 0xfe, 0xfc, 0xfc, 0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0x81, 0xc1, 0xe3, 0xff, 0xff, 0xff, 0xff, 0xfe, 0x7f, 0x3f, 0x1d, 0x01, + 0x01, 0x01, 0x03, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xb5, 0xce, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x84, 0xca, 0xb1, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xdf, 0xad, 0x73, 0x01, 0x01, 0x01, 0x01, 0x01, 0x21, 0x53, 0x8d, + 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x77, 0x00, 0x00, 0x00, 0x00, + 0x77, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x77, 0x77, 0x77, 0x77, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x77, 0x77, 0x77, 0x77, 0x77, + 0x01, 0x01, 0x01, 0x19, 0x1d, 0x0d, 0x01, 0xfe, 0xff, 0xff, 0xff, 0xe7, + 0xe7, 0xff, 0xff, 0xfe, 0x20, 0x78, 0x7f, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, + 0x00, 0x21, 0x21, 0x41, 0x41, 0x41, 0x41, 0x41, 0x04, 0x9a, 0xfa, 0xfd, + 0xfd, 0xfd, 0xfd, 0xfd, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x7e, 0x38, 0x21, 0x00, 0x01, 0x00, 0x01, 0x00, 0x21, 0x21, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0xfa, 0x8a, 0x84, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x02, 0x04, 0x00, 0x10, + 0x00, 0x40, 0x80, 0x00, 0x01, 0x01, 0x06, 0x08, 0x18, 0x20, 0x20, 0xc0, + 0x0b, 0x0b, 0x3b, 0x0b, 0xfb, 0x0b, 0x0b, 0x0a, 0x04, 0x04, 0xc4, 0xf4, + 0xf4, 0x04, 0x04, 0x05, 0x90, 0x10, 0x1f, 0x10, 0x1f, 0x10, 0x10, 0x90, + 0x70, 0xf0, 0xf0, 0xff, 0xff, 0xf0, 0xf0, 0x70, 0x3f, 0x78, 0xe7, 0xcf, + 0x58, 0x58, 0x50, 0x90, 0xc0, 0x87, 0x18, 0xb0, 0xe7, 0xe7, 0xef, 0xef, + 0xb0, 0xfc, 0xe2, 0xc1, 0xc1, 0x83, 0x8f, 0x7e, 0x6f, 0x43, 0x5d, 0x3f, + 0x3f, 0x7f, 0x7f, 0xff, 0xfe, 0x03, 0x0f, 0x91, 0x70, 0x60, 0x20, 0x31, + 0x03, 0xff, 0xf1, 0x6e, 0xcf, 0xdf, 0xff, 0xff, 0x3f, 0x3f, 0x1d, 0x39, + 0x7b, 0xf3, 0x86, 0xfe, 0xfd, 0xfb, 0xfb, 0xf7, 0xf7, 0x0f, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x80, 0xff, 0xff, 0x80, 0x80, 0x80, + 0x80, 0xff, 0xff, 0x80, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x03, 0x03, 0xff, + 0xfe, 0x03, 0x03, 0x03, 0x03, 0xff, 0xff, 0x03, 0x00, 0xff, 0xff, 0xff, + 0xff, 0xff, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, + 0x3c, 0xfc, 0xfc, 0xfc, 0xfc, 0xfc, 0x04, 0x04, 0x23, 0xf3, 0x0b, 0x0b, + 0x0b, 0x07, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0xff, 0xff, 0xff, + 0x80, 0x80, 0x80, 0x80, 0xff, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, + 0x03, 0xff, 0xff, 0xff, 0x03, 0x03, 0x03, 0x03, 0xff, 0x03, 0x03, 0x03, + 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0xff, 0x00, 0x00, 0xfc, 0xfc, 0xfe, 0xfe, 0xfe, 0x02, 0xfe, 0xfe, + 0x07, 0x07, 0x03, 0x03, 0x03, 0xff, 0x03, 0x03, 0xff, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x04, 0x04, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x80, 0x80, 0xaa, 0xd5, + 0xaa, 0xff, 0xff, 0xff, 0xff, 0xff, 0xd5, 0xaa, 0xd5, 0x80, 0x80, 0xff, + 0x03, 0x03, 0xab, 0x57, 0xab, 0xff, 0xff, 0xfe, 0xff, 0xff, 0x57, 0xab, + 0x57, 0x03, 0x03, 0xfe, 0x00, 0x55, 0xaa, 0x55, 0xff, 0xff, 0xff, 0x00, + 0xff, 0xaa, 0x55, 0xaa, 0x00, 0x00, 0xff, 0x00, 0x04, 0x54, 0xac, 0x5c, + 0xfc, 0xfc, 0xfc, 0x3c, 0xff, 0xaf, 0x57, 0xab, 0x0b, 0x0b, 0xf3, 0x23, + 0x3f, 0x3f, 0x3f, 0x3f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x7e, 0x7c, 0x7c, 0x78, 0x00, 0x00, 0x00, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x1f, 0x0f, 0x0f, 0x07, + 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xfc, 0xfc, 0xf8, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, + 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x07, 0x1f, 0x3f, 0xff, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xe1, 0xf9, 0xfd, 0xff, 0xfe, 0xfe, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x10, 0x10, 0x10, + 0x10, 0x10, 0x10, 0xff, 0x00, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, + 0x1f, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0xff, 0x00, 0x0f, 0x0f, 0x0f, + 0x0f, 0x0f, 0x0f, 0x0f, 0x92, 0x92, 0x92, 0xfe, 0xfe, 0x00, 0x00, 0x00, + 0x48, 0x48, 0x6c, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x0a, 0x0a, 0x3a, 0x0a, + 0xfb, 0x0b, 0x0b, 0x0b, 0x05, 0x05, 0xc5, 0xf5, 0xf4, 0x04, 0x04, 0x04, + 0x90, 0x90, 0x9f, 0x90, 0x9f, 0x90, 0x90, 0x90, 0x70, 0x70, 0x70, 0x7f, + 0x7f, 0x70, 0x70, 0x70, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x80, 0x80, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x08, 0x88, 0x91, 0xd1, 0x53, 0x53, 0x73, 0x3f, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xfe, 0xbe, 0xce, 0x00, 0x00, 0x07, 0x0f, 0x0c, 0x1b, 0x1b, 0x1b, + 0x00, 0x00, 0x00, 0x00, 0x03, 0x04, 0x04, 0x04, 0x00, 0x00, 0xe0, 0xf0, + 0xf0, 0xf8, 0xf8, 0xf8, 0x00, 0x00, 0x60, 0x30, 0x30, 0x98, 0x98, 0x98, + 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x0f, 0x0f, 0x07, 0x04, 0x04, 0x04, 0x04, + 0x04, 0x03, 0x00, 0x00, 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf0, 0xf0, 0xe0, + 0x98, 0x98, 0x98, 0x98, 0x98, 0x30, 0x30, 0x60, 0xf1, 0x11, 0x11, 0x1f, + 0x10, 0x10, 0x10, 0xff, 0x0f, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xe0, + 0x1f, 0x10, 0x10, 0xf0, 0x10, 0x10, 0x10, 0xff, 0xe0, 0xef, 0xef, 0xef, + 0xef, 0xef, 0xef, 0x0f, 0x7f, 0xbf, 0xdf, 0xef, 0xf0, 0xf0, 0xf0, 0xf0, + 0x80, 0x40, 0x20, 0x10, 0x0f, 0x0f, 0x0f, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, + 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x1f, 0x3f, 0x7f, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0x01, 0x03, 0x07, 0x0f, + 0xff, 0xff, 0xff, 0xff, 0x0f, 0x0f, 0x0f, 0x0f, 0xf7, 0xfb, 0xfd, 0xfe, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x1f, 0x3f, 0x7f, 0x7f, 0x7f, 0xff, 0xff, 0xff, 0x1f, 0x20, 0x40, 0x40, + 0x40, 0x80, 0x82, 0x82, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x3f, 0x1e, + 0x82, 0x80, 0xa0, 0x44, 0x43, 0x40, 0x21, 0x1e, 0xf8, 0xfc, 0xfe, 0xfe, + 0xfe, 0xff, 0xff, 0xff, 0xf8, 0x04, 0x02, 0x02, 0x02, 0x01, 0x41, 0x41, + 0xff, 0xff, 0xff, 0xfe, 0xfe, 0xfe, 0xfc, 0x78, 0x41, 0x01, 0x05, 0x22, + 0xc2, 0x02, 0x84, 0x78, 0x7f, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, + 0x80, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0xde, 0x61, 0x61, 0x61, + 0x71, 0x5e, 0x7f, 0x61, 0x61, 0xdf, 0xdf, 0xdf, 0xdf, 0xff, 0xc1, 0xdf, + 0x80, 0x80, 0xc0, 0xf0, 0xbf, 0x8f, 0x81, 0x7e, 0x7f, 0x7f, 0xff, 0x3f, + 0x4f, 0x71, 0x7f, 0xff, 0x61, 0x61, 0xc1, 0xc1, 0x81, 0x81, 0x83, 0xfe, + 0xdf, 0xdf, 0xbf, 0xbf, 0x7f, 0x7f, 0x7f, 0x7f, 0x00, 0x00, 0x03, 0x0f, + 0x1f, 0x3f, 0x7f, 0x7f, 0x00, 0x00, 0x03, 0x0c, 0x10, 0x20, 0x40, 0x40, + 0x00, 0x00, 0xc0, 0xf0, 0xf8, 0xfc, 0xfe, 0xfe, 0x00, 0x00, 0xc0, 0x30, + 0x08, 0x04, 0x02, 0x02, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, + 0x7f, 0x7f, 0x7f, 0x3f, 0x3f, 0x1f, 0x0f, 0x07, 0x40, 0x40, 0x40, 0x20, + 0x30, 0x1c, 0x0f, 0x07, 0xfe, 0xfe, 0xfe, 0xfc, 0xfc, 0xf8, 0xf0, 0xf0, + 0x02, 0x02, 0x02, 0x04, 0x0c, 0x38, 0xf0, 0xf0, 0x0f, 0x0f, 0x0f, 0x0f, + 0x0f, 0x0f, 0x07, 0x0f, 0x08, 0x08, 0x08, 0x08, 0x08, 0x0c, 0x05, 0x0a, + 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xe0, 0xf0, 0x10, 0x50, 0x50, 0x50, + 0x50, 0x30, 0xa0, 0x50, 0x81, 0xc1, 0xa3, 0xa3, 0x9d, 0x81, 0x81, 0x81, + 0x00, 0x41, 0x22, 0x22, 0x1c, 0x00, 0x00, 0x00, 0xe3, 0xf7, 0xc1, 0xc1, + 0xc1, 0xc1, 0xf7, 0xe3, 0xe3, 0x14, 0x3e, 0x3e, 0x3e, 0x3e, 0x14, 0xe3, + 0x00, 0x00, 0x07, 0x0f, 0x0c, 0x1b, 0x1b, 0x1b, 0xff, 0xff, 0xf8, 0xf0, + 0xf0, 0xe0, 0xe0, 0xe0, 0x00, 0x00, 0xe0, 0xf0, 0xf0, 0xf8, 0xf8, 0xf8, + 0xff, 0xff, 0x7f, 0x3f, 0x3f, 0x9f, 0x9f, 0x9f, 0x1b, 0x1b, 0x1b, 0x1b, + 0x1b, 0x0f, 0x0f, 0x07, 0xe0, 0xe0, 0xe0, 0xe0, 0xe0, 0xf3, 0xf0, 0xf8, + 0xf8, 0xf8, 0xf8, 0xf8, 0xf8, 0xf0, 0xf0, 0xe0, 0x9f, 0x9f, 0x9f, 0x9f, + 0x9f, 0x3f, 0x3f, 0x7f, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x70, 0x1f, 0x10, 0x70, 0x7f, 0x7f, 0x7f, 0x07, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x03, 0xf8, 0x00, 0x03, 0xfb, 0xfb, 0xfb, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xff, 0xef, 0x7c, 0x7b, 0x76, 0x75, + 0x75, 0x77, 0x17, 0x67, 0xff, 0xdf, 0xef, 0xaf, 0xaf, 0x6f, 0xef, 0xe7, + 0x3b, 0xfb, 0x7b, 0xfb, 0xfb, 0xf3, 0xf8, 0xf3, 0x1f, 0x1f, 0x3f, 0x3f, + 0x70, 0x63, 0xe7, 0xe5, 0x0f, 0x0f, 0x1f, 0x1f, 0x3f, 0x3c, 0x78, 0x7a, + 0xf0, 0xf0, 0xf8, 0xf8, 0x0c, 0xc4, 0xe4, 0xa6, 0xf8, 0xf8, 0xfc, 0xfc, + 0xfe, 0x3e, 0x1e, 0x5f, 0xe9, 0xe9, 0xe9, 0xef, 0xe2, 0xe3, 0xf0, 0xff, + 0x76, 0x76, 0x76, 0x70, 0x7d, 0x7c, 0x7f, 0x7f, 0x96, 0x96, 0x96, 0xf6, + 0x46, 0xc6, 0x0e, 0xfe, 0x6f, 0x6f, 0x6f, 0x0f, 0xbf, 0x3f, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x3c, 0x3c, 0x7e, 0x7e, 0xff, + 0xff, 0xff, 0x42, 0x00, 0x3c, 0x42, 0x99, 0xa1, 0xa1, 0x99, 0x42, 0x3c, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x1f, 0x1f, 0x3f, + 0x3f, 0x7f, 0x7f, 0x7f, 0xf0, 0xe0, 0xe0, 0xc0, 0xc0, 0x80, 0x80, 0x80, + 0xf0, 0xf8, 0xf8, 0xfc, 0xfc, 0xfe, 0xfe, 0xfe, 0x0f, 0x07, 0x07, 0x03, + 0x03, 0x01, 0x01, 0x01, 0x7f, 0x7f, 0x3f, 0x3f, 0x3f, 0x3f, 0x1f, 0x1f, + 0x80, 0x80, 0xc0, 0xc0, 0xe0, 0xf8, 0xfe, 0xff, 0xfe, 0xff, 0xff, 0xff, + 0xfc, 0xfc, 0xfe, 0xfe, 0xff, 0x7f, 0x1f, 0x07, 0x03, 0x03, 0x01, 0x81, + 0x7f, 0x7f, 0x7f, 0x3f, 0x3f, 0x3f, 0x3f, 0x1f, 0x80, 0x80, 0x80, 0xc0, + 0xc0, 0xe0, 0xe0, 0xf0, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe, + 0x01, 0x01, 0x01, 0x03, 0x03, 0x07, 0x07, 0x0f, 0x1f, 0x0f, 0x0f, 0x07, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xfc, 0xfc, 0xf8, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x01, 0x01, 0x01, 0x03, 0x03, 0x07, 0x07, 0x0f, + 0xfe, 0xfe, 0xfe, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x01, 0x01, 0x01, 0x01, + 0x01, 0x01, 0x01, 0x01, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xff, 0xff, 0xff, 0xff, + 0xfc, 0xfe, 0xfe, 0x7e, 0xff, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, + 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xfe, 0x01, 0x01, 0x01, 0x03, 0x07, 0x03, 0x01, 0x01, + 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x3f, 0x3f, 0x3f, 0x3f, 0x00, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7e, 0x7c, 0x7c, 0x78, + 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xfe, 0xfe, 0xff, 0xff, 0x7f, 0x7f, 0x7f, 0x7f, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x7f, 0x7f, 0x3f, 0x3f, 0x3f, 0x3f, 0x1f, 0x1f, + 0x80, 0x80, 0xc0, 0xc0, 0xe0, 0xf8, 0xfe, 0xff, 0x3f, 0xbf, 0xff, 0xff, + 0xfc, 0xfc, 0xfe, 0xfe, 0xff, 0x7f, 0x1f, 0x07, 0x03, 0x03, 0x01, 0x81, + 0x7f, 0x7f, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, 0x81, 0x81, 0x81, 0x81, + 0x81, 0x81, 0x81, 0x81, 0x7e, 0x7e, 0x7e, 0x7e, 0x7f, 0x7f, 0x7f, 0x7f, + 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0x81, 0xc3, 0xc3, 0xe7, + 0xe7, 0xff, 0xff, 0xff, 0x7e, 0x3c, 0x3c, 0x18, 0x18, 0x00, 0x00, 0x00, + 0x0f, 0x43, 0x5b, 0x53, 0x31, 0x19, 0x0f, 0x07, 0xf2, 0xfe, 0xfe, 0xff, + 0xff, 0xef, 0xf7, 0xf8, 0xc1, 0xc3, 0xc6, 0x84, 0xfc, 0xfc, 0x0e, 0x02, + 0xbf, 0xbe, 0xbd, 0x7b, 0x7b, 0x07, 0xf3, 0xfd, 0x10, 0x20, 0x22, 0xba, + 0xe6, 0xe1, 0xc0, 0xc0, 0xff, 0xff, 0xff, 0x67, 0x59, 0x9e, 0xbf, 0xbf, + 0x20, 0xa6, 0x54, 0x26, 0x20, 0xc6, 0x54, 0x26, 0x20, 0xe6, 0x54, 0x26, + 0x21, 0x06, 0x54, 0x26, 0x20, 0x85, 0x01, 0x44, 0x20, 0x86, 0x54, 0x48, + 0x20, 0x9a, 0x01, 0x49, 0x20, 0xa5, 0xc9, 0x46, 0x20, 0xba, 0xc9, 0x4a, + 0x20, 0xa6, 0x0a, 0xd0, 0xd1, 0xd8, 0xd8, 0xde, 0xd1, 0xd0, 0xda, 0xde, + 0xd1, 0x20, 0xc6, 0x0a, 0xd2, 0xd3, 0xdb, 0xdb, 0xdb, 0xd9, 0xdb, 0xdc, + 0xdb, 0xdf, 0x20, 0xe6, 0x0a, 0xd4, 0xd5, 0xd4, 0xd9, 0xdb, 0xe2, 0xd4, + 0xda, 0xdb, 0xe0, 0x21, 0x06, 0x0a, 0xd6, 0xd7, 0xd6, 0xd7, 0xe1, 0x26, + 0xd6, 0xdd, 0xe1, 0xe1, 0x21, 0x26, 0x14, 0xd0, 0xe8, 0xd1, 0xd0, 0xd1, + 0xde, 0xd1, 0xd8, 0xd0, 0xd1, 0x26, 0xde, 0xd1, 0xde, 0xd1, 0xd0, 0xd1, + 0xd0, 0xd1, 0x26, 0x21, 0x46, 0x14, 0xdb, 0x42, 0x42, 0xdb, 0x42, 0xdb, + 0x42, 0xdb, 0xdb, 0x42, 0x26, 0xdb, 0x42, 0xdb, 0x42, 0xdb, 0x42, 0xdb, + 0x42, 0x26, 0x21, 0x66, 0x46, 0xdb, 0x21, 0x6c, 0x0e, 0xdf, 0xdb, 0xdb, + 0xdb, 0x26, 0xdb, 0xdf, 0xdb, 0xdf, 0xdb, 0xdb, 0xe4, 0xe5, 0x26, 0x21, + 0x86, 0x14, 0xdb, 0xdb, 0xdb, 0xde, 0x43, 0xdb, 0xe0, 0xdb, 0xdb, 0xdb, + 0x26, 0xdb, 0xe3, 0xdb, 0xe0, 0xdb, 0xdb, 0xe6, 0xe3, 0x26, 0x21, 0xa6, + 0x14, 0xdb, 0xdb, 0xdb, 0xdb, 0x42, 0xdb, 0xdb, 0xdb, 0xd4, 0xd9, 0x26, + 0xdb, 0xd9, 0xdb, 0xdb, 0xd4, 0xd9, 0xd4, 0xd9, 0xe7, 0x21, 0xc5, 0x16, + 0x5f, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x95, 0x97, 0x98, 0x78, + 0x95, 0x96, 0x95, 0x95, 0x97, 0x98, 0x97, 0x98, 0x95, 0x7a, 0x21, 0xed, + 0x0e, 0xcf, 0x01, 0x09, 0x08, 0x05, 0x24, 0x17, 0x12, 0x17, 0x1d, 0x0e, + 0x17, 0x0d, 0x18, 0x22, 0x4b, 0x0d, 0x01, 0x24, 0x19, 0x15, 0x0a, 0x22, + 0x0e, 0x1b, 0x24, 0x10, 0x0a, 0x16, 0x0e, 0x22, 0x8b, 0x0d, 0x02, 0x24, + 0x19, 0x15, 0x0a, 0x22, 0x0e, 0x1b, 0x24, 0x10, 0x0a, 0x16, 0x0e, 0x22, + 0xec, 0x04, 0x1d, 0x18, 0x19, 0x28, 0x22, 0xf6, 0x01, 0x00, 0x23, 0xc9, + 0x56, 0x55, 0x23, 0xe2, 0x04, 0x99, 0xaa, 0xaa, 0xaa, 0x23, 0xea, 0x04, + 0x99, 0xaa, 0xaa, 0xaa, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, + 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff +}; +unsigned int rom_mario_nes_len = 40976; diff --git a/am-kernels/kernels/litenes/src/memory.c b/am-kernels/kernels/litenes/src/memory.c new file mode 100644 index 0000000..3f1c7b6 --- /dev/null +++ b/am-kernels/kernels/litenes/src/memory.c @@ -0,0 +1,41 @@ +#include "memory.h" +#include "cpu.h" +#include "ppu.h" +#include "psg.h" + +byte memory_readb(word address) { + switch (address >> 13) { + case 0: return cpu_ram_read(address & 0x07FF); + case 1: return ppuio_read(address); + case 2: return psgio_read(address); + case 3: return cpu_ram_read(address & 0x1FFF); + default: return mmc_read(address); + } +} + +void memory_writeb(word address, byte data) { + // DMA transfer + int i; + if (address == 0x4014) { + for (i = 0; i < 256; i++) { + ppu_sprram_write(cpu_ram_read((0x100 * data) + i)); + } + return; + } + switch (address >> 13) { + case 0: return cpu_ram_write(address & 0x07FF, data); + case 1: return ppuio_write(address, data); + case 2: return psgio_write(address, data); + case 3: return cpu_ram_write(address & 0x1FFF, data); + default: return mmc_write(address, data); + } +} + +word memory_readw(word address) { + return memory_readb(address) + (memory_readb(address + 1) << 8); +} + +void memory_writew(word address, word data) { + memory_writeb(address, data & 0xFF); + memory_writeb(address + 1, data >> 8); +} diff --git a/am-kernels/kernels/litenes/src/memory.h b/am-kernels/kernels/litenes/src/memory.h new file mode 100644 index 0000000..1d461b4 --- /dev/null +++ b/am-kernels/kernels/litenes/src/memory.h @@ -0,0 +1,15 @@ +#ifndef MEM_H +#define MEM_H + +#include "common.h" +#include "mmc.h" + +// Single byte +byte memory_readb(word address); +void memory_writeb(word address, byte data); + +// Two bytes (word), LSB first +word memory_readw(word address); +void memory_writew(word address, word data); + +#endif diff --git a/am-kernels/kernels/litenes/src/mmc.c b/am-kernels/kernels/litenes/src/mmc.c new file mode 100644 index 0000000..b60f2e7 --- /dev/null +++ b/am-kernels/kernels/litenes/src/mmc.c @@ -0,0 +1,31 @@ +#include "mmc.h" +#include "ppu.h" +#include + +byte mmc_id; +#define MMC_MAX_PAGE_COUNT 1 + +static byte mmc_chr_pages[MMC_MAX_PAGE_COUNT][0x2000]; +static int mmc_chr_pages_number; + +byte memory[0x10000]; + +byte mmc_read(word address) { + return memory[address]; +} + +void mmc_write(word address, byte data) { + switch (mmc_id) { + case 0x3: ppu_copy(0x0000, &mmc_chr_pages[data & 3][0], 0x2000); break; + } + memory[address] = data; +} + +void mmc_copy(word address, byte *source, int length) { + memcpy(&memory[address], source, length); +} + +void mmc_append_chr_rom_page(byte *source) { + assert(mmc_chr_pages_number < MMC_MAX_PAGE_COUNT); + memcpy(&mmc_chr_pages[mmc_chr_pages_number++][0], source, 0x2000); +} diff --git a/am-kernels/kernels/litenes/src/mmc.h b/am-kernels/kernels/litenes/src/mmc.h new file mode 100644 index 0000000..3376ce1 --- /dev/null +++ b/am-kernels/kernels/litenes/src/mmc.h @@ -0,0 +1,8 @@ +#include "common.h" + +extern byte mmc_id; + +byte mmc_read(word address); +void mmc_write(word address, byte data); +void mmc_copy(word address, byte *source, int length); +void mmc_append_chr_rom_page(byte *source); diff --git a/am-kernels/kernels/litenes/src/ppu.c b/am-kernels/kernels/litenes/src/ppu.c new file mode 100644 index 0000000..b65976a --- /dev/null +++ b/am-kernels/kernels/litenes/src/ppu.c @@ -0,0 +1,432 @@ +#include "ppu.h" +#include "cpu.h" +#include "fce.h" +#include "memory.h" +#include + +//#define PROFILE +//#define HAS_US_TIMER + +PPU_STATE ppu; + +static bool ppu_2007_first_read; +static byte ppu_addr_latch; +static byte PPU_SPRRAM[0x100]; +static byte PPU_RAM[0x4000]; +static bool ppu_sprite_hit_occured = false; +static byte ppu_latch; + +// PPU Constants +static const word ppu_base_nametable_addresses[4] = { 0x2000, 0x2400, 0x2800, 0x2C00 }; + +// For sprite-0-hit checks +static byte ppu_screen_background[264][248]; + +// Precalculated tile high and low bytes addition for pattern tables +static byte ppu_l_h_addition_table[256][256][8]; +static byte ppu_l_h_addition_flip_table[256][256][8]; + + +// PPUCTRL Functions + +word ppu_base_nametable_address() { return ppu_base_nametable_addresses[ppu.PPUCTRL & 0x3]; } +byte ppu_vram_address_increment() { return common_bit_set(ppu.PPUCTRL, 2) ? 32 : 1; } +word ppu_sprite_pattern_table_address() { return common_bit_set(ppu.PPUCTRL, 3) ? 0x1000 : 0x0000; } +word ppu_background_pattern_table_address() { return common_bit_set(ppu.PPUCTRL, 4) ? 0x1000 : 0x0000; } +byte ppu_sprite_height() { return common_bit_set(ppu.PPUCTRL, 5) ? 16 : 8; } +bool ppu_generates_nmi() { return common_bit_set(ppu.PPUCTRL, 7); } + +// PPUMASK Functions + +bool ppu_renders_grayscale() { return common_bit_set(ppu.PPUMASK, 0); } +bool ppu_shows_background_in_leftmost_8px() { return common_bit_set(ppu.PPUMASK, 1); } +bool ppu_shows_sprites_in_leftmost_8px() { return common_bit_set(ppu.PPUMASK, 2); } +bool ppu_shows_background() { return common_bit_set(ppu.PPUMASK, 3); } +bool ppu_shows_sprites() { return common_bit_set(ppu.PPUMASK, 4); } +bool ppu_intensifies_reds() { return common_bit_set(ppu.PPUMASK, 5); } +bool ppu_intensifies_greens() { return common_bit_set(ppu.PPUMASK, 6); } +bool ppu_intensifies_blues() { return common_bit_set(ppu.PPUMASK, 7); } + +void ppu_set_renders_grayscale(bool yesno) { common_modify_bitb(&ppu.PPUMASK, 0, yesno); } +void ppu_set_shows_background_in_leftmost_8px(bool yesno) { common_modify_bitb(&ppu.PPUMASK, 1, yesno); } +void ppu_set_shows_sprites_in_leftmost_8px(bool yesno) { common_modify_bitb(&ppu.PPUMASK, 2, yesno); } +void ppu_set_shows_background(bool yesno) { common_modify_bitb(&ppu.PPUMASK, 3, yesno); } +void ppu_set_shows_sprites(bool yesno) { common_modify_bitb(&ppu.PPUMASK, 4, yesno); } +void ppu_set_intensifies_reds(bool yesno) { common_modify_bitb(&ppu.PPUMASK, 5, yesno); } +void ppu_set_intensifies_greens(bool yesno) { common_modify_bitb(&ppu.PPUMASK, 6, yesno); } +void ppu_set_intensifies_blues(bool yesno) { common_modify_bitb(&ppu.PPUMASK, 7, yesno); } + +// PPUSTATUS Functions + +bool ppu_sprite_overflow() { return common_bit_set(ppu.PPUSTATUS, 5); } +bool ppu_sprite_0_hit() { return common_bit_set(ppu.PPUSTATUS, 6); } +bool ppu_in_vblank() { return common_bit_set(ppu.PPUSTATUS, 7); } + +void ppu_set_sprite_overflow(bool yesno) { common_modify_bitb(&ppu.PPUSTATUS, 5, yesno); } +void ppu_set_sprite_0_hit(bool yesno) { common_modify_bitb(&ppu.PPUSTATUS, 6, yesno); } +void ppu_set_in_vblank(bool yesno) { common_modify_bitb(&ppu.PPUSTATUS, 7, yesno); } + + +// RAM + +word ppu_get_real_ram_address(word address) { + if (address < 0x2000) { return address; } + else if (address < 0x3F00) { + if (address < 0x3000) { return address; } + else { return address; } + } + else if (address < 0x4000) { + address = 0x3F00 | (address & 0x1F); + if (address == 0x3F10 || address == 0x3F14 || address == 0x3F18 || address == 0x3F1C) + address -= 0x10; + return address; + } + return 0xFFFF; +} + +byte ppu_ram_read(word address) { + return PPU_RAM[ppu_get_real_ram_address(address)]; +} + +void ppu_ram_write(word address, byte data) { + PPU_RAM[ppu_get_real_ram_address(address)] = data; +} + +// 3F01 = 0F (00001111) +// 3F02 = 2A (00101010) +// 3F03 = 09 (00001001) +// 3F04 = 07 (00000111) +// 3F05 = 0F (00001111) +// 3F06 = 30 (00110000) +// 3F07 = 27 (00100111) +// 3F08 = 15 (00010101) +// 3F09 = 0F (00001111) +// 3F0A = 30 (00110000) +// 3F0B = 02 (00000010) +// 3F0C = 21 (00100001) +// 3F0D = 0F (00001111) +// 3F0E = 30 (00110000) +// 3F0F = 00 (00000000) +// 3F11 = 0F (00001111) +// 3F12 = 16 (00010110) +// 3F13 = 12 (00010010) +// 3F14 = 37 (00110111) +// 3F15 = 0F (00001111) +// 3F16 = 12 (00010010) +// 3F17 = 16 (00010110) +// 3F18 = 37 (00110111) +// 3F19 = 0F (00001111) +// 3F1A = 17 (00010111) +// 3F1B = 11 (00010001) +// 3F1C = 35 (00110101) +// 3F1D = 0F (00001111) +// 3F1E = 17 (00010111) +// 3F1F = 11 (00010001) +// 3F20 = 2B (00101011) + + +// Rendering + +void ppu_draw_background_scanline(bool mirror) { + int tile_x; + for (tile_x = ppu_shows_background_in_leftmost_8px() ? 0 : 1; tile_x < 32; tile_x ++) { + // Skipping off-screen pixels + if (((tile_x << 3) - ppu.PPUSCROLL_X + (mirror ? 256 : 0)) > 256) + continue; + + int tile_y = ppu.scanline >> 3; + int tile_index = ppu_ram_read(ppu_base_nametable_address() + tile_x + (tile_y << 5) + (mirror ? 0x400 : 0)); + word tile_address = ppu_background_pattern_table_address() + 16 * tile_index; + + int y_in_tile = ppu.scanline & 0x7; + byte l = ppu_ram_read(tile_address + y_in_tile); + byte h = ppu_ram_read(tile_address + y_in_tile + 8); + + int x; + for (x = 0; x < 8; x ++) { + byte color = ppu_l_h_addition_table[l][h][x]; + + // Color 0 is transparent + if (color != 0) { + word attribute_address = (ppu_base_nametable_address() + (mirror ? 0x400 : 0) + 0x3C0 + (tile_x >> 2) + (ppu.scanline >> 5) * 8); + bool top = (ppu.scanline % 32) < 16; + bool left = (tile_x % 4 < 2); + + byte palette_attribute = ppu_ram_read(attribute_address); + + if (!top) { palette_attribute >>= 4; } + if (!left) { palette_attribute >>= 2; } + palette_attribute &= 3; + + word palette_address = 0x3F00 + (palette_attribute << 2); + int idx = ppu_ram_read(palette_address + color); + + ppu_screen_background[(tile_x << 3) + x][ppu.scanline] = color; + + draw((tile_x << 3) + x - ppu.PPUSCROLL_X + (mirror ? 256 : 0), ppu.scanline + 1, idx); // bg + } + } + } +} + +void ppu_draw_sprite_scanline() { + int scanline_sprite_count = 0; + int n; + for (n = 0; n < 0x100; n += 4) { + byte sprite_x = PPU_SPRRAM[n + 3]; + byte sprite_y = PPU_SPRRAM[n]; + + // Skip if sprite not on scanline + if (sprite_y > ppu.scanline || sprite_y + ppu_sprite_height() < ppu.scanline) + continue; + + scanline_sprite_count++; + + // PPU can't render > 8 sprites + if (scanline_sprite_count > 8) { + ppu_set_sprite_overflow(true); + // break; + } + + bool vflip = PPU_SPRRAM[n + 2] & 0x80; + bool hflip = PPU_SPRRAM[n + 2] & 0x40; + + word tile_address = ppu_sprite_pattern_table_address() + 16 * PPU_SPRRAM[n + 1]; + int y_in_tile = ppu.scanline & 0x7; + byte l = ppu_ram_read(tile_address + (vflip ? (7 - y_in_tile) : y_in_tile)); + byte h = ppu_ram_read(tile_address + (vflip ? (7 - y_in_tile) : y_in_tile) + 8); + + byte palette_attribute = PPU_SPRRAM[n + 2] & 0x3; + word palette_address = 0x3F10 + (palette_attribute << 2); + int x; + for (x = 0; x < 8; x ++) { + int color = hflip ? ppu_l_h_addition_flip_table[l][h][x] : ppu_l_h_addition_table[l][h][x]; + + // Color 0 is transparent + if (color != 0) { + int screen_x = sprite_x + x; + int idx = ppu_ram_read(palette_address + color); + + // FIXME: we do not distinguish bbg and fg here to improve performance + if (PPU_SPRRAM[n + 2] & 0x20) { + draw(screen_x, sprite_y + y_in_tile + 1, idx); // bbg + } + else { + draw(screen_x, sprite_y + y_in_tile + 1, idx); // fg + } + + // Checking sprite 0 hit + if (ppu_shows_background() && !ppu_sprite_hit_occured && n == 0 && ppu_screen_background[screen_x][sprite_y + y_in_tile] == color) { + ppu_set_sprite_0_hit(true); + ppu_sprite_hit_occured = true; + } + } + } + } +} + +// PPU Lifecycle + +void ppu_run(int cycles) { + while (cycles-- > 0) { ppu_cycle(); } +} + +static uint32_t background_time, sprite_time, cpu_time; +#ifdef PROFILE +#ifdef HAS_US_TIMER +# define TIMER_UNIT "us" +# define time_read(x) read_us(&x) +# define time_diff(t1, t0) us_timediff(&t1, &t0) +# define TIME_TYPE amtime +#else +# define TIMER_UNIT "ms" +# define time_read(x) x = uptime() +# define time_diff(t1, t0) (t1 - t0) +# define TIME_TYPE uint32_t +#endif +#else +# define time_read(x) +# define time_diff(t1, t0) 0 +#endif + +void ppu_cycle() { +#ifdef PROFILE + TIME_TYPE t0, t1, t2, t3, t4, t5; +#endif + + if (!ppu.ready && cpu_clock() > 29658) + ppu.ready = true; + + time_read(t0); + cpu_run(256); + time_read(t1); + + ppu.scanline++; + + if (ppu.scanline < SCR_H && ppu_shows_background()) { + ppu_draw_background_scanline(false); + ppu_draw_background_scanline(true); + } + + time_read(t2); + cpu_run(85 - 16); + time_read(t3); + + if (ppu.scanline < SCR_H && ppu_shows_sprites()) { + ppu_draw_sprite_scanline(); + } + + time_read(t4); + cpu_run(16); + time_read(t5); + + cpu_time += time_diff(t1, t0) + time_diff(t3, t2) + time_diff(t5, t4); + background_time += time_diff(t2, t1); + sprite_time += time_diff(t4, t3); + + if (ppu.scanline == 241) { + ppu_set_in_vblank(true); + ppu_set_sprite_0_hit(false); + cpu_interrupt(); + } + else if (ppu.scanline == 262) { + ppu.scanline = -1; + ppu_sprite_hit_occured = false; + ppu_set_in_vblank(false); + + time_read(t0); + fce_update_screen(); + time_read(t1); + +#ifdef PROFILE + uint32_t total = cpu_time + background_time + sprite_time + time_diff(t1, t0); + printf("Time: cpu + bg + spr + scr = (%d + %d + %d + %d)\t= %d %s\n", + cpu_time, background_time, sprite_time, time_diff(t1, t0), total, TIMER_UNIT); +#endif + cpu_time = 0; + background_time = 0; + sprite_time = 0; + } +} + +void ppu_copy(word address, byte *source, int length) { + memcpy(&PPU_RAM[address], source, length); +} + +byte ppuio_read(word address) { + ppu.PPUADDR &= 0x3FFF; + switch (address & 7) { + case 2: + { + byte value = ppu.PPUSTATUS; + ppu_set_in_vblank(false); + ppu_set_sprite_0_hit(false); + ppu.scroll_received_x = 0; + ppu.PPUSCROLL = 0; + ppu.addr_received_high_byte = 0; + ppu_latch = value; + ppu_addr_latch = 0; + ppu_2007_first_read = true; + return value; + } + case 4: return ppu_latch = PPU_SPRRAM[ppu.OAMADDR]; + case 7: + { + byte data; + + if (ppu.PPUADDR < 0x3F00) { + data = ppu_latch = ppu_ram_read(ppu.PPUADDR); + } + else { + data = ppu_ram_read(ppu.PPUADDR); + ppu_latch = 0; + } + + if (ppu_2007_first_read) { + ppu_2007_first_read = false; + } + else { + ppu.PPUADDR += ppu_vram_address_increment(); + } + return data; + } + default: return 0xFF; + } +} + +void ppuio_write(word address, byte data) { + address &= 7; + ppu_latch = data; + ppu.PPUADDR &= 0x3FFF; + switch(address) { + case 0: if (ppu.ready) ppu.PPUCTRL = data; break; + case 1: if (ppu.ready) ppu.PPUMASK = data; break; + case 3: ppu.OAMADDR = data; break; + case 4: PPU_SPRRAM[ppu.OAMADDR++] = data; break; + case 5: + { + if (ppu.scroll_received_x) + ppu.PPUSCROLL_Y = data; + else + ppu.PPUSCROLL_X = data; + + ppu.scroll_received_x ^= 1; + break; + } + case 6: + { + if (!ppu.ready) + return; + + if (ppu.addr_received_high_byte) + ppu.PPUADDR = (ppu_addr_latch << 8) + data; + else + ppu_addr_latch = data; + + ppu.addr_received_high_byte ^= 1; + ppu_2007_first_read = true; + break; + } + case 7: + { + if (ppu.PPUADDR > 0x1FFF || ppu.PPUADDR < 0x4000) { + ppu_ram_write(ppu.PPUADDR ^ ppu.mirroring_xor, data); + ppu_ram_write(ppu.PPUADDR, data); + } + else { + ppu_ram_write(ppu.PPUADDR, data); + } + } + } + ppu_latch = data; +} + +void ppu_init() { + ppu.PPUCTRL = ppu.PPUMASK = ppu.PPUSTATUS = ppu.OAMADDR = ppu.PPUSCROLL_X = ppu.PPUSCROLL_Y = ppu.PPUADDR = 0; + ppu.PPUSTATUS |= 0xA0; + ppu.PPUDATA = 0; + ppu_2007_first_read = true; + + // Initializing low-high byte-pairs for pattern tables + int h, l, x; + for (h = 0; h < 0x100; h ++) { + for (l = 0; l < 0x100; l ++) { + for (x = 0; x < 8; x ++) { + ppu_l_h_addition_table[l][h][x] = (((h >> (7 - x)) & 1) << 1) | ((l >> (7 - x)) & 1); + ppu_l_h_addition_flip_table[l][h][x] = (((h >> x) & 1) << 1) | ((l >> x) & 1); + } + } + } +} + +void ppu_sprram_write(byte data) { + PPU_SPRRAM[ppu.OAMADDR++] = data; +} + +void ppu_set_background_color(byte color) { +} + +void ppu_set_mirroring(byte mirroring) { + ppu.mirroring = mirroring; + ppu.mirroring_xor = 0x400 << mirroring; +} diff --git a/am-kernels/kernels/litenes/src/ppu.h b/am-kernels/kernels/litenes/src/ppu.h new file mode 100644 index 0000000..cc21200 --- /dev/null +++ b/am-kernels/kernels/litenes/src/ppu.h @@ -0,0 +1,41 @@ +#ifndef PPU_H +#define PPU_H + +#include "common.h" + +typedef struct { + byte PPUCTRL; // $2000 write only + byte PPUMASK; // $2001 write only + byte PPUSTATUS; // $2002 read only + byte OAMADDR; // $2003 write only + byte OAMDATA; // $2004 + word PPUSCROLL; + byte PPUSCROLL_X, PPUSCROLL_Y; // $2005 write only x2 + word PPUADDR; // $2006 write only x2 + word PPUDATA; // $2007 + + bool scroll_received_x; + bool addr_received_high_byte; + bool ready; + + int mirroring, mirroring_xor; + + int x, scanline; +} PPU_STATE; + +void ppu_init(); + +byte ppu_ram_read(word address); +void ppu_ram_write(word address, byte data); +byte ppuio_read(word address); +void ppuio_write(word address, byte data); + +bool ppu_generates_nmi(); + +void ppu_set_mirroring(byte mirroring); + +void ppu_cycle(); +void ppu_copy(word address, byte *source, int length); +void ppu_sprram_write(byte data); + +#endif diff --git a/am-kernels/kernels/litenes/src/psg.c b/am-kernels/kernels/litenes/src/psg.c new file mode 100644 index 0000000..0c67397 --- /dev/null +++ b/am-kernels/kernels/litenes/src/psg.c @@ -0,0 +1,54 @@ +#include "psg.h" +#include + +static int p = 10; +static int key_state[256]; + +#define KEYS \ + CONCAT(AM_KEY_, KEY_A), \ + CONCAT(AM_KEY_, KEY_B), \ + CONCAT(AM_KEY_, KEY_SELECT), \ + CONCAT(AM_KEY_, KEY_START), \ + CONCAT(AM_KEY_, KEY_UP), \ + CONCAT(AM_KEY_, KEY_DOWN), \ + CONCAT(AM_KEY_, KEY_LEFT), \ + CONCAT(AM_KEY_, KEY_RIGHT), + +static int MAP[256] = { + 0, // On/Off + KEYS + 255, +}; + +byte psgio_read(word address) { + // Joystick 1 + if (address == 0x4016) { + if (p++ < 9) { + return key_state[MAP[p]]; + } + } + return 0; +} + +void psgio_write(word address, byte data) { + static byte prev_write; + if (address == 0x4016) { + if ((data & 1) == 0 && prev_write == 1) { + // strobe + p = 0; + } + } + prev_write = data & 1; +} + +void psg_detect_key() { + while (1) { + AM_INPUT_KEYBRD_T ev = io_read(AM_INPUT_KEYBRD); + if (ev.keycode == AM_KEY_NONE) break; + key_state[ev.keycode] = ev.keydown; + } +} + +void psg_init() { + key_state[0] = 1; +} diff --git a/am-kernels/kernels/litenes/src/psg.h b/am-kernels/kernels/litenes/src/psg.h new file mode 100644 index 0000000..49e0fa9 --- /dev/null +++ b/am-kernels/kernels/litenes/src/psg.h @@ -0,0 +1,20 @@ +#ifndef PSG_H +#define PSG_H + +#include "common.h" + +#define KEY_A J +#define KEY_B K +#define KEY_SELECT U +#define KEY_START I +#define KEY_UP W +#define KEY_DOWN S +#define KEY_LEFT A +#define KEY_RIGHT D + +byte psgio_read(word address); +void psgio_write(word address, byte data); +void psg_init(); +void psg_detect_key(); + +#endif diff --git a/am-kernels/kernels/nemu/Makefile b/am-kernels/kernels/nemu/Makefile new file mode 100644 index 0000000..deb8a14 --- /dev/null +++ b/am-kernels/kernels/nemu/Makefile @@ -0,0 +1,31 @@ +ARCH_SPLIT = $(subst -, ,$(ARCH)) +ISA = $(word 1,$(ARCH_SPLIT)) +PLATFORM = $(word 2,$(ARCH_SPLIT)) + +ifneq ($(PLATFORM), nemu) +$(error Only support with NEMU) +endif + +TMPDEFCONFIG = tmp_defconfig +TMPDEFCONFIG_FILE = $(NEMU_HOME)/configs/$(TMPDEFCONFIG) + +all: + $(MAKE) save_config + $(MAKE) build_am + $(MAKE) restore_config + $(MAKE) -C $(NEMU_HOME) run IMG=$(NEMU_HOME)/build/$(ISA)-nemu-interpreter-$(ARCH).bin + +save_config: + $(MAKE) -C $(NEMU_HOME) savedefconfig + mv $(NEMU_HOME)/configs/defconfig $(TMPDEFCONFIG_FILE) + +build_am: + $(MAKE) -C $(NEMU_HOME) $(ISA)-am_defconfig + $(MAKE) -C $(NEMU_HOME) ARCH=$(ARCH) mainargs=$(mainargs) || \ + ($(MAKE) restore_config; false) + +restore_config: + $(MAKE) -C $(NEMU_HOME) ARCH=$(ARCH) $(TMPDEFCONFIG) + rm $(TMPDEFCONFIG_FILE) + +.PHONY: all save_config build_am restore_config diff --git a/am-kernels/kernels/slider/Makefile b/am-kernels/kernels/slider/Makefile new file mode 100644 index 0000000..1f20441 --- /dev/null +++ b/am-kernels/kernels/slider/Makefile @@ -0,0 +1,3 @@ +NAME = slider +SRCS = main.c image.S +include $(AM_HOME)/Makefile diff --git a/am-kernels/kernels/slider/image.S b/am-kernels/kernels/slider/image.S new file mode 100644 index 0000000..0bd41ed --- /dev/null +++ b/am-kernels/kernels/slider/image.S @@ -0,0 +1,7 @@ +.section .data +.global image, image_end +.p2align 3 +image: +.incbin "images/projectn.bin" +.incbin "images/litenes.bin" +image_end: diff --git a/am-kernels/kernels/slider/images/.gitignore b/am-kernels/kernels/slider/images/.gitignore new file mode 100644 index 0000000..1eb37dc --- /dev/null +++ b/am-kernels/kernels/slider/images/.gitignore @@ -0,0 +1 @@ +!*.bin diff --git a/am-kernels/kernels/slider/images/litenes.bin b/am-kernels/kernels/slider/images/litenes.bin new file mode 100644 index 0000000..b3fe1f8 --- /dev/null +++ b/am-kernels/kernels/slider/images/litenes.bin @@ -0,0 +1,1583 @@ +}~{~~|}|}svz  %%!"& !!&! 6ƐЈƆ{ɂx΅}ʅ|„zĆ~Ä|ƅ}dž~ǃ|Ї΅}ʇ~„yΉф{ͅ}˃{Ά~ͅ}ȃz͈Łzņ~Å}ŇĆ|ăz͈΅}΀yՅ~ȅ|ʅ|̄|ʅ|Ɔ{Ɔ{Ȇ{̅{τ{̅{Ć{||Ć|у|ځ}̅{ʅ{Ȇ{ƅ|ȅ|ʅ|˅~˅~Ʌ~ʉʇ~͈χӌ͈~ʈ}ĕW94  ?|twtwzwvzzxtzxtxyvzzy{y{{y|z{{vyv~szuvvtxvyvx{wytyu{yyzxwxyywutsؓb3/Cꐉyrrptpurusrtrqpqrptrsutvsuutqstssroslssnupvrqpprrrpqorrxtswrotrorꑇn2,Cuqmnkptx}mtr}noulrroxmnsrnusuprnqqnqrnrrupnsorsvuurorrkurmpsnqmqqqiw1*?trxtrҐ}Ӎ|蝏֍眎ފ~{vrlquqnvloontmtoopxusيwǎyșӛݒ|݅u㑀ނqswrv|蓃ގ}䘆㗅ꘆurqwqy1);듅vwvyylἮڦޞ߀wpporkrvswosqqrmqvr}qżʾƏ°ﴡxtxxfԔ١굡σqwusrw2(5 㕅svu{ہv۪ƬԻսٿƼѠⰤۛԁyluvtttvtsox܀mvprxysv~̱׸ި瑱ޠܮܲyvvsڀoӎ}ߤԤ㻨产ݣԄswvuuq4&  6ߚmvyss篞ǵḩ޲⺮ڴ䲦ƹدIJ~nt{zmö~oݕy|qntru~o~q禘ܠ՗쪟ˊ|χuրnttvppusosރt؁q؁qusqrr~i}l6%  >#梏hpttsଛȹޞۥùם淩ǡ繨䩙ςr~u퓈j\͚խͻմṦќᔄxyoorpx~tꑇҊyqpopooopupw~rs~rssoooo}i7% 'Ġvlvjop~w}|~volmno~q}ttuwtuv߉utuuv{promqornrwsopnjnmpvsyrrrrrrrrrrqsqqtpm2( \\\'''+++000---00*./-,..,./,./,./......,-++,*0/+/.*.+'21-...+*,2.)+)('*.(+/023.,+*((+,0(,1)-2,-1000,*)-+*...+++(.)+1,,./0,8# :ISuVo 40+:1(26/24.//-,*0/ -+1//.,,,**311,**/--1//,**1//*((311+))-++200/--.,,,*).,+0.-.,+-+*421/-,20/1/./-,0.-,*)0.-1/.3101/.000.,,/-,/-,1//.01*+/02311120/732310311(') 8-/К}qvotxwsrnlqtsrssuussttsuttwrssonnuqruopmpqjunqurrrrrrrrrrqsqqtpm2( GGG  &*=h|{} /42}qk{jovmnmnrvtpnrsqporrquptutnpntqrqwvqvssqsptyprrrrrrrrrrqsqqtpm2( JJJ + +      + +  + :dsNia|^r    + +  +  }}} !1*triippooqsrnjoppnpqrqptlsosttrsvvsywrututsmnorrrrrrrrrrqsqqtpm2( JJJ  +        bnu?V 4  +  +  + + + +   |zz"3*ylskqrwtqrtqolmmoppqqqlprqssuyqxn߃v…qygxwoyi܇xuvspqrrrrrrrrrrqsqqtpm2( JJJ    +  +Ra/HQd=     +  }{z 27.ń{sgmrwvsrrqppmpqrtsqoronpp|߆{j^_X|ppf҂{ɘcXڀywxtorrrrrrrrrrqsqqtpm2( HHH  &((jmqY_f    ]x5Vr8>0   zuvupqwrsA<=}xy +  VSOifb|yu +    }|;0(sȴsgvq|wtnjkottsqrrqpqruwvtsqorwu߆|ph㼳tYT|x~wtxrrrrrrrrrrqsqqtpm2( LLL +  +/0.x~xxx*-1    +IakX_5WVX !|||___usr  +{wv +/ É}Ճr`މsvvxmhjmrttqqrurrtwxxwvpsqp{|tzyvprrrrrrrrrrqsqqtpm2( JJJ   \XMHKS999FB=]ZVrtuKNR~ba]}9=B +*/(Ruy05\ +  267,01)-.X\][_`*./)-.!"`de[_`:>?%).,05adiEHMEHL|nqu   +  ~zy" @ᕉrlqqqupkonxvtmmuwnttvw{svpptpxkn`wsqrrrrrrrqrrsqqtpm2( JJJ   +3* +#÷~t½  +hjV'&"uu~}  +qpl_^ZDC?TSO )''   + + +|zy=參rroprouyv~}|nqht|pqrvvytsnrnv|mۢwa݇strrrrrrrrqrrsqqtpm2( JJJ )% i\Nn\\K>g[Q@4(%jtho_Nt^Q>)~lM@0vhV |?CDZXXrdK8#"yk_ |b>|S|YUk^bQf).O=2#A(rs@0)vgW~o_=.K<,B3#p`iZJyp`@1!iZJaRB.rb* hYIj[KYJ:QC1} ~n]|zy<떇puqlmrst|~z~{qgpnzqoourtsprhxmsm˺гѷ̻кɳμػԬörpnsrrrrrrrqrrsqqtpm2( JJJ*#q\N1nQkQ9vaLmZEq\AybBE-kMhL*eFpXf>nGX#f,a5P4kLW,uA`0n?f1i0sDU0nHuQ#h^4f7^-\+e5S#p=`-n;b/l9n:a uH vy}5ꒂnlprp߄ur%T8%gN牄azӬށrtwrststzxwvturqprqwsrsppooqpytqrrrrrrrqrrsqqtpm2( JJJ W(u:{NXr?4 +*l>`(b*h1W o8j4r9\#c*h,Zo4Vl1\!g*c2k=n>Qp8Vk3]{H +sG7%zzz9ꔈrortqn.R@8OF݃`xnfrvvuqwunimtwurrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ   +   P-jBc9i:h9U6   + 1qEl6f0[%p:b,g1d,m5l4c+p6d*n4c)l2k1f3e5d2m8~Ok3j2i+h*oCYE3 + zzz>땉kortt{n}\U(L3LmLq持ebމs|z|zklvwvrpuupkpuwtrrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ    +     H* fG`=a6pDQ.   0c8q;a+["n5h/d+b*l2m3f,p6g*n1e(n1m0d0`,b-o7Vk3i1f(e&e5\G2  +zzz=參uqttqqtkhre~i{idngho||xurrvwsqptuqprwurrrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ + +        N(sLV'b-{IA + +  9wKi-p4q5e)v:zD|?f)m0p3e'v8`"r4f(q3l4Ku>]!z@_'x?e'T}LK3   +  zzz <蒆kouvsrruwuthmrsrvyxuuwuonrttruxuprrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ +   W-s@s:x:n7hD   /j=zBf.MFg,Db'z=w;g+}Ac'~@e'z{Fj3u7~=d1sX=  zzz <蒆ttwurroiehqqvqrostrswzvmmqtttwxtprrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ   + +   + O,zK[!^!L<    2|Pm9l8xCd/|Gr> zEi4p8tf/QLO0 +  zzz<撆qwpnkrpplostqqoqp}yyqmn|xtppqtrqrrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ +  T/ i?~LvBpI\A-  +   7lI~Og8Z+Ti:Tb3~OzKk=Qg7Pj:{KuElAO]"BvCuBn@k3@a+{^?zzz;瓇qponopprroouqpsnr~ycf҄nkttyuqqrrrqrrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ 5!|_iBqAKc3}Qa/}FmB  +    +    #vL!{Df%~?d0vHg2SNM0  zzz9䒇qnpqrrrssvsspptv{og|tfmxywrrttqprrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ 4nAm3w1bv/f"w-lt7:" +             kE"h3r1O n8j:g/m.e/kN/ zzz<䒇ssqokpqutrqknrtyׂx8tcp}{uckyyutuutqprrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ + : q?e+k&m%d#e(k%o!o1(   +   + +        + +      + +kI+j6j(Vb(i7g.c$p:\@!  zzz  3uurrkpmqornnmov|܂.aAk\cshnsxtruwuqprrrrrrrrrrrrrrrrrrrrrrrrqrrsqqtpm2( JJJ9xJh3l2o3c0tDf.s0h2   +    +   + + +  +       gJ/p>`v/k/p;e,Vv=S7   +zzz +7㓈p{xtknlqqqnztr|~Mhh+p4c2jB[0s7f"tA5&  + +   +    +  + + iM*d*v6Ijl2l*w5j7kP6 zzzI 혎yxvwxqozzwqpmt{|vvrpqpstrutrqqruwuutqqrttqpqqqqqrrrrrrrrrqrrsqqtpm2( JJJ 9p=c)g+n9Q6 + + + +  +  + +      +    +   gI,m7h'a#d.o3g"^l:W8!  zzz G +yohrnolekzysolu{vtsqsnkrrywurqqruwxxuqqtwwqpprqqqrrrrrrrrrqrrsqqtpm2( JJJ 9wFh0i1q@O2  +    +  +   +     +  +    gG*o:b!i,f0m1h#Vr@R3  + +zzz8嘅lmrqpprw{|xrxuwssvppoosutwurqqtux|{xrquyxrnprrqrtrrrrrrrrqrrsqqtpm2( JJJ +;og8lO4      +   +  +  +   iH'f.?tEyCl0p*z4g3sT=  zzz 3ᒇpoqttqrw{z|rpvophtppnsqqwxrtpqtшt|eylxkxfcd|cxkсvtnqturrwrrrrrrrrrrssqrspm2( JJJ 9Jq2l/QG(  + +    5' &7  %!' + + 1;tP,Ha Fg2z>l&Q PK- + +zzzþ7璈rqsutqpprutp{qmiiwuqpmqvutxptqvmgkNNwbdwXbKoEOsEVwT\gSvhtnqutqrxrrrrrrrrrrssqrspm2( JJJ8s;l*x8i7jL1   +  +    + +   + +   ";>c{{]F,'0ijs| JZtpQP !Y\mckK0mFh,Bp?vCo5r,x1i4oQ8  zzz9閇lstwurpnnqqutuwriyrqsoouuuupsuv}f6\çNyF!wA?exwgًtmqutqtxrrrrrrrrrrsrqrspm2( JJJ; s=g&m-p;Y5        + +  -XHmmsZ0!7LQr:*-:Sufbd +(u8VW[[?!nEr3_h2b1l4g#[tj4oM)         + +       \^lxX6,)[{qx]Y"TMzrlC4,mjseE#yKg%Ap? nCo;o+x1k1mT4   +zzzԷ@ 铁qijmpttrnoijnlku{^sf΍wrnsrusrnsqv}d\ES@dR [<PE $R.ME>΋qimtrnqxrrrrrrrrrqrrqrspm2( JJJ?Oo:l0HM-  hAV`6dj>U[,j?~]9!   0 +deNrH{Cj;_^=QqZ9 Z'l/h3Z3h#l0^*_+sBD(    +oHi5h4_+k7n:Pm9l8k7j6g3j6f2i5h4k7g1V"l9f6_,c.m5d/]-pJT;! +zzz6ˍքԅӀԅ΄׍ق܇Ӊ؇ڃi~pFSTJUoz憐|}ΎϋшȅʈՅ>aM{j oYP|z҅ӃӆτЃՈ΂؊ŀԇֆςΆфւڇ̂Њ҆ލˁҌчԂ֒b67 JJJ 2 ~aBa=f?b?\D0 W"j%r7nC{6b'o:m5l7W;   + ) w[=lJ|Y7nK)gEzW5rPvS1eCdB}Z8jHwT2lJyV4gE_=^:kHrV4kL[<nL_9c=mJoT9bP?   zzz  .Zizopttng|xwpl}nzgm[tHpHzE~LoC:~Z{si~|}jz_lu{jtiursyaghG{EvL}I~DzRwoytqj~rxhqfpu|iooxys}phdrwuqt|piqnk}rqeolp|{1,I JJJ   + h0Ȅ9d"~Oc!~BVe+M@      +   zzz 2EhV6\Cr"R3SXoZR Q?]Jb5\O5\5MRl'N@O/S>q(S:S@YZQN6\Hq$S&V6\8XGe$K6[0RNl:TEZCZv0R#L*V@p'[T,]:g(\(MEc*Q:j,RKd0L[!R/S:XGl"S!LA]\w&TJJJ  +     [#q"=i:Af-x@u9o7a?   +    +  + +   +  +  +  +        +   +zzz  ,BeY;`-[+[4XXu=fWSEm2X*\W3b0ND\8TF^:^,Z+X6[Oq>d&P4WIe4S)U$Z@o5RO\*P=b3W>Y?SUhJfDo(\$TBj-T'T$TCl4S"X/WFh*S-[0VQl5SCo"Q3XD`1W$S$MQn9]J +JJJ  +  ^(y+b!kE`$m5Y![y@H&   +  +   +    +    + zzz )G\Dk9OXq5ORi6Ne;_BdE_AZCf%OSy.Kd|7MUt$GRz/VIk1Ij@VCYJ[YjGdHGp8Lfg4RPp'J[y`6T[kBKEHO3HPo3MBN*N\pMZ.E9XC\EP=MEc/QNe9I=V)N\|1CT\?JJJ   + +  [-m$r6gAs7d*o5i-q:[8    +  +    +  zzz  -Qg2TC]M_GRBVT{N9_>QR^G`?i+XGgi2ZHl8]W(R1YHoAj%O*SHmlv!QJJJ    vT)u/Cf<ƆEd'x;p4q=bF$    + + +   +  +zzz #JX0V5^Ch)KDdJkUv)G4QWr9Z2\P`5\Rp1H5PNpVeH + JJJ  +  + ~]6t5`#m=]u9V`*xI>$ + +   + + + + + +  +zzz []{Qk>b5T{s>Jz2>`R\D\A^!.Z]]R[JJJ    vW6n8e/~V&l4i6a1a4nF?)     + +  +  +zzz      + +    +     +     + +    + JJJ +   aG/|X2f>O3a7yW3yZ9x[~>JʖOƁPʞW7˛S>̘Q>w6ڦdFÊL><МZQCu6{l*GCAԠ]IF~=IđKϘU?~>Ӟ[>̓UCC}^ŏR}=ҝZ>˓RAz9Ԡ]>ЖU>x5ԥaőND>ةeCt7˅Js3ѥ^AɌN}AŅDŖRPG~@ДRDŗW8tH~{wJJJ C,bj/Vt5џew>ܰq|6}@Ė`OYy>RH\P}DȖZg-WxFTRHdwGř^=̝`|Kh5͜^w8ɟjvI\I\"js?ǘZz8߲yxHs=О\x:ǟktCGKI[v@Цet:L{IK˘Zx;ٯzuAQIZNl7ǕY}Bgu=k-!~zyJJJ"tZ5p;n3XrAY(s[^({SJxDe{T n3i6j:XUo8h7Ϯ|u=O}KvHewOh2sDOKWs=i7Yf,ZyFl:Ȑ~Rk3p=Ux=|NxDu?gSa,o8r:UPms;XON|Az@SŞZ?v:̧mw:–Vz:{=U^ACHMΡ]Ճ$u=  |{NNN]VBŧxd#̇>=—TCŕU~>x8Ѧc@ŽLƁB?UMBv6}i%BņIz<ğ[IE>JLÍNĀ=y5ӝ`w9ҘW=@}YǑP<ȕVGϘU|7~<Ϡb?ӖR}7y7̡bI=z5ۯo>{>y>u5Ϊd>͍MBÃCŚWKBBǏNCQ%x<  }yxBBB1"]b.Rq9ĕbm<Ҫvt={>R{GZp6R|CTLt;ǘ[]"\m;RIH[k5–`w=•\t=n8“[n6Ŝeo9UL|Wdr;Ř_q7͢iu>t;Õ[t9Ŝel5NJ{AYr8ś`j/}IxGLNs5ѧrl8Pz=Y|Jj5ÔWl1et)_# wutvvvooorrrkkkvpuoookpnlqoprrtoqwlnvntƲƫyı{{{¯Լv|¯iƸ®{ytǸm°smsxælҼ{xu|Ǵws|~̳rѶqlmpoqurnrojoqrmqvoqropnnqonrssuvommYYYZZZsss###JJJ@@@lllTTTRRR+++ccc{{{999VVV###AAALLLiii+++ bbb!!!VVV~~~KKKYYY[[[jjjyyy~~~{{{|||III>>>EEE222___ddd@@@wwwooo;;;;;;hhhFFFsss[[[|||xxx333qqq333```AAA^^^$$$000nnn((([[[```ccc>>>???HHH^^^AAA$$$ + + +MMMPPPhhhmmmZZZ<<<}}}+++QQQ:::888kkk777###---OOOOOO!!!sssEEE^^^BBB///ssssss000...pppXXX~~~...VVVEEEXXX~~~qqq___ HHH]]]CCCmmmZZZ333>>> ggg}}}III + + +444xxx"""(((lllZZZ===666 dddDDDgggJJJ\\\mmm{{{???000SSS111HHH[[[HHH ===ooo(((JJJXXX~~~zzzWWWtttsssDDD~~~{{{222gggEEETTT999\\\---999 iii {{{FFFOOO666:::;;; hhheeeJJJTTTIIIbbbGGG^^^FFFiii$$$PPP###,,,|||###000uuugggvvv|||WWWAAAuuutttfffKKK ggg888BBBYYY + + +ddd{{{}}}qqq"""mmm<<>>***nnnRRR@@@{{{ 666***'''"""666RRRTTTrrr@@@ooo!!!>>>???sssKKKHHH}}}777LLL///RRR>>>oooNNN'''kkktttnnn&&&555"""zzzppp___...wwwkkkzzz000[[[---QQQ___nnngggkkkfff$$$yyy:::vvv^^^ III nnnlllttttttlllbbb)))&&&444BBBxxxvvvbbbuuuddd```222gggeeezzzzzzVVVYYY[[[<<<<:88PNN`^^!'%% + +#! rpphigmnlGHFUVT + NLLYWW>>>FFFGGGUUU///bbbGGG888222kkkrrr999```BBB|||xxxooobbbxxxjjjLLL111444KKK...???ggg^^^ + +oooEEEJJJDDD%%%NNNppp}}}HHHFFFOOO~~~+++RRR}}}%%%eeeccc444zzzeeeTTT(((@@@+++TTTqqq\\\EEEAAA,,,qqq111XXX~~~KKKEEExxxwwwVVVqqq+++lll666:::,,,qqq\\\kkk***~~~OOO+++FFF333CCCgggNNN|||www000CCC{{{yzx///___VVVlll~||<::***FFF---jjj---===gggnnnXXXyyy  +   + +     + + +        + + + + +KEFZTUTNOOIJPJKLFGMDAQHE     + +     + + ,'$50-63/:73SPLeb^ifbqnjXWS #4-*OHEJC@C<9>74:304-*-&#'           +dbawxv           PHHjbbc[[aYY]XW\WVdXV\PN     + E<9ngdkdaunkwpm~yvytq~{}|vmi +  "     !""!!!        + + + + + + +  `^]}~|          "!!!#$$    SIIoeeg]][SSd\\/'':+)vge3$"           0%!PEAJ?;MD@NEAPGCWQL\VQ]WR^XSd^Ynjeqea ! " ""!  !                 OKJhig      +  ""!$$$$%%%%##" "     5))wkkyoo|rr`VVB0/K98H65$"  $!""##""!  "  +, <0,<0,6+'3($90,>51F=9NEA[UPTNI]QK !    +  +     + + + + +      + +   +          +         + A?>][Z +  +     !""!" $$$$$&''# # ! ! !      +A55uuyx|{R@?   $ !"####"!## %+8)&M>;G;7A51D95<1-  +"B4. $!  "" !   + !   +              +     + + + + + + +       +        +  +  ' ( + ' #' + /0+ +%  ) + ) + ) + ) ( ' +& $%  G24fUY ! " +!   " % + ' * ,  +# + - ! A2WG:T@;QA;NG8IF1'- +104( +  ! " " ! !!" " +   + + $ !   +       + +  +  + +   +    +fgefkiľſżȾ   +  +5"-$ , 6!)7 $9" 7!>(*7+7+9"&=&$@'%>%):".4#.2#+8%(6%(6%(6%(7#(9"*8 *8 *.!0#<+/UDHXGKXGJYKLXLJ^NU[LPH7:6$%<*):%'5 "8!&3#8)9,7*6(:#+:%(5 #*$%,#&( '4.)E78M6>M72,4("5)#2&  / @1.O@= &%" #   +'" % & +!   % " ! ! $ +& " ! +   + + + +     +      +    +  !   #$  D1:G5<@31A70?62H;9J;9J96C3,9+%8'$@*%H+$L*G--E--D-+B.)@-(?,'<,&;+%:,&9+%9*';+,6#&>*/?+0>*/=,05$(:),9)*=.,8)'<-*:)&;+%=*%;*'4# 1"1%!-"+"?!;!8 :%$:""6! /!*#)+03* %&"$( (%          + +  +   +       +<=;"1),'% $  +  +     + ! ! ! " # ! " # +" + " # +# # +*+ * - ) " $4"!! +%%$ $ $ $ $$&&" ! % &J46M=>O?@O?@M=>@01$') +# &$ % * !  # " + # ' "  + !   +  +        +  +    +   #!  %% )#ٸٳܭڥ֝՘ѕΒ͏όҋъщԊՇԅԃҁ|{؀.1   +  +   +    +  +'/4!&('' !  +   # "" !  + +! ! !  +   +  +  +  +( + & ( +. +)}I13*'''& $ $ # # # (&# '#  + .RAEP?CSBFRAEN:?  + # +! ( + $'" $&"! & * %  #   +  +           +     +  + "   $ %  #~9@       +  + +    0"$@)-=&*1$ & %   "(-,,,,,++++,+**,,+++1426' {{~z{~rroabdRScMO75-...-,+*+'*+**))^JOS?DYEJ\ILQ>A!  &%'#! #!  !   # '&&+ /*# # &     +  + +  +   +  +  +   +  +"! "'$ ||uqpoquz~|wru6@   +   +  + + +    +)(786D68bMPpY]lWZ:%($   ! %$(..-..---..100058 2*+/48:8-*'*-049;579987659 9 9 :!:!9 9 9 -//14 5!235! 8$#5! 6"!4"!4"!7%$6$#8()7!#7"!:)&8,(;*'B((@$$A&)D'*J*+O-.A(&;+%>2(B2%<./<./;-.9+,:,-<./=/0;//:-/$ +   +   +     +!"" )') ٣ޥآԢ֣ܠ|w{ٟ{Ϝ{䞀ߛxޜyݝ~מҝ٥߫஄㳉ܯݲඌ三껇乒溕Ẕݸ⿗–佐潌쵊벋ໃ乀七᳄㴈浉綈켌帅ෆ⹈ܯⳍᲓ䲜߸׷Ӽ{{wvquwz~|}nj4A      + + +  + .!#I69t_bz}\IL +( #  "# !" # %%$#$# ' )22 7->*+1898 8 7 8421358 : 4 6755 6763 4 4 4 3 3 4 4 + , - , ) +) +, .+ ) + ( % & ' % +& !+, ( # $ +.+ . 1 1&       +  +         +    +   $*'  +ԡ}|tuy|}{yy}|w~|}ʼnȍƋ뿄쳀{tuz{麂{v|븆ٵ~{~xg2A  +      + + + +    <13Q>AmZ]~mp"    +   $ $ +$ &(('')-49+7;A +=5= +> +;=BC ?:; 9 688669;;87:;:@ >=<?A?:6 3 5 +7 5 5 4/234 32 +4 1 -1 6 4 +.0 1 +47 32 0/ .!    +   + + +  + + +  +  +! & $  צ|䰌٩ة㱍ݬ~櫋沎ⱋ䱉z{{z|~}{ȅÂā~ĄÈڻӺ־ͳշѭٲ޴ر٨vⷄֿ̳ү۪~suvu⽛~xzxng2@      + + +      2')B14F58J=?<.0!"  + ! #   +    $ & +- 6~rs^yaxa}fy`ÀgƃjƄkȆmƆm†ijÍoÑstqqqonhkjgbdcaoQvXy^uZoTnSoTqVmHmHnInLnLmMkMjNdJfL^G]G]G[G_KZF[@U{MB+          +   +    +  + (  %  Ϩ變|豆¨Ԟu{}ﴃ뵆뵆빋๒ӷ俍ÌćŃȃ~„̡֬ﶂ鵇ć}{{{׷wrptoi/>           + ,$ + $   "$  +  & - +.= 뷠ȑ̖̕љԞ֠ڣܢߥߝݛݝޞ֖ۛߛݜܛߞۜ֗՘ךם֜ӛљϚ͘ʕӐˉ͎̉ǂƃćƋNjŇǒｙ5 ( +    + + + +  + +   +           + + &  ̫粑誂ⴜ孊ஊۮǦͬ亝Ĭ⾚‰ɊŇ뿉ț˲ŪŸ绪洖鵀ċÈ̚ƢջŤɜ깁춁qﻆܹupvtql/=   + +            +  + ##%" % !  +   ! +& ( 09 븘|ǃ̈ҐԓҒҒؖٓߔބކ܄ۃ؂ׁ؂؂ӆՈԇ҆Ӈ҆х҇҇͂҇̂̀Ѓ|̀{w}yxzwtyuσŽ9 - & + %   +   +    +  + +      + $/$&@35+"   Үҵ传ʼзºװױ۸پ¹Ʒȹƻļ˾կܵ㼺Ὥŵῲ۹ܻܶ澎~Œz꿤segskksmfzpi~pqpt~ptzspytk{tk~qonqyymzwszuw{wv{yq{yq|wxxy{utzyqo0> +        + + + +      + %  $'#" ! +!  + + $ ' 24 +ڪ궁}yy＄麄㻆޽ٿÔƙțϟȕ͔ԕԏَߎ܈܋ډم؄ՁӀԁՂֆс~ρ҄цτ΃ōĊȏɐÈƉˏˌȈdžȄ͈̉ȁ}徊罈޺~ݾywtʁzz׉=&# +  +  +  +         +    ſncey{~O>A ) ү﹊sy֡ΨuLXMXR]SZcgZXb_eamkonjibe_c`gS_erepco_kbmdpbo\lWhTgThThThSgWjVhQcal`lWd^o_o^k_ged鿐ɀzxβ]72 +   + +    +   + + +  + + 0% vuv|p/?  +    +  +  + + +   + &% +%#! + + +  + +' , +/ݰŠzzv㭊ӽٸլ˛͔ӖѐёϏΎΎˋLJņLjňnjŊōدڷ翎Ž羇ݦߥʷѿ뻇ɡӏƚ4 +)  +  +     +  +  +     +  +z|}?13 +Ұvrژҫt\#GqEee|8Qv#W#ZXUU"W#X!V$Z"YV Z%hYbWXXT,QKXá{zāŅÀw˱oDA+ % +#% # $!      ##$ $ !# ?2qtz|sn->  +   +     + + '# + +)(% ! +"   +# +$ $ +! # ) +,ݦ}絇̫ӿЩѣɒ·ށlsրτӊІ{͐㺃ňwqkimsm߬؞unvٖ̀֓ٗؗƄǁ|ʆ:2%  + +  +      +    + + +    +higqupimh_`\d_\:-+ +$ گzz٢Ωd,XuyNq,k+e$ % ( & !" !  # $ !  +! # +>+ +tx{zsm,:   +  + + + + + +    + "5%&E34R@A;)*1!"" $'(  +" $ & +! $ * +,ܥ겉ͧԽ˧ı׻}k׸忟Ę⾐ɘݶж˼ðмͼܿ㼏ŘƜ供߿Ժ޵⾐ŒּӶ‹˅·Ղˊ= 2% +      +   +  +    +    +efdnrmswrwxt|yL?=" % ܲ~xݥ̨l9`_i[hB^-a0h0a5c/b-g,f2i1c/^2a5a1b-d+c0e*\:m8bNcx΁ǎƎȂÀѬrP@) + + , + "!  " "  +   +  " =* txzzsm,:       + + + +  + + +     '  +  $  +  + ! # +$ & +" # ) + -נ齔Ѩҳܾ¿¿ǾʸξÔ̐Ç΍υ˂Սي̎? +4%  +   +  +   +   +  +  + +   +  +  +opnwxvy}x}~zPCA * ݶxᨈ˩u.Pb~tz#wZrúQh9d [,h,c+`1h.h/i2j0d6j+Y3b2a0a/`1d1d;fPeyİт~̋ȐȋƅčӰtQC) +* )' + "    ! ! + +     " :'twzztm,:     + + + + +  + + + + +   #/!" &"  ! + # % % + & +! # * +,Й~~鷍ຊņ輇}CgGhThTfNbK[]h\gUg]kVfUgN_VfRcQbQcNaPaR_Zf]gR_K[L^RlLfBYKaOaQcN`NfNiXlYeZcXeUi]o^ogpsl{Љ~}΀؍׎َޒ˒@ 5$  +     +  +   +  +  +  +   +  + +  +xyw|}{~{{|xUHF +, ۻy婅ή|5WHa^tFa{'JB^UfKUmXb[gBOYjPkIeetmkAoMljxUaC^/_3p0o8q6l4j8s:t1j>t9l7gh>o6p2hNlȰӆӁ̌ʔȎɅǍ֯oWE# & #" "  +     + +     " 8%twz|rm,:      + + + +  + + +  /+*4/,A<9IDA_\Xzws "  ! + " % & & +! & + -ʒ~~v͌Jg/^t]hbvav^vBd=d9^>a5g3c7e2_=ffBdBc>f +1  +  +   +  + +!  + +  +    +{zvfg-#ï괋ﬓʯ~4[ĸȺY{LkƽvulzPl_vȳ̟ȜǢǣÛͶtXM-1*)# # +!     +  +  + + % .tw||so19  +   +  + +  +  +  xws}}w|vzvx}t{w{}x # %  +! ! " & # # * + 1yh㼖Ђҁ`x=gŮ$d8HJf3f*e7p,i0m5l6i7h6f7k6l2i,e-i*g,e0d7h:k"fEX֗זڝёؓؐڐۑȒA 0    + + +   + +   +      +    +   zztde +,# ɸ齃ˮFUĶó + +" "  + !   +  +  + # +.sx}zsr-2   +    +   + + + +  +~~x~~}z}||&'(  + +$ ' + ( % & + .ra꼝⼙тҁby7e])=oFGzmHnJtHiGm*f-l>w,n2q4pq5e8f?kFt7g9k2h8p/h5ifʾǩԶȻ̠֞ûž¿˾ν̷Կƶ#   +    +     + " )rxzwwn.+    + +      +  9541) / + " # ' ) & +# $ * .dTŜЄЄf+h;s0rUm6dlC\ƥܙ؊ݐݒٔՔْؔƐ= ."   + +   + +    +  + +  +  +  +     ŽZMO`RTPCE<131$&)#+ " çž液_jONF7teMQ6uaHTBTHYL^JeJeI~dUpǪŶvBlEkKmWrgmېԛ # +)'  !   +      +  +   +*txzyxn0(   +   + +      +    $"!7 ( 0 ! +" " & ) ' % $ + 1`PƟ‹Î•È쿞œӄՆg0jܵѻ·?o9tľc{;qmD`åۙ׎ٓؔהՕ֕ՖĔ: (#$   + +   + +    +  + +   +       + + +(0 % +Ȩğġڬǝ›ŧ˨جϡͩɴƯʭOv{kyݍݡ&4 +% #  # 05 ++'     +'  + +    + +    + *ux{{ws2)  +  + + +  +  + +  + + + A*(' / + " " " & ) ' $ +$ * 0 ]Mʣčď”Ƅ›ψыk0iɽʶ=m9vNm+omGfĩ֚ۜ֕՗ՕӔӕҘ5#! +(  + +  + + +    +      +       " ,4 ' ~ʪɥƧ©¦žÜƟ궩鶴紸緱¬èõ˭IJη|ߛ̜'. #+IV@JUKUcXfwlpzp{drnR>=)- $ # $ % # % % ( + 1 + 4 {J@άƒǒ•ċȣƢΏ΍4oξľũAw1qſù¾j{HovEiܞۖݛٕ֏؏֌ՎŒ3 %$*  +  +   + +  +   +  +   (:)- !9 *xdp˯Ю̭äƑž꼚Ž—ԦԪĩ˥ūٛ͟ߙޥޯժ׷הߍ،՟2,?OPj^Vt95^]e1:f06YCOkmUOn@:]3/L1% $<-H7*@!#  -rmuwoon0"YYKbj_vwsvv|wzxw~@I<) &(:-YmaWibJXT~rntc`fSPYGF3)." " + # +$ " $ $ ) .3 4 qC8ӱ˖̘ȚďǨè̕ђqyDHk % )~nrtpjje.-.$_l^Sj\Yvf\{fhnwyu}sz{o}wWheZb[BMEO`S\na[m`WeY "  + # $!&$-( '('# $ % *+ 0 5 +b4)ٷ̗˗ȝʜťɡԑԏGu?a"kS_|Ug dSalin iRY}Y[ nXu$wMd5<%l1xQ@rPld:F+fx gQ^ b^m'6 k +)ha?j%)xjvQC`klېӐԝʛ̝ΙҘ×3 ! + +   + +  +  +    +   +   $/& oUcԦӢŠƬē￣Ū«{bT`isuw{iXZVm`av &go0@PT]3#oy_j )(!ߗphjgqYe±`0 "%P[QI\SG_SVm^ardowl{vyvuzavm`bj!8E=\m_i|i^k[  !"#&''-" ,% &'&# $ % +- 36 _2'ܹΛ͙ʟǜɢ͞ώԓalv{|xxwxu}{s|~~}ynpby~`fl}y~{xs~޾כܙ֗њ̜̞̜ϛ˜5 %  +   + + +  +    + :9= + +   + ,- +sKdթ֤Ӧǥ©äȘƒÔřơġƥɴq,7@Tdtcb#CM^yYiy%%Җl]ddiX^Ī]1 '($PUSDLKCNKHSKRZPcc]lmdu|mn~l[t`QN][e_XjY\oZ]kY  + !%&%,4$%! )# +# $ " " $ % +, 1 3 Z-"طΚ̙ǝ̣ęŗћӝ̧Ѧғޛהӓԙϛ̜Λ7 )!  +  + + +  +    %&7;0 ;<8nnnedf + +    %%. +tBbгѫ˧Ȩ̡Ŏul|͛ǣￕØƛ͝Пʢֻӻֶֹұݸشճֳ޳ݧ֡ѬιѭȧҾ#Abx{##:I|ss()K5?Pzxmƒqg\fih]W3 " QRPQQQNQOHLGPQMSQPXWSah[YhS:P7OPT!&$amal|jyx     %+,1 7'( )# $ $ " " # &).2 2 +X+ ֵМ͚ȞɟʞɟѥҢء۠ۡߝߜެݯئެ٭ڕؕޖ֍ҍԖΙ͚7 , $   + + +  +  ><4cd[|u~}v,2'  +    !"+n;]ͽ˷ʴèЩ٣o_T`cTYubLŅ͞åƢʟΝϞǠĶԽ̡ʥȪϲҰɟ΢ФΪϯȩɥΡМ֞ЗΤϢԦҥӪѩϤСԤӨˠΚԔח͞Ʃˣ˥ĭҶ86I$@mx /3Liyhm?@\ +,Мs\_[gbTS2*&%[XTOLHOPGJOFNTOORVX[_cjgiuiuq   +  + (0:*+9+, %" + + + ! +" # " % ' ( + 0 6 M"׶ΝʙŝƜ˝ΥЦՠܛޜޤ٩ݬߤޞڜߣܤڤߨۛݖߚܚ٘ݖݑۚ۞ݙܐߒؙ۟ޕؘۙה֍ԌӒϕ͚ￛ9 .#    +  KE@|{{zvuai_"(# +    !+,f2ZǹϸͯФޞkaR_YoKi<]J[HXOOkӣĢɢˡǢϲմϧ֟ڟئԪӬگӧӪˢѢڣ٢Ҩ£ɤǡǭQJeZn$SHbcÿиɽøkM8JPK2MM>1PmfpI.18"86.!0("1- $ +, $!,*,NOYwCNiLPi:5R )8lytxwS̉LMRRQLyJK     +  +8= +A + EGJ P +LL 3     && +    " (+ . 4 2ή͝Οʤ͚ʠɥ˧ϥҦԧ֪خ۵ڶߵުߨ۵۶ذ٪֨էتۯҪҧ٥آԨѱɵСߕޓۣΣثΚף͠ҩէמۜܜ՗Ԝ՝טב֍ՑәӝЕϐ͗콝4( +   +  HB=a]XUVMV\QS[PLYKQ^PUY^[`cgmlu|u} +  ! - +) +HGeP|T5a{T}>{v`9Nq{FtOaqYshnz\seubMxovgIogbHpCm`cFpKu_LDrd]VDxbgXxKj~f{Gl$67)#)($, )0&!0#1   # . ;;F 7 4#V;?t<@q#'J  +    +    "% #$+ / +( +.,ôĦƪŲ͜ɢʭͪإ؝ݦج٨ެުڪۨڟޝߥٰʬsrOAbT}qWPfMa>iHhR`PgSmPuRpNrXoxfhjn; <OߞN. (ʚՠė50%   1(%smnFBM 8D66G  @ +0!ULK)ykj7tmgu8rz]R;quQP]?v_VZGzc\UErufU{WxvtUp`y{jPqp`{wZszl{`jpvqvpsyIoFUG71hF.=$ + CE2:7"),%+;A-5Z;9u;0y.*.?1O9_LO<{`zNVR1S&>% ( $ +.% +#   +  +&'+EEEIIIDCG)%B=F E +K JI +JX(-Z  +    + +  !!!  +  ( ) #  ") +21 6ͤΡϦ̡ɤΨrkÂڭףۦߦݥ٧תجܢܥpB# 4C2tecF6))=& 80$%&(1&.'&,,!#(#%85=7 3+.O%cEř+" !   + +)  -)/3/:A :D @ 4  + +! .,#Q K~ztxpuwx§ĝÚ|ǘ•ȜȗƔΝԞȏʒÉіɎxU|Z`="4'!(!2C8+;*2=) 1>&(7B&QX&!_FM Ue!hEdGw+35#g2="%" 3- ?:1 + ++1efjXZZ9<:EIDW\[[_d).=2 / ; IIGV O6       "!&  + ! ) +* # " 2 ; 0컡բїӛ̫հxSU_nmur"9CޜٱߠܣߥߪӨ׵ҳϭ۱֤۪ߵu@% vjR><$VKC?5$bV>M=-0)3NH'J&K&F#@#?%<"E%F"J 7OK,ME&/U<:-81 0.J<*5 +W>ݳœ%   +  C> DG2      (%YRuw}}v}xmzsnunuptmjonikknghlffcge]``VYU\OZXWT[RUUWMXV4?+ # >M?4C.#'<&6L43E."&"'$ 1-(8(9(B%$K@ 06 z*/[Kʰ8&e:7"JIM,('3/.  +*+/LPQ  +   +  +""$   # ( "   & 43 +(罦ƚ˙ԥɨ֦qX\Kw9nAk9YRmPWԋگܪߩߧݬݩעצ޷ڰش|N/zgX>6)yrD4$tcPD3*')  )DN=1:%(7")?,2I32B+',  #!-,(,u:'r$jY 7 !$ ('+*)- + "$%fkirzs`nc]naXj]QeY^ofYgeYegbmqEJi< 7K](&Z    +  ""   # # " ! , +- / (۰ϱʥ˨ިz^jQ~:v6tI|CmFkPrTjuڳگެ޴تܩ߬ڮ|< )?,)mZRL9*,>,!/*D0]u^[@gHK,U7L2Q7P5W7L)j?O9,w=*K.%LB;4/&?62TFGxƫ"        +FBLC.+c   !  .aPZVMLHKHGJCMIBDGBACCECFHGIGIFKDHGGGIDBCA@EEAA@AHC>D>?;DGQg8  '.4QU(\?:;63T*5XJ~@"Z5'O;6D1.J57YBF'|eī.!    +  + +7F H +L9 +  +   *]OSG@BHGG@ADHAAA=H>@ADCCGBEHMGFGFC>C>>A@@@A?<=??C:C=0MK3@E&8@"EN4QXC). ::4{yqyro~vlvoyi{tftnbkhlqomooeptmqrppvrxQ\x!:  +  +  ! ( * "   ! $ + +. 6:ޤicFdPq5\ .QNn>rWiZ gGlIbW`ߴ۫ާܪ֩ثݬ٥߭wP4XG2,%.:$4?%=E&$?J0"-(0)$'%-()1'-D7E6)A0$B<0L=0H6*=AA@;>C?C>@=>?=<9::9>9@9A<=;;956::7?9=889>19:>;7@5?A+;% !#.2'/tbdX"(% ASB7JEG0-)!!%'GK8#% 7=*6@"LX4emNEI0-/./&12) +58/}wvp~styrzxz}z}{pppfsqnvku|mcqkex{bpv  + +    +$- + # ! % +* + 2 *ʢ߬b[Nh=|OyQnSsSwY~9;8:=97=9B78868::98;5796<79;89><=<==<<;<@C@??@@C@DEGCFF09,  ,,{qwwi +$ &LPDb]Z)$&MKK32.*)QS?PS:76" E?8A>634$+07? 2> 8D.!,-.$'( 6=6~uvuwrvvy{}z{|}q{xssfmkgsYnf + +     ) * % % +. 4 . "   }t~eF̀(<@4FK6BG(EL'FN)@4X\PrwnkqllqplnvBES. 5 3     7$-( +!QIF=::=88;?><7&+".%@> DO'EW.`nLTY9;:MN4 9Apv   +  + YUPUWK~tnufdm`goeeleck`lsndls<@X %  -#& +'G4BF76:2//1/./1,0*''$$"#"}~~y|}tzqzqzrsmphrkngkfnhh bWRVQX SZSZ +QTH\ MYMTGSBQ=I:MEE5FPA 6  & rkbxy~'+5OG0 $i_e   +     OLGwypwwpluhisgkv\lwckvlpx_er    !# $ ,> +(D2A-G 3> 194<7C2B.=16392<,8-7,0&2(7-4*2(3).&2*/',$*"4,)!.(4')- 0#()-!!&)&*+')#!L3M<":972-;2 "$ #!#%.E( +%,!/&7/IA0ZQCgbS;=)JP9UWD)'   :73-.$"  ?G6 (  ;BS^g{HUkRc "!&'&-! +" # $ " #53 uaV~U\;wRWWWSX~pxW]]bWwaeK;zM_tZ~GjkTk@L|/0J 9*>66+OB,83$$ '*68$ebSc]R=5.NHC0*%g]ViZQB.#:+EB-:@!CI&NM3OJ;1**!-# ^^ih%" +  +  +   + tulyu~ty|w|yvdugkzep|vdnn +    # +              + + +  + +  +   +   + +   + +     +UNQSKKJBBSII^UQ!  +  %   +/.   & +00  -)$OLGJJD$'"%-#&Im~naz~Zt{LhsKftIctH[hCTa=Qj=Tt7Gd#('$  +    %' '&!#) + 2 `czk\IgWfSjUi[|kakjc]j^\Wf\mL_pT^,$)2!3!20+$ ;-yi$ # ,- C@1/(  :."K<)<'8(5-+)OJ1RL9&&*+ 66 +W`ty*    +vwn~|wz{ymwpo}qjvp    +!$  +  +   +  +           +    + + + #! ".)&,'$4-*   + + +  + + +%kccqfntmrwroYYM + +43$'MQEffZUUCML888*,-$//!ZVK5+$  + ),!%#'!% ?H- *  + TK_Ua}JVr6Da8He.>[/J 4M#6K!5F 3B7L[BVg;Qc;Rh?Wo5Nh4Oi:Od=Nc5Ih2Io,>]!!&" !  + %(- /*+1, wb\lOSy|[PqzhNsbR^SqmgO|ffpib-'=. +/ 1'' a\CwiWwdU{k[{iNG3?9&;2$+! + (! A5Q? <,+* QF2LE4 '-=B% (ex   uxo~{ixp    (!&%) ,)+*-1163483C7< 31 -,*2(7)7)1&/'!!! +    + 'RDEXJK  ZY]-!'    ! # /N6@) +  + 0*%^f[#'&$'&'<:/TP=VV>`dQ]aV.2'TWHSSG+'"  " #KR=FM>&.#)@K1"1BO?,-A^ 4M#(($  +(   $ '& * +,( '65 uburiu|byqnrmm|{uvjl=#>+5,#,.vq\lcYAbYE\RA7.!  $#mfR^P=HA(:17-MG0OR9 '&A:)  +"4VrO[s%$    x{r~  + +$(!2).%-$/+2165:4>0?16/*+)*2*7(5&/"1+("  +  G9?ykqcX[ ^SV~)%    5$(cO[   + + 7/0KQL$  /. ?40C1*?1@<&*%=E4AK; ?M; +"RSIHI@46*!%KN8FH539(*6"(L\K %5L!1H(6I$1A $ + % +,0B'S2W2L6H7H7L,;%"&"*      % &" !" ! & 9 @ . ^XwUo8a,T=MJ_$@/J.EGTCK;I0s4U)Iz-@s07p;D%:~4}-'`"1i +)`0i"^-*h %d$c I"K. *H %:" +!&%+)'*! $QC'1&0' .%2)"  85-2)%29'+(&<>!IQ2.;# !-<&!HCDZnTq_pquxq@89  {_mg!  +$'"&"+ -*%&15/!"&#    + 832okjrnmB>=PNNzyoxvn{yq}{s{yq}zu|w~{w&!    +   + + ,$%yupusiuucj453E>C & +/):%$9F-7. %'-9%*3%  "6+-?69!"#CE169)&/" + +  + *     % -.?#7H3D"5D"2B-T*D-;.9 /9!'$##      %('(,/-..1%,! +'$$ ).+ -( $ ! +  %% #   +     +  +@+*01"! $,/()'# +-(?83)0%,%ZYDA@,  HG2hcNJB+@<50/+87"ORCNQB # P\n=Qt>Z|CdwGivLmFhevs'51 + +  51&{bPp=dz7ew?kx, +)')('%%#"$" !!  #  . "y{_TV)#$_WX*0"+.0!1"1 $3"%5$':),?/0@01B45  + +   +I>@@57G<>PEG.*) 44.))#,-$  "!%$%%(+#&+NG> +  +#!"('0' '-(&4.!# !  + <>? +   !  + %/#+8'4(6'5#6#6#5"3&4# !"#$         !  + #!  " # (!  &($ % "'!     + +   +  + $" ePO>'%1% 6.!8+^Q;mth{bJF.ON9abN/+#E8(JI4oq[JM4*&okOeaE76!$%$) LQR[g@Rw,Db*DU'CN%CT2Sm-0B14F67G78J:; +   + +   F;=K@B:/1+ " +  " /-"EC8AA3NN@47(:?0IN?01'?G6 +"$,!" IS&-=0I$?S2J^I]ojymy_fyU\mLTeCP`AQb@VhKfzGf{JlOtGmRrSuT}SMx +(  + #!    +    +   E=>WLN  K@BzrsystwrsoijSKL(0"$/!7$';*.8'+9(+<+.<+.=,/A12C34D45    +    * 9+/1$&#(>35J?A*  +   86+ *, ', %=G: + 9;/$*2:):>+!"*/ (&2    +     + !$  %' +()(&%  !$)''. "1#%4$%7'(>,-@.-A-,@+-<')?*,@+.9&)<(-?+0      ,$$OGG.&& ]TQrs  + + (%$,%5&M:+X?/Y?/V>,3$*&,1LUA+/;7%& #,)'*6?%XVKYVHCA/9;%38$( Z^cZazESw4Aa;@U + ' %91H2D[7I`;Pf=TjF^tLg|NkC_wBaxBaz;^xFk=c@fGnOqOqKtIvFo~ #  + "        A69f[^  +<45\TU&KCDc]^lgh_Z[d_`?9:+ 8*,6%(:),7&)8'*<+.<+.<+.@01C34B23  +  + + .!#>046(,$ ) MBDG==KAA% +     + >90PND  "(, W^QHaS@KA0.$  ';?4AA3*--7'#'7%'1 $"!102         " " ! # + $"%*) ,!+ (. "2$&3%&8()<,-@./>,+8&%<')6$%9'(7$'3 #;*.$   + JBBphhMEE E<9xfe +   +  +  'F:4 )"'&6/ ( / 1 3#6/68%&.4#WXHSO=% -'=<' & 64)dcU7:$$+BF-12(DDP]cCPp7C[   ".'84CS5IZA^m<]la{9[xBd{DhCl@m9bq +         :06i_eulovy4+.   NGJtnojdeb\] +B<=d_`jef]XYe`a601&,!3%'5$'8*,5')7)+>-0?.1A03E56I9:F58  +  + ?249,.% 'KAALBB?55*"$   +0-%GD<+/$W[PHbUV`ZRMJ #-CA7FL; "  + " SRT!"&   +    ' 0%' &- "/"$2%' .!#.!#%%').1!"2 !/-/*0-.      + +)!!g__zy6/, %vt}}yzv{w~x}iWV  *"2,%46* "" +3(MF799)Z[K.-cbT""HE60)FH2"(+)@@024!BJ37@&IN9%!(+@+6J*6 +  +   #!$;C4QX5T]8Xc<_i9Yf0O^9Xg3Qb5Vf4Uh8Yl7Yp<^v:`x6av/Ve   +    +  9/5i_etmrslqnglf\b* & +UKQojlmhjd_ab[^VORE@A^YZb``^YZe`a("#' .""1#$. !6(*4&(6(*<,-=-.@01E56G69?.1    'B571$& +* F<<$ +[QQ0'$~ur +# +" 67.12)*-$ ILC$'[^UBZNOWV>9; $ &*+ )&%!&$"!  +  + +    +   + + +*"#=24$+ - "- "1$&  *,!'%$&**)**%&)+"  -QCDpff%B96|pn,/3 5"7'!7)#6*$;1*A3-I93Q@=:)&   +  #%  + 79-!"'1. /&LC6GA4VSD6/& ! #+84!SR>X[E*2!.."     + +%04!/5#* *'9D5HU9O[/IU2M[+HV1Q^-Of2Tk3Xn3Zp/Qa +  +    903d[^zqt|svxqtxqvibg3,1 }syqgmpkmidfhce`[]QLN<79lghb]^lfg+#$-"$1%%5'(4&'6**7)*9+,<./?/0C34H7:I8;;*-   + ;68?24 +    +  '_ZW+&#wpm + gd_MMG(("KMGTVP<>8[\XG[OTY\E>E#,  " 22,$! !"&##)   + +  +  ' E:<'- "0#%.!#0#%  $'"  ! #    pddH43ULI~ol/?*(='"@*%E1,@-(B4.E93L<5QA;UE?B1. +    (,%&GF<#!93(" kaWx{qUUE+'7:$.)&#:<&*  TDE"),# +  ($!1#)0 &-(?FOBKU@JTAJW6BN-$&2?0CP2ER1DQ'H\-La-Md,Oc%FV +     4),dY\ynqxortknulozsvleh4-0+$)d]bSLQ" ~w|slqrlqlgifacfac613"!fablfgumn&+ 2$%4&'8()7++8*+<./>01C34I9:N=@O>A7&)  814\WY#   +   + +8,,B66E972-*+&#  1-(74/,,&hie\`[ae`ADBSh_=?G4,7#Zk$8=JDU;*-@3%:5&;7, +    ! EDH657+(* +   +  B79&- "- "%- "' !     OCCB66 / zmk~yu|qmbSP1<&!A($E,(E/*F3.B2+B5-L:3H50L<6;,)   !  +& + + 5%j]U$ .#=0(ZXNhwiexiNUF% ' '&6/,% *& '%+(!7$!     $ 3 &1 &1&#*%-:.9G(5C+;-!  + +1'')"-E0/$ 4>+&B7/;4+)?2*NMChzm[rcP[K)&22 9D0"*:0)7,NC#VL; +  +$ %+7%2,:!/% &"0$1*7%03= 6A'9D+7A&";K5G%;M!;L*9&#%PKMsnpohkzqtsjmphiwopwopxpqF@A + [TWzsvojlqlnmfkd]baZ_f_dc\amgl}w|/,.302d_akdgnfgf[]"*2!$7&)6%(6()1#$<./<./A34=/1I;=A35. " vknTKN +   1(%C:7C:7@74F/-(-F*)]A@pTSkTR)"  + 8;9IPMGONDLK?9><=B@=B@9><;@>+.,h`aB79 $$  +  +WIJsq|zpdb ,# ohe}vs~rpULI&_XUslinhcwnjA511":*$=*%?,'>+&A1+@3+C80M94M:5RC@( + + *"#;34/%%WKIuhf?-,   , [YOstjf^W F>7\g][m`%2"0&**+)*3-5)1*107$19)1  /?#3C#8G)6^]_nmoonphegpkmrknqjmskl~vw]WX  =69vqsuprlgihcec^`gbdmhj+%* ZTYqkpgaf*&+:9;[Z\URTkfhmfiqhk\OQ). 4#&9(+6%(;-.<./?12;-.F8:G9;E79B57*twGBONWBJC=YE@dV-CHSS_E47iVONB8,&UQF3/$ 3/.  !  %$&023=B@8=;5:8;@>51V+(< @MBJ>-' + ?EDANL6DC?ML7SM6HIDMPEQK@TG=RJDOSJGPXPPUMFPMEhe]xlf[KE@  843  !&$:?=JOMBGE386ODF      9--k__zzyz{|SEF, ja^|yxupkhojgged;:6# gb_|urkda3*&1&"7,(7-&;/)<0*C5/C5/H:4Q<:SB?PCA" D9=B912) +>=3>B7rha;'"6+'$/'=QE  Zp.*MpcqWC8|eO5&SMBA=8  #"0*= +#+<(6);*?,;-=,:,))!,( '%&'"*  +", |~}geenllVUWUTVjiktsuwvxihjdce{z|xwysrt]\^HEGDACbac~y}~uwx|~y|8*.  #"(-/1!"3%'7)+:-/?46( h_bRIL +        1(%=41@73>51X.)< AIKFG;(  + CIHIUU2@?2BA41J]Z>LJ?OH>LFGMLHGKRMOTSOKOIOSMiic>83*('111  !#$'*("%#&)'+.,),*iabC8:     + %VKMxxyyxxuui]]"dXV$f_\yvupmsnkpkhjki#! 0,+wpm}zH<: 4)%2'#6+'6+':0)<0*C5/G71N;6WBASA@I=;;56G@C&   +L31y}tktia!,=6-GE;C5/R>90*%Pe\Ytj&-!MBLjZTdTG  %'ihx*#0&0:#/9,8()7 !/ +"#"& $  "  + + ! otupxxmuux}~suvjjjVVV___qstuwxrtu{}~wyzhegpoq}{y~~,!$     !#%-"$OFItkn   +    + &$  +     2)&>51?62;2.K*!1 6 HJKJ6 , !  ! mnj!)($0.-;;;8::  + +%%%#%&*,-(+)$'%'*('*(!$"]UVK@B +    + C8:vkmxz}rtzqnwnkzxsq2&$ K?=zxus~{,# XQNzsptolpkhytq[\ZZUT~ttyw3$"1" 1" 1%!5*&6+';/+>0*E5/I50Q;6P;:L:9K??XSR)$%   + +4DGA7L5-IC8DB8J<6M721+&F[RXqg3* ?77\PPaVRHF; +  '-8(%."*1'+(*#""&" $!""   ,44088088>FFAEFQSSUWWmooy}~hlmtsu|uz{xu}}~}0%(. $3$(2#'/!%2$(4".+$%{ru +     +")6%(;*-9+--!" + 1(%<3/>518/+<&2 + +=KM7 +7*   +  5??4BA6DC+<9;KDFVKJSPJKOVRXRPPMPGNSJIMHCFD`d_%%=<8%#"120JJJ ,,,HIG564 +%%%!"')*,-++,****'''%%%MEFQDF 4')dY[uw~su{pr|qsynp~ur|UIG 'thfxv|pnvjhxolZQN zsprmjytqrok + !lgf{ooqab#q_^(."4($6+'<0,@/,F3.J4/R95H32o]\]QQ   +) 8kXN3 9$IG2.9GARg^3-(95 YQRZUVCF=;4# IR[KX`EOVNUXBHG;DAWYYjonfki183 $$#)""  "  """,,##$$ + HJKbdenpq}|y~x}~|v{||tyzw|}rwxpuvx}~~|~x|}v{|qyyu}}w|}y}~{tw,!$2$(4&,7)/;-3<.4G25D/2B/2<.09JA>I?CFDMKQJHNHKIIODGK@JIEGGG4:5vwIRH$&   540&$#;<:LNN>?=DECHGCED@  ###''')))+++...<<<666WYZ}xxxxxxusr{wv}yx|zw&!UNK}z}vsoheja^mdarifvs* XLJQEC khcvrmzvqvpkja]pea-!7+'<0,9-)>2.D84D84J>:A51~pr\NP) + +  >NIQUA +@%NB6K?5G8/:1(38/LZOele3($,% NF?^VORLE}wp>;3 +hi`^_VUXOX[R_bYQTKSTPLMIRSOQRNEFB('#!#  +/0467;*+/TW\gnqZadfnnjrrksrowvpyvqzwu~{z|z{|{||{oij-"$1$&3%':,.>-0A03>02?13A35@35=02F9;xmo + %  +,!6(*=/1@24F75B31B319*(2#!+#  +3%'@24F8:F8::%#/5( ) 2$0# #  387PVU*0/=CBDIGEKFCGBCGBFGC?@?;9:6   $#$  #'%(,"%) !&}ovyckkowww|~smn.#%/"$4&(;-/?13D68@35>13@35:/1g\^?78#" +,!>13NACYKMVIGXKIUHFG:8=0.:-+(  0#%F9;TGIL?AI63C0-:%#! +$ +/'(   FLKy398;wroc^[mhezspxolzqnvs|spneb}>20 + !!&)3&${y:-+/ 6() + + +  + 9@ + +KRK< =#H<2K>6D4-@5-+.%WbXSWQ"(% $\VQWQLUOJ~MID<<6[[UVVPIKEHJDEGA>@:9:6BC?#$  451ONJ0/+  ""#)*&/0,*+' #*-zsz}emmltt||fab "$&$"+ ",!# *"#nhi  "&&/#!+))&$  + +       + "  + +"  +^feOWV/540656;:@ECEJHFLGLPKKOJTUQ$%!$%!976vts 7231// '''IIIPPP8882448::.000228::... + + +nstafg\ab[`_ikkikk:;9}fc_tqmzsp<0.%+(&&'},.0!   ! + <4:C< 5 ;$G:2M@8E5/>2,)*!^f_=?9%*' +  QKFVPKNJE}x41,KKESSMNPJTVPOQKFHBAC=IJF 23/$%! +651/.*=:6)&"-*&&'#451+,("%8ADclop|~^jlw|}~||WUU ,'(a\]           +  +    + {,75&+*).-*/.275:?=BFAHLGFJENOK +AB>\ZYOML  0..@>>IGGDBB777222,..1330228::244244244-//&(( + ]eeDLL-55%%%*+$%-21 + +hkirqm|y{tq~{~<0.8,*:-+1/?20|z)%9,*6%"*%   ',   $ 92. 5 26 >("E93J<6A1+8,&%"))#*)    +F?: +784wut20/*(( LJJRPPQOORRREEE777"""688-//133244.00/43%*)*/.(-,(-,ejkHPP'//-554<<>FF+33*/09>=vxxqpl|~}7--9--<008,,1%%ss?33!H</,C41/# +&<('>*) 1"1- +* - *0;(#B81E95@/,:.*0-(++   $RMLOJI,('  +DBA?@>?@>451JKGGHD%&">?;YXT_^ZVUQ_^ZQPLPMIMJFEB>1.*<95$%!AB>OPL120RZZcmm`lnr~~~~~|s}}uy~jjjIIIbddRPOTRQb`_<::MKKWUU=;;897UVTIJHDEC;<:9:8/11133498=CB8>=pxwHPO'//,10-21(-,0317:84756:5=A<)*&?@>lmk;99 ?==:88JHHMMMIII???777///,.. + + + 133133/11244-21/43',+,10(-,JOPINO ,44$,,,44 !056MQR[`_W\[y{{opnqrpopnzxwusrsqp|zy|zy~{yxYQQ?77-%%1''.$$j``J@@ I??C99E;;H<8=1-  1$"B018&' /$ &$  " 2# =40C84?209-+LIEdhc #."    B=< AB@<=; ! +;<:cdb9:8564bcaefd\ZYFDCZXW@>=JHGGEDMIHIEDSONTUQ562t||~|z}z}z}|}}}~{yxy}uwwPRRY[[xyw786tuseee\_]{~|twusvtchfchfX]\JON:?>JPOGMLTZYdij;@A:?@8::8::799;><9<:364475897  422  :::"""777777333666***&&&(**%''%'' )++%''"'& %$"'&#('$)(|y~UZ[bgh^cdejklghlfgkeff`auopE=>tnoztu{uvwqr|spmdaaZWQLIVQPf\\thhrsaSTMCCIDCIGFVRQaYYaTR`NMWNKVGEWCB\MKkb_volvmjthfofc}|UTP`YV`TRzqnNIFf`aNHIRMN]XYd_``[\[VW\ZZ^\\PNNJJJ:::[[[rrr}}}wxvwxvpqoyzxvtsvtspnmpnmusrpnmusr~cd`AB@ghfKLJ231>>jjjhhh799,,,GGGUUUHHH<<>>mmm666ccc rppPNNwww fff^^^@@@~TYWIJHpusefdbXXGGG1,-133 DDDhhhMMMBBB8=>tvvdffsssLLLLLLDDDPPPCCC4668=<?==533yyyWUU888###zzzkkk''' VVV $$$hhh !!!wwwppp{{{KKK***///;;;HHHIII777HHHMMMAAA~~~!!!~~~```"""NNNNNN888 EEEqqq!!!111)))"""QQQSSS###JJJnnnqqq$$$ppp%%%+++ggg kkkyyy---zzzMMM444hhhaaa444GGGFFFjjj333333cccWWWZZZ!!!HHHxxxwww666 888444...pppEEEAAAsssfff888vvv<<>>]]]wwwHHH...CCC000fffHHHnnn---```IIIuuu'''fff111sss333(((MMMeee>>> !!!WWWmmm```ZZZQQQLLL000~~~HHHQQQ999TTT:::WWW WWW```|||[[[ qqqZZZyyy{{{UUUnnnkkkyyy ###zzzwwwMMM///(((TTT===+++%%%%%%aaaaaa ~~~(((___ cccUUUHHHUUUddd```vvv(((~~~jjj:::lllmmm???\\\XXX333nnn777MMM333hhhEEE~~~777;;;vvv***DDD'''nnnppp))) 222fff)))222]]]RRR@@@ggg===@@@777SSS555===xxxjjj)))kkk%%%444 ===666SSS---___'''rrr[[[111;;;kkkxxx + + +///;;;===888BBBrrr'''aaahhh\\\YYY%%%HHH===eeeTTTfff~~~(((uuu{{{KKK{{{VVVLLL777777^^^:::WWWpppddd+++ VVVeeeCCC444RRRAAARRRlllppp(((333 222***ddd 555---""" ZZZTTT)))$$$mmm '''tttRRRQQQxxxEEEUUU666+++iiimmmccciiiHHH444nnnKKK999ZZZccc%%%<<<666---EEEAAA+++,,,)))"""cccJJJPPP)))qqq:::nnn + + +###}}}YYY!!!QQQ```AAAppp///^^^VVV;;;lll(((666333OOOmmm lll666iii777vvv***000wwwCCCTTT... %%%gggyyy555;;;777tttfff 333444{{{XXXxxxgggqqq,,,hhh777111111111###sss[[[\\\QQQ[[[``````WWWdddKKK}}}\\\eeeuuuvvvpppzzzNNNUUUbbb```iiiooo~~~hhh\\\XXXFFFdddBBB~~~??? fffeee```qqq***BBB\\\+++LLLEEEjjj]]]???bbbdddxxxLLL$$$gggFFFvvvooobbbUUUbbbeeehhhYYYfff///YYYYYYIIIxxxvvv)))kkk555zzzXXX[[[LLLkkkqqq===[[[888___uuuoooYYYkkklllRRRGGG222III(((\\\\\\YYY\\\RRRLLLUUU666zzz+++IIIdddkkkPPPyyyqqq??? ]]]mmmnnn***'''WWWHHHGGG)))```III+++ '''aaa444%%%BBBggg'''~~~JJJ555FFF;;;:::OOOCCC {{{444 333 999IIIppp///QQQCCC???___ eeeTTT"""MMMMMM WWW,,,LLLxxxcccccc%%%oooOOOBBB"""QQQ111)))ZZZiii666YYY HHH)))dddMMM}}}JJJfffLLL))):::ooo###CCC---!!!QQQ[[[ 666))))))===%%%PPPsss???[[[TTT---KKK'''mmm444LLL$$$$$$???GGG+++dddeee{{{XXX444PPPxxxCCC:::qqqHHH333vvv(((TTT--- + + +HHHoooYYY$$$fffmmm|||;;;'''ttt<<<@@@%%%HHHvvvRRR ;;;bbb&&&===<<<gggTTTMMMWWWrrr``` + + +///||| """PPP\\\LLL999(((rrrDDD{{{gggIII,,,mmm___)))((( \ No newline at end of file diff --git a/am-kernels/kernels/slider/images/projectn.bin b/am-kernels/kernels/slider/images/projectn.bin new file mode 100644 index 0000000..100dc06 --- /dev/null +++ b/am-kernels/kernels/slider/images/projectn.bin @@ -0,0 +1,219 @@ +rrHVOqqG\\ɱҽҹxxKssMĩxxMwwLбѾxxP@@^^UU>>ljrqqqqqqqqqqqriêDDCCjjFXX??A??DDv@@DDgg'FFɩaa>>M˲IInģss=uв\GG==FFEEpvtvk\^dNuu/zz4jjggSSRR::\J>>\\QQIIYY;;ZZ``iieeWW RR RR +RR +RR +RR XX ffii__YY??VCCXXTTTTTTTTQQPPPPTTUUTTTTXXAApSSUU SS +VVXX%RRZZ +UUWWZHH\\ UUUUfXXYYRRUU^^``{{:RR8MMZZZZLXXOOcc#\\::zTII<<j_]]RREaabb]hh*22BB>>??OOUUXXRRGGJJIILLLLRRYYaa IXXWW~~Eooff\\SBBccbbeeccff cc cc cc cc dd ff ccddaaaaEET>>SSOOOOOORRcckkiiVVOOOOOOSS==mOOggggMM``!__eeffOOcc^^ggbb__ƶvv9]]]]òuu2YYcc›ԸӸԸ__ --GGeeffHH55VOORR ԼhhWWLŨ^^TTbb^^}XRR``YaaccgglXXPPCC!==EEDDDDBBGGZZgghhXXHHAADDDDDDCC77γwwGXagooiiZZVVr˳QRRYYKK%77CCJJaagg]]KK>>??GG$$IUUppΪԳѯѯЮնƝjj RRa||>]]XXxx:XXjj kk XX{{=aa!__jj qqTTOLLmmffbbaaJJ!DD``ffddPPOO--PPgggg``XXXXRRTTxRX]]^^ZW[[PPqūLLjjVVIILLUU66bb&nn.}}9iikk~~4uu5}}ww$ffdd__hhqqGpp-rr1ss2rr1ii.f^^QQ>ZZXXHH{nmm4~~Cnnee[[pp2tt>K~~Iww?bb-TVVbbNNGGHHHHHHHHPPeePPqJZZRRSS[[Iyy9\\VVbb"ZZuu%KZZ[[GMM]nn__aaee$eeee]]ZZdd nn RRoRRddUUSSVVbbbbaaVVYYcTTqq!?WWaaee"hh&iijjRROO]]SSKKHHAA@@??GGGG>>@@IIIIKKVVXXYYgg!__eeZZSSSSRR__ggggXXRRSSRRUUEEoo'~~;ZZcc~~?TTllYUU +MMnnJNNRR;;ƫvv:MM?dd!ɱjjMMbȭTRRmmhh OOp{{C[[QQoVVRRƫdXXTT|bb"XXxx1dZZRR__QQ}pp!^^aabb"[[ggTT[[cll[[kk#ʩʨzz*YYaaNNjjiiaaddee +\\ddjjɯffPPfIIO`` +bbBB^^gg|QQddccuu$rr"rr"xx*iicc``ss#uu%rr"ss#uu%iiLss9XXNN``PP[[ ii6IIiihhpprr NNLLOOTTWWNNQQll$LLeeRygg>>xxQzz?EEhh(22TTTRRmmhh OOpNZZUUll,[[ZZλOO__pp+bb"YYpp+YY[[uu3KKbbҿdd__aabb"ZZbb"KKffhhVVDD;TT__..MMJJ``eeaaVVLLWW zz1aaSSxx/IIxҺPPEElnAAWW\\ccQQȪeYYQQn[[\\ZZDѵ]] UURRoo)|CCUUNNOOrr#qqhhkk]]PPxx4FFXXQQSS\\ccJJffxx4PPtt1TVVbbNNGGHHHHHHHHPPeePPqZZ-``cc#bb"bb"bb"bb"hh&dd eeaaeecc#bb"bb"bb"cc$\\ee>ͻQQYYIddbbQQbb"[[ffoo%\\XXtt,QQvv3XXaaaabb"ZZcc"OOTTζ~~E5TTcc"v__^^YYjjZZ=ff EEwwBll4u++CC@@@@@@==CCIINN33uhh0zzNLL[[||D\YYNNHYYUUccOOIEIIXiiRR\\TT^^mm)iiSSNNoo-xxD{{OWzz/ggNNȲOO^^TɹMccQQuIUUppͩԳѮүѮնŝjj RRaJJ XXZZZZZZZZZZYYccggff\\ZZZZZZZZ[[TTUU!LYYTTXWWWW`bb"\\``RRSSZZMMUU aaaabb!]]ff\^^NNIbb!6TT````+{{Fxx=aa __aa}}aa__`` ѹYY__ll)bb"\\aaYY\\gg#LL^^ UU aaaaaa!aaddTTRRZZllJJ==TTN9TT``EE]]^^YYggkkbb99fftt*KKҶFFii&{{6YYJJV``%pĠuuFWTS\pp&aa^^||BYSV||OmV==ZZB[[``aaaabb"\\bbaa__ffaa__ WWaaaabb"ZZbb"OOQQRLḼdd#VVxx.uu.I̱[[ XXGpp+aa``tt/))LLFFFFFFFFEEIIeehhddQQCCFFFFFFLL))^ZZSSʶGGDD__"CCKDPPCCYYuFFQQ¤̳nnQQUff*yyCCC__ffccvrr&MMQdOOhh``MMLLhhaa]]PPTTeejjccSSRR]]hheeRRKKcc+JZZRRPPddhh#YY hhNNbb#\\ccHWWllUURWWaaaabb"ZZcc"PPQQdd#TT}}3XX uu%aaSSddggHHCC**}}mvv5aa\\H``,xx@tt=tt=ssttXXiiTTEEZZ +IIͷEEYY MMXX+KKWW"ee'KK]]MMQQUUaa!``ddQQNNXXllLLǪͲ\^^XXZʱccLL¡\\\\ZZqq)gg^^WWaaǯ__ ]]ll#TT"LLSSRRRRRRRRTTbbjjhhZZRRRRRRRRWW66β==HH\\ZZzz5tt.``MMoo.YYVSS^^PP]aa TTVggTTTTkk(Ü@@UUOOJJIITT@``WWuu;eRRff ͳ~~6JJ}cc3R)a:#}lzaunT22Ƚd:+yS?J?|nRȺmd~~~~ͿhipPL~|||||||||±HS!]-rr}}}}}}}}}}}zrH9Q wP{R'n@b;G d1#\Cf:!a7]6+l>=c99d99d::d::d::d::d99d:;g75AV!m@ V62,W''Ÿn?%e8 `5d9 tI1f96T(rG.h<%_5d9!e4|SN`-#zMDSôC ͿS+$sQLqk;C {ZM2qFEnBA?nU_`vLHCo]pZnXnYnYnYnYnXp[oVI"T-!@GFFFFFFFH6zyM7d1 _*E ?K HV(!UK +J[(OxzsI/e@?59οT..kBBg>>g>>g>>h?>g=?b?:_ZoEFa1 ʺX$nj[+(ǸɾżN}YMʼʼ{v^)ο˻̾ǹP,c<.b;.h:*[" h:*b;.`9+e>1f5$Z# h?2b;.X1#u[h_YCɻʼc1e`˼ʼE + Y'(mB8ƶóR'`7&EQ!!P P P R!#X \$ X$$OP P R""FW11P P P P Pa1.g72RP P P S$#JxUA=pK;odziqe^+*T__yPMd2wN@ʽͿ̾̾̾̾̾̾̾ͿȺ@W''V''X!Nl;0U$%S%%^02[-.S$$T%%W((C}SE8_MʹɴoL=FeIο¯\N3reKlnpA$`1/@j^H$yhiB3]=|aK]NBm@=c99d:9d::d99i< HHVY!O HF +HJT! I7mRN°ɸ;d1οǶųzk;!IJȶ̼İLGVW +@ U8:W)@Y''|TD>ŸcFumjf`ZMhcgbro]+sI:qnlhdJtFALg>>f==i?@vMOlCCh>?f62sGEk?AoF>ŶU""}V(\\\[U\+S(S'f<+Y.R&R&b7'`6&W%>tjn=.ͽtj7ͽF hqbAOnotG(d40>lM:L +c9%Z.V%d0n@*U)T)f<+j;.tMBF +yyyyyyzzrqrqzzz{vrQ%Y"|qA+N&\5VpqiqKBE W%%pA?L νξS +˻ʹuG7iʾðhf[\}YY^^a`^,+Ob`__[[~ZZ^^˿b[~YZ}ZY}YY}YY}YY}YY}YY[[^]v]W.B? + +? +? +N \%M? ? +? + +@ :?G{|}}}}||zy||}}zzS!X%&j?5vj`atHB]+´: +̻\1oaAs^D }b.MmnsF'd2/E˺ɽlxvzvuxuvX#"ƵD̾Frsrsob\(%vb0xlrayŲF Y9^0"NRI? + A ,\('\($\&$xXJkd]TTh`e\pic/uJ7nhy[Pz>WR\]pB:dbigli^]o@6{TSdcRyR8Fbd|XX}YY}YY}YY}YY|YY`^IlNO˿M̼}}^>>hE8`/0?dc`,c4$ͿR!x\j>(vM6rr||{{}}||||||||ttd81aXqB+vCD ~cx<MmnsF'd2/UNAAAE + +jG88:Qh7&l<,Da.g5%h6'c0b.[1\&keysSP'$JPOOOOOOOOOOP<Ek:7k:7ùsG,V@tc0.wR%uonB.V2L rOGjdsCAwqU%G ξRS{REʺP +j90lı]'o`}j?2l]W@xPHZIuJI9qú?@CC@ J_+$J +lID;SNOOOOOOOOOS8U""n@3aX{O9Ck=,a;0xQH^'m@1nKBrMCd0g5"qLCcD8S..kAAh??lCEg==i@@e76>c1*i@@i@Ai@@i??Z11}}yG »j8\Lú}`F F iξB}THOmnsE'd3/EX!_+"J"f3"˻Ih=({XAuO8ZBY!oA-{XAtO8|XAl=&T"s}lpoooooooooopqaJ4 lC.qJ/wR8a-a-wR8qJ/lC.2 Qstb.Ǿ5{len`pG-KhA/yP>|vzfȹ˾B Y)+N!@A]>5{^Wleg4'[% e`wZSc^nA=Y!d\d^gIBl[ïUl>T~e^Q}T`-j;0\*rF9ŴujG Ƹ@d1n[FV''Y''Z# ]&W&'V((E}h{_E S [% +X#!M:yNEPlmuI)d2/>Y'(E X,&h4'S6vVMWb/$®̽GF\\\\F?̾ntG7@d^Gµnd|Q:vpc=7AɷrIB_GC P! \4/vPJA[''i7!ZIZJ®[%̻[5 Z0"nG9\(U[&c9*I k`|Q9?MDHG F KDL:qSS?c71sJX&&jciB2V&|rN#T{eVG _5!Q#f6!b/ X ])V*S'S'[0Z) ^.!I s^~gtl;*l;*t~gs^I ~sQ \' F +faJbU}T^Q~T<IJ{lzPCn?7pE?G|dd}ZZ\\}YY}YY|XY`]N p@9qp_a|YX]]yXZrdY&'j_aI`-$yuICl?>VyQKM {y~Iz>ɷClaY(k;#wj9E gY# ]SU\@>X&&ǺSŲA}qzre1X ~VChWWBJ WPe_lgd0#d0#lge_WPK Mqi\AKkE3{TF`U\N}S;opK9̼Dʻmfx`MT%%ja@X%%uKCr:gQ{}XLƽP^:1_)¸}{}vJ@c/~zxdT~U=^Nh=0|t~{> d6)a50|dd}ZZ]]\\\\~[[db^(tF;_a}YY\\]]yXZrdd0/źg`B ͼA~^Of;-P~l=:^-"vPGeVslZ1,>ʹŴ=ŹW&k;#wjrD7AοG d\WJȶ6>Z'(COi:!\,C +D +g5],W&o`L`.+pLCV& =\]\]? + +_PK®UI |R7uqfAC@YJX?bP^TY.$ohjRT%%Bzo9ͿW$$uU jE+DfB5Na-Ǹ|Y@dKoVpB-_*pXaIyT:{gZ~Tɷxp> X'wK1{j90<\H~I8u\úAW |ym@k>0BQ{h|[,ʿǹW(f9*RŻƳU/$Ͽ?F +ȶwMIwMIȶG xc1Ͽ*nd1!i:/eRk^wN>X(%piiQU&&S +]OP ])Z()XJ}S>öl@:d20`Dw[J\SuIBİVqA?bRU?aS<e;/=\,%ȼ^+'Aɸ^+9gUοS Z((g?-b6,2}H|{pB<ò{ϿP_*ƿ=~>ͽe9)ynk=)FV('S%%X'&F +NW''S%%W((Cyf^) LTV{RF[85zǵk;1W TV!uaƳJ ȷſpC2]'d2%ǿa9+S!IHDD vmd>5pM=@ ]*Y0Z1\,#\,#Z1Y/],E {RP1wHZ& e52f53X$Lð;i<9i?@f==mCCRW"mfdJL%%9o>*ȶɹ<i<:h??h??i;98vc~VMsH?NrjmA0oE7k@9kYR! ±L~K,)mj]02vJD>q_jG:mCDC [Yymt,sE9y>kC8lF5kAFi85@¹Q&&V'Rs&±D =g5!B ]DdSE G lHDĸȷU&k;:UST*ǽEHKJJP_,!QJKJJM;j[k`U$!w@c2,g==e;;f<+F%%k;*]*7Ⱦb>Y10{i]*$M'X-X.a3!WZ'[1![1!D H1RZ# +QGDF@ H$!Q$"i?8e3ȷoE5ȷQb1.X''F <qkfeT" ^--`-*V&'Q""Y*+e78T%%V%%_+'`//S "uM;iLLV!^& IyzArJ;d>1^6(e?1j=.O {PI{OHFξedd0)ɺ˽̾ƺǶa4&cX|o.sg}YKaPsH>q^X#s?<F +``a]I xlg6*U0*T%%qgnKDAijqD;Z(%nEE~~B̾IJn@,qA8tH>jVÿ[&ʹ˺e3ϾWƳY"}g;*9ĻO[/-\5 XOo`oCA~V,,^]U# e6G f^ySErKA|~h87;sE0Us_-%SüLȶ<˿kdS"? ʹ4|SFU#<|lh=;d66|mgQlii;.R zOCeXa31g:9ɸtH@ghD:zqabwKGBOc^ɼ= +T%%kgi?@BuoP ÿsLKzzB˼ɻ|T>mC>]/!`3"g;(T `2)t4{YI`0!úkE:c0h5)\&_-tmmLL__\\\\\\qobb}YY}bbzuB{yʿL|pj?4K%%O# ʼ\-̼Pe]mJAJ^>:`6%h]=rh9w-{{i93}ZW>sD"sG5j_VJCF {>l:!?rkW!tg^(/?th<oTO`2 vsEuIApB'P [LI d0$˻@j9,qlBh:.|@mfd4!wcGL˼_`yMJB~9j]̾H T%%lhl@Ad=7}qsI2X*d<)\2X+Y.f<<}}B̽f`zsǾqhwe4'@,¯MĽ3y?|O>0BOW D <=<@ )voC»nMM__\\\\`^CqFE``z_]vH?}x|Cog[+{*> <;;OW-°^)wpJ^-nF +C.o[[a/hV^.'ƴW(Ƿ5b.yM-_*e2X!T?g_19<ǴA~T5P;ĺTvI@=TUQYCF __xMIA\4+m<%ZR˽F +T%%lhl@Aͽg==}}@ 5X"T E<;=;<= Jg3%Z"*hXsJ?Z&˼žPc=5`Tf2(O<b.$QοiT\/ NK{O;KbHyREe8.¾K^-tG8k:U`SOlIAd=8J_=||BD ʺY*OͿ±y]' ǽ{mSGSȼ\&K scY%E +˼I dVzW R"ʻeXgWxNA]N`8-vI;pA$fgwLH~g85gQU6n>&q[_ExO:X&&V$$pA3V<vm=4l=4fWf6'B19:xMCP Y-'sL7aRH IJqC#c2.о=¯8V?Nh^I JgU],"c.%EggwLHBdduIF˽F +T%%lhl@@c>3qgb3%sK;nbe;:}}B̾[.+_10[//\/.^.0qH8? + ElhFS$#T#%_)TWX&&S##MbGHP.^+(R$$S%%Q!!b20b40ykuoIF rL=ʺ_.[%a2&T//kAAf==f<?h71N{OIsKLe;;f<<ǵqC#c2.ͽ:Ƕ=̼l:1a0G {PF}u^4%B˽hjuIEB__vJG˽F +T%%lhl@A|h:+ug\JGe<<}}B̾NO +? + +F̾jZk:-xL9Ryg4JF +vkeh8'[$ rC'[4#H {Q>ss}}}}||rjVwt||||}}utò˽]-{jczvc1/Pd1 upga__xMIAK> +B 2bE@{ʾF h_pjpE?B ʺ5j<+pC.Y!}T3Z"kTF ǵsF'g62Ͽ?J {OF=spLH+$̾?\]ZWC_`vJG˽E +S%%kfl@A8ƺT-"b:+aA?B̾~j@@c4$? + +F̾Ŵ>fEuH8],'ŴF Ϳ].xf{P;o> }U>__xMIi93tHEF +C ~]W?rnX*lXJ +B lB(ukJ +>w6XJtJ=xK7?c2U-/ȶ(=tF?n@h=>]Q:IͿ:pl~y7T]RG D|<A c--@ +b2!aDAN>uKE6y˺;vQFI_-0H h9(pwRFqM;ϿL^/%ȷP)HoK6y^_kJFU/+T%popTKNQQUIJE c0SR W'(H5|]]zXU9ľy_`jIDvexksf|murev[.$bGHR&X*+f9(YBob±nnMRIO"Z+-H c2 <oH?6{1kD=Fƾc0Y%iYijhW|TGȶaB4{l}ɿh>$οǿ²|iZvĺȺƶtM4fYcMvvaa::nmWW>>__MNhi::PPLL:<dd??,,]];=]^UXTTpp~YY9:WWggff qqgg54&''&==}}JJnnoouuiiii``hhsshhijooAAAAHHZXMK[Y<<  XXCC;;oo*)33FF,,ZZrrWWQQZZ__ ddNN?@[[OPddGGttooqqqqoommZ\  + +II||oo QPyy))xx6666*) YXGF`^XX22LL[[rr))''<=JK<? $$ bbKKOO ZZ##--nn! llpp (($$RS\\``$$`a]]__uuIIIIsslldcFF-.KJNNwx23ba--33! RREE++ssbb"#0/ee88}|~~ ;;mmllLLut{zbbqq>>HIlkcaa_VUec[Y_^hfIH//||GGSSoo%%00nn>>eeRRjjQQ$$RR\\``%%##44RR<<9:~HH %%.-[\TSvv<>XX-,}}44'&XX78LLRRJJ]^33DDPP,,XXJJ55!!EF55$%IJ"" DD@@ddqqFF33QPTTZZGG44QQ..KK + +>>fe..wwBB=>eezzzz{{{{vv3197VW55A@02[Ywtyvifnk~{vsqnsppmkh""55tugf3322ww33ii~~+,+,11==ļ 6 +5;7fr#{{yn{rs~wp~rr~ss|srvrsswswryt}r~Ssh#5{0PKKKKKKKKKLLLKLMMKKMLKKKKKKKMD M%    + + $)#<+*7*7'+% & (-/2"3!8<&8'<(8!;$9!?#>!?"A@"A"?" =! ? A"@DC"$G$@ @$C%A"B"A" >$@%#?">%@#(F'$Hj=e6e7e7e7e7e7e7e6e7a1V$],f8^.Q[*g9c4U"\+e7e6e7e7e7e7e6f8_/_.-((43(40)37&21$0*'0-(0/*1/&1+&10B5,91$=3:G9+!81):/.*&- (8% 3"$3'2$6(%4)&7%8'&9$$8$"8#"8#":&'<&)=('<'&:'':'&=$":%#<%(=($=%#?*$>$$<%&<&#;%#>&"=&#<,'<&&<)$=)&8&/D/Fh:b3c4c4c4c4c4c4d5],^/h:T!qFe6`0IaS f7c4c4c4c4c4d5],^.*#$0/%0+)'+)!+)+(,) +%%0,>E,%*-93, 80#30#(3%,MG )4)$9) 02$)4'$4&!4&$6# 3!!7 '8&!5!%4"#8""6"#8##8%4'>,';+!7!!7 "8""8*$7#(8#7$$6&"9'#8$#9!"8%'8)'8(*>+ Gh;c3c4c4c4c4c4c4g9NwrD mBs>vLZRf8c4c4c4c4c4d6],^./$1/ /) ,''$#(&% &( '-"/()00* ,80"'D?;6'3%C:/#+!%3* * 2",0%5 "0!!/!4 2 2! 2#!2!!4! 3 2"23 3%5" 3!!2! 3!!3"!3!1 "4 2 !2 !0"&3&!1$$4%*7*Gh;c3c4c4c4c4c4c4e6MJ*Lk>ĶAnYSf8c4c4c4c4c4d6],^.( 3'!-(!0$#,))(%#((5/ (,* -/**%$.(#>01',/3,;3!/ #"+%9-(0#4$!0 0 .!/#0"0/1!$0-!0 /1#2"3$!/"1!-#!.!"0$3#"/ !-% /$"3 /" /(5*Gh;c3c4c4c4c4c4e7U"rHi[c4zb5|pIjQf8c4c4c4c4c4d6],^.-"!.*!1+*&*#) *$' 5#?9!""8/%/,"',C?3+&. !>0.L/+")'=.8"0)%2%-* /!0.,-1..+.!1/"-/"-$- +! ,!/"". 0!,!%5& Fh:b3c3c3c3c3b3f8KoRuIlN^5WnBmPf8b3c3c3c3b3d5],^.,,%/*+)!+)"()& '%)%;)=5"5,'$*!" 7($0$<2J6%(&,@4$=!C3+?9+ /Q8**"-+.),-,+,,-*-,+-#.# ,!*" +"+&1(LmBh:h;h;h;h;h;j<]-~a.b4QdIɳW$xM]\,j>h;h;h;h;h;i*.%)*$'+*++)+/0"2 1$:ƾ_bahsq:ch0&($75''&&" $&))w(")N7,X0(+!2&*6!, &#&>/34/%6 +/0dMTD 0/E6.)!16"'B31'&,!/++,+ppo scLKջ:Šՙ*ћ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ(қ*ћԙB͢`"xɎ˒ʑʒʒʒʒʒʒʒʒʒʒʒʒʒʒ"˔ ŇXӧVѧǓƑƑƑƑƑƑƑƑƑƐƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑǒč-ȓgv!//K\`89TheYilPcbTgf`tu_uuhyw9H@ '!3$&###&+!f'1 V/&T(T7*>-g(4! +#$(-Qh]xбȼhuC>yA(.8+7(!6(."4#4TB<%( *(*!.!3 +#{zqoPNHH^_ssttttttuupp_`./-,[] [̝2М/М/М/М/М2Н/М/М2Н/М/М/М/М3ў2Н/М/М1Н0М/М/М1Ϝ#әD̢c+~0/͜0Μ/ϛ/Λ/ϛ/ϛ0ϛ0Ϝ0Ϝ0Ϝ0Ϝ.Λ/ϛ0Ϝ0Ϝ/ϛ.Λ3НɐS֪S֪ɐ3Н.Λ0Ϝ4О/ϛ.Λ1Ϝ3Н/ϛ5О5О4Н/ϛ2Ϝ0Ϝ.Λ/Λ0ϛ3Н/ϛ2ϝ0Ϝ.Λ0Ϝ1Ϝ.Λ0Ϝ&͗,͘ $"DISoso}Qgm(:3 +4':6)'O@ !$c P(L,(C*U,F%a!?* #&$ (˲ 37Z/,M"9U1ba +$-!(i'L$%,>B/M6*0L3*(6 #\^(*..MLmlrrqqqqqqrqjiIJ*+/.ab (80ȟ1М1Ϝ1Ϝ1Ϝ˓0Λ2Ϝ"˕1Ϝ3ϝ3ϝ1Ϝɏ ˔5О.Λ%̖(͘3ϝ1Ϝ3Μ&ҚFˢd.3/͜+̙3Н2Ϝ/Λ0Ϝ.Κ&̗$̖$̖'͗5О/ϛ#̕&̖3Н2Ϝ6ОʑT׬T׬ʑ6О3ϝ*͘ɏ-Κ4Н&̗ʒ-ΚȎ ƊȎ/ϛ"̕,Ι2ϝ2ϝ-Κʒ0ϛ˓,Ι3Н+Ι&̗3ϝ3ϝ%ɔD}}}EDD-7::DD96&>UYZqvAQT &"*"=*9%%>D$(r:1R' L,&R.(P)L*V C)  $'`J[M "Pps3Qsow#10/90 =e;OD0"#%=-/ G06,*EC."'9O++80˞1Ϝ3Нʒr޼,Κʒmݹ!˔*Ι+ΚȐ`ڲ Nj&͗\دHէ%̖3ϝ3Μ&ҚF̢d.1+̚/͛&͗0Ϝ0ϛ)͘)͘<ҢFԦFԦDӥ˓%̖IըAӤɐ/Λ6ОʑS֫S֫ʑ7џ'͗@ӣ"˔!˔U׭ʑʒmݹ/ϛ-Κ,Ι1ϛɐ:ѡ"̕AӤ_ڲ!˔6О'˖6ؤiiijmn +t"D>*@NMFVaf}~)..(G<6'1%83 #P+S)T6.T2+W/&I%K+#<& "!& ')YgSg|iz2 9PD' *25gdɏ-BMLF?$ +3&09wm!,&!+/- !1 >?}}mnnnpmnm&41SN%N(U*!R* Y(U*$G(G,#<'  !'$&.boa +'}h"-. :*Y2&<5& (( $) +%- +RsM!G:?!'~8Tg),1 +hWog[Ve1"0/ ..0-11 00#/.05 +{zzzzzzya=45٘1͝.Ϛ(͘WԥY׭_ٱ=Ѡu޼8Н}O֫q۵Uլ޼`دgڴXد˓4Н3Μ&ҚF̢d1 V׮^ڲȎ۶,͗*̖Hը)̗6О$˓;ҡ:ϝ[ٰ$̖˓S֫S֫ʑ9Ѡ ˔HԦqݹƊ yŇȎ~Gѡ+ʒȍ6ΚZ׭{Ȏ8џ)͘-͙tttnon 0XI"8+'$:,^!LB?US 1%+*)<=I? +3+$4LK9QR4PO+IG,*"&?' 7")J6 %%$'4kMle02()-8MEudLn~$R"#4-02.!2/*01&5S1 TңȍƊƊ Ɗ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ċ +Ê +Š +Ê Ċ Ċ Ċ Ċ Ċ Ċ ŊȊҊي!ۊ"܊#݊#݊#݊#݊#݊#݊#݋#ۊ(؀`*8kK)ؚ2˞1М4Н ˔Eԧ\د_ٱ<Ϝuݹ4͗ +Ä{ܶDО@џ+˓]֬Xدʓ4Н3Μ&ҚF̢d1 V׮kܸ Ɖ(̖'˓ɏ<Ң/ϜLթʐȎFԧ)͘ʒS֫S֫ʑ9Ѡ ˔IԧȎ +ĆƉ%̖Ň}nje۵aٰ>ѡ&͗5О)͘-͙tttTVYwz{~="% kD14BB(=4/?0lurqzFNJ '00!+(!!)%!" bvn0$E"L0)((# ( +Fjd&M9( 0, ' -m}UbP 2 2121&-62<(Q5'F&FNKZد ˔;ѡ6П6П6П6П6П6П6П6П6П6П:Ѡ7џ6П6П6П6П6П6П6П:ѡ7П8Ѡ6П6П6П4Ο3͟3͟3̟3͟3͟3͟3͟3͟3̟3͟2˞9Ǘw^ì@Ǟ%ћ3Ϝ1Ϝ2ϝ%̖Lթ_ڲ[ٰ6ОqܶJը"̕4Н3Μ&ҚF̢d/+=ТCҥ+Ιʒw߾'͗P֫~v߽}iܷnjQ֪S׬ʑ9ѠʑS֫S֫ʑ7П*͙5Оq޻%̖'͗:џiܷʒw߾z,ΚM֪!˔<ѡ/Λ ˔Q֫,Κʒeܶ5ϝʑ5О2ϝ)͘-͙tttprs/76?HS)00qU;R-JIy3&+UY?e,! .66/54DMMDLDfiiIHJ3":^B# ,IE2gbA&X׭ʑ5О0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ1Ϝ˓,Ι1Ϝ0ϛ0Ϝ0Ϝ0ϛ1Ϝ/ϛ˓.Κ'͗0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ0Λ7Ǘpdݩ;ț&Ӛ5ϝ4О5О*Ι@ӣXد˔7П*Ι=Ң=џ*Ι:ҡ9ѡ,Κɏkܸ ˔6О3ϝ5ϝ&ҚF̢d.4*˙)̙4Н3ϝʒ0ϛ%̖ɏɏɐ˓5О˔!˕ʓʑ4Н5ОʑS֫S֫ʑ5О2ϝ+ΙȎ-Κ5О!˕ʑ+͙ʑȍ Ɗ-Κ'͗2ϝ+Ι-Κ3ϝ&̗2Ϝ5ОʓȎ+Ι5О0Ϝ3ϝ)͘-͙tttqpq$0)eL|WKF{hX7[b[#F:itv ..hpo(&  4?99C9("!$*#  2<-.7$-FEI% +;$ &(M!#'.-"93\.5N|w8*--15##!>) #O.3,$"Z1X׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2Ϝ'͗\ٱ5О2Ϝ4О0Ϝ4Н6О4Н*͙`ڲ%̖Dӥ*͙5О5О6О3Н1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1ϝ0͛7Ȗs`ޫ<ț(ӛ)̗˓ʒ)̘ɏȏ ˔*͙&̗ɐ˓(̘ ʑʒ+͙0ϛąȍ#̕˓'̗*̘%ҚF̢d.23Ξ-͚'͗+͙ʒɑʒ#̕6О'͗0ϛ+Ι+Ι-Κ%̖5О0Ϝ6ОʑS֫S֫ʑ6О1Ϝ.ΛGԦ7Пʑ<ѡ)͘6Оʓ8ПHը)͘&̗&̖'͘+Ι0ϛ)͘˓ ˔&͗"̕˓-Κ1Ϝ3ϝ)͘-͙tttppp)80!*'yeM]76.PZN$8GSp7MHȜїIӧUدAҢGԥN֫aڳ(͗AӤ ̕{޽8ҡ5О ˔BԦWدq޺9ҢMԪ$љE̢d.4$ʗ8ϠXٯʑsݺe۵ɏ<Ѣ.ΚSժ˔t߼˓4Н5ОʑS֫S֫ʑ5О5ОɐSըJըp۵>ң*̖ɏg۵R֪P֫Iէʑ`ڳbڳNը#̕1Ϝ2ϝ)͘-͙tttpop,7/!%!EJC(   + .86AJM:AG6@@!*&(<'#$% S]RV^P%" +  "*"&/  +" @=+*<)eF[M#+ D!69v<9# +! $ $ F46&(%!( 5"?))+#?'G7 1X׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ3НɏXدŇJթX׭Ɖ&ʒ Ɗd۶Jը"̕3Н1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1ϝ0͛7Ȗsaޫ>ɜЖ7ϝw۵޻_ٰNjqݸWخ/ΚY֬ їEˡd.2'˘jڶ/Κr۵T׫˓V׬k۴W׬}ʑ5О5ОʑS֫S֫ʑ7П.Κ7Оlڲdح`׭mܶY׭߾DԦʒ%̖Uըrٱ_׭bը%̗0Ϝ2ϝ)͘-͙ttt $-6,31"'""1'",$2(!1,3>@=LS;GL?EI !   5A;.     +". C +) F3I6"fW H!U:!WP .Z=:#+ P3!I!!%K+(.!#L *3&+ "9"X׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ3НȎdڲ6Κ0Ι%ȍDҢ*̕~ ʔʑV֪ɏ5О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1ϝ0͛7Ȗsaޫ>ɜΒpݺnٱ4̖lخU֪5О$ɐ]Ԫڳ2˚Uթ ʼnHОpڳ~߾$ҙCˠd/.3Ξ+͗x߽nݹ5Н^׬x޻)͗R֫ʑ5О5ОʑS֫S֫ʑ5О6П ňLҥ_֪iթcخÄGҡhܷ~{EԦȍu޺߽XӤ!˔/ϛ3ϝ)͘-͙ttt}}z )5  ) +gg]KWK( +%4"8 '7@;5?B8Н(͘}߼TԧNԧ*̕w߽4ϛą˓3ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1ϝ0͛7Ȗsa߫:ǚ$ҙݹhٱHԥW֫lݸ|߼8ϛIӤO֪CҤЕF̢d-8Ċmش޺8Λ\ٱU׬Q֪Ɗeٰ}߽ʒnjɑ5О5ОʑS֫S֫ʑ7П)͙4Ϝ|ݹsܷi۵GӤmڳ‚vݹ>ң1ϜsڲrٱO֩#̕5О)͘-͙tttsrs $5A8$MSNYgghmdAI23>+%%-$-&" 4?;$-'!4"HXF/    :'@2bV-35p<  B:(qf$B+'@> +gA6o  ,R0"@!  + <&%^- $%5&&#=*. &*  X׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ3ϝɐCӥ*͙ʑKӣAӤNj&̕ʐcٱɏ5О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1ϝ0͛7Ȗsaޫ=ȜїƋeخƎxݹ-˔ ŇYدȍNjN׬CОlܷ:ѡrݹx߾̎Kͤd/1#ʖɑwܷ{۵IԥHҢpڴMԦȎ6П5ОʑS֫S֫ʑ8џ#̕lݸ7Κ]ڲk۹FӥrݹKӥ3Ι)˓9ϜQ֪6̖ƊDҡ&͗5О)͘-͙tttstu!##5@B[jW(/0JN,DL(5++UV' / O_Y.'(1,##!!+/A+%8 >2;&$%%  + 21-wu2-/)xg 6-+6 ( 29%!T7;a U!: @%$WM .( ' 1("?-X׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2Ϝ)͘Hԧ-Κ)͘Hԧ˓HըmܸXد&̗Kը$̖=Ңʒ*Ιkܷ\ٰʒ-Κ2Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1ϝ0͛7Ȗsaޫ=Ȝ!ј8П2͗ȏvݸ>ӤɐNj3Ϝtݹ[׭Wخ€4Оv߽+͙Jңoݹ$˖$ҙF̢d./.͜YӦcڲ-͙߼fڲą@џOң Ɖ2ϝ6ОʑS֫S֫ʑ5О5О Ɗ[׭)̗W֫9ΞȎ|=ҡ4͘\خŇ1Κ^׫t޺h۵v۴!˓/ϛ3ϝ)͘-͙rsrxws#$)4*""!"2&d*!$1#+ 1*&0)2=1 &5$*2-a)(`% Z%b*&#(&;I+ +).,2. (/UM(]K(bBI)!#.}[dN./ #3$%" *!*X׭ʑ5О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ%̖.Λ0ϛ&̗2Ϝ$̖ʑ!˔0Ϝ$̖/ϛ*͙3Н+Ιʑʓ1Ϝ2Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ0͛7Ȗsaޫ<ț&ӛ)̗c۵lݹz߾-ΚʓAңʒz-Κ NJ*Ιm۹!ʔ(ӛF̢d-5ɔAѥv߼"˓bٲi۵ʑR׭Aѡʒ9ѠʑS֫S֫ʑ5О4Н ˔q۶[ٰʑȎLԧ߾Ã4ОZدj۶U֫%̗1Ϝ2ϝ)͘,͘ttt@ʓ߽qqp%)".!)$"#  +7E.%4.=$-*(&!!#."4G;,)%4  + !/  +3M;/ 0 + +.# +*@.4'1X9 !K>I%!+!%6!Xخʓ8Ѡ3Н3Н3Н3Н3Н3Н3Н3Н3Н3Н6П4О3Н6О3Н6О7П6О3Н6П4Н5О3Н5О7П6П4Н3Н3Н3Н3Н3Н3Н3Н3Н3О3Ν:ȗsaޫ<ț&ӛ2Μ˓Ɏ!˕Hէ"˔-ΚO֫Xخ˔$̖-Κʒ,Ι/ϛQ׫(͘,Κʑ9О1Λ%ҚF̢d.2,̚7ϟDԥq޻N֫ Ɖ/Ϝv߽JըdڳȎ!˕ȎNjZد*Ι6ОʑS֫V׭ ˔:Ѡ6П0ϜCӥ;Ѡ8П$̖+Κ)͙2ϝ1Κ(͘/Ϝ2Н)͘0Ϝ+Ι1Ϝ4О4О*͘'͘0Ϝ-Ι0Ϝ6О7П.Κ0ΛBBBtttJΙ޻bҢ`Ѡ}۴pqp (2. 3""4!1/9%3<279'$-:/FOC5@-(4>4CN@1#-4?3COO+tth|smslkodS\Mbh_*7 ( %" + + 4 -.210vdL}B\?' +5 5&.R:$?#"! 7#!Uӥ€ȎNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjNjnjŊf\ܫ<ǚ'њ4͜6Ν7Ϟ2Λȏ'˖4Μ2͛'˖$ʕ2͛5Μ3Μ4Μ0͚0͚'˖3Μ3Μ4Μ.͚4͜'ЙFʡe/44Ο.͛'͗ʒ%̖9Ѡ.Λʒ$̖ ˔6П2ϝɐ4Н7П%̗3ϝ8џʒS֫OҢĄʒɐɐȍȎȎʑʑɐȏɏɐɐɐɐɐɐɐɏɏɐɐɏɐɐɐʑnj$ȍIJI޼޺޻VԧLҢ^֪pqp $/! '# GRBjthgpf*;D;`_dCME2>*-8-BMD )P]QW]WIOD'19)29#*4)7%'5 &2 !5):%  *'"F)#8*/ (- g=A8Z0>;,1= 76:,&& #:!:1 "ƥ>ѣܞ)ؠ&؟&؟'ٟ+ڢ(٠&؟&؟)٠)٠&؟&؟&؟&؟&؟'ٟ)٠&؟&؟&؟'ٟ)ؠܝAԦť ] w ɑ˔!˔#̕ ˔ʓ˓"̕!˔"˕ʓ˓#̕˓˓!˔˓#̕ ňSէZ׭hܶf۴e۴g۵f۵f۴e۴e۴e۴e۴f۴e۴e۴e۴e۴e۴e۴e۴e۴e۴e۴e۴e۴e۴e۴e۴g۵`ڲv۶tttk֪ݺ۴uӤB͗Jџ`Ԧrrq":(Y(,6*9H4-@-/;/-9.5G3'8GODGNN"' 4>9JSG+! !)  "+&7   5V@ 0&5 / ( D,]D1;8;57$684 A;4#?1/50= 9! !!ɼrsrXժqڱvܷMѠl׭zwx'N1)S29,LUE  4"$' +  +8)"/)8 (7"2@+"0 9>5IS@ZdT(6 &5$!)!E@! +)-5* 7/( 422 <1 5#=95?=<"=;8#=#@4! %%#TҢ~nj Ɖ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɖ Ɖ Ɖ Ɖ Ɖ Ɗ Ɖ Ɖ Ɗ Ɗ Ɖ Ɖ Ɗ Ɗ Ɗ Ɗ Ɗ Ɗ Ɖ ƊÌlQ!heeeeeeeeeeeeeeeeeeeeeeedet#ŎȔ˓˓˓˓˓˓˓˓˓˓˓˓˓˓˓˓˓˔ɐ Ɗ Ɖ +ň +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +Ɖ +ňnjwosrl֩ٱrңxدnpp &/!;>5JRF$   %"Y_UU[P +  +#COGVWPBKFEMFGP=$6+! J?%*3/+79;90875#@5 $?>!=8;4="A<!@;2$0!$ )&)Zد ˔;ѡ6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6О6О6О6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6џ<Ң n91.////////////////////31633Œ3͘3О3Н3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ3ϝ4Н6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6П6О=ҢȎpsr]Ԧnop,7##381LWL*1,!!*+.&*/)&083   +  !!'2($3(+1)#%7A+*$3"$ ""L!MA+>)C'!3;!<$86%C5A!<!: D2"B$B;$A B?<'?%"CC 2""""#""!"!)'&X׭ʑ5О0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ1Ϝ0Ϝ2ϝ2Ϝ3Н3Н3Н4Н2Ϝ2Ϝ3ϝ2Ϝ4О2Ϝ4Н3ϝ1Ϝ3ϝ2Ϝ3ϝ3ϝ2Ϝ3ϝ1Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0ϛ6џÉ z8“122222222222222222224545Ñ4ŕ4ʘ4̚2Μ1Н4Н4Н4Н4Н4Н1Ϝ0Ϝ4Н3Н2ϝ3Н3Н3ϝ3ϝ4Н4Н4Н2Ϝ3ϝ2ϝ2Ϝ1Ϝ2Ϝ2Ϝ1Ϝ2Ϝ1Ϝ2ϝ1Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ0Ϝ7ПNjosrnnt *5#$&-(`a[ '(#)" +088%"" *$% IYH&-83+<-'##%+%'M#< $wY.`+_>'+!#?!> 1!B&CB>"A'$C!@!;!B%E"A%C;<*D$BH%= % #)# %%!*#($!0+)X׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2ϝ%̖)͘!˔ʒʒ˓*͙&͗˔"̕Ȏ"̖ʑ ˔*͙ ˔$̖˓˔%̖˔,Κ2Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ7џǍ†8Λ0̗1̘1̘1̘1̘1̘1̘1̘1̘1̘1̘1̘1̘1̘1̘1̘1̘1̘0̗2͘)ʔȏ ȏƎǍ ɔ˕'͘-Κ˓˓˓˓˓-Κ2ϝ˓"˔)͘"̕ ˔&̗"̕ ˔˓ʒ(͘˔$̖(͘/ϛ)͘+͙+Ι)͘.Κ'͗.Κ2Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ8џNjosrooq%'!'*'NQN(*'$**0'$-%'"4=2HMO)  (".DIV@KF&-/('"#.'T]R ,/$2# ! 7 1o6(^I=zr-K NpkP(+?!$A!+H&6J))E'/N**D%0H*/R(+K$.I'3S,.K(1L&*J,,C&(L'=+F-+C&-.)',$+')*(%)'*+(**)(/-.X׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ6Пɐnݸ:О@Ӥr޻Gԧ-Κ{߽U׭iܷrܸ%̖z߽-Κ.Λ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ7Пnjʼn8С1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν1Ν3Ϟ)͚?ҤO֭?ҥvݼ?ӣO׫=Ң)͘UخVخU׭VخWخ1Ϝnjx߽R׭%̕Mթlݸ6ОZٯXدK֩}pܸRթ#̕S׭O֫5НN֪Gը\ײ2ϝ.ϛ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ8џNjosroop++5-(:#Y]S'9 3=.USZqjrFCG'&/EKZTXjNLY"#&00F02C261GMR_KUX;DEAFG7?AABGRVSlsoENG"'0*  K18->' A5  , ) +( 2+ 1 &- 5 + /- 3 8!< ;!78P%L .B),#)/&*5.-/.-/--0+/4.1,(+0-1 X׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2Ϝ*͘1Ϝwܻ߽ÃĄtܹ=͙3͖,Κ-߽͘Ǎ0Ϝ+Ι1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ7Пnjň8џ1ϛ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ6Оɏ|ݹb۴V׭kݸXدS׬HԧJԧ\֨߿cٰ˓tܷ@ϛ~*ʓFԦ'̗3ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ8џNjosrsrt&-17!.3D,;F5&:!,>$511''( )&"82M75F'&)&.1ADDU +&!%7?EW,G%&V]R|uJ^HE]GWpY0N)1H-#-'  mz}x{kvoswkm@^@/W!&=.(<)))+$%%%"'(#%#$"+%$4.0 + +X׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ4Н ˔j۹{߽u۴v۵Kժq޺>Ң[ٯu޹5Нܷ$̕-Κ2Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ7Пnjň8џ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ4Н ˔V֫lܸJҤOԧS֫HңjݹcدÄ!˔ŇQԦQ׬f۴޻qڳ(̕S֪UԦuܷ߼bٰȎhٰlد*͘.Λ2Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ8џNjosrwvw +!$(5'EPEX[MHN>HM=RNH:2:<06*,KBHe"(>6-/G 'C".90 C, ?' >&@%,K-(J($(& !$__LLX׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2ϝ,Κ/Κiׯ{޻`ٰeڳmܹW֬j۳q޺EԦl׭t۴ݼxڲU׬"̕4Н1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ7Пnjň8џ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2ϝ'͗;ѠNթ1ϛn޺mݹ!˔@ң&̗]ٱb۴#˔uܶwܶzܷBѠGէlحS֩7Пqڲ߾޼kٲ,͘.Λ2Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ8џNjosrttt !'(2?I9bl\TOBGG6]XK]TL[! C$#G #M!#H%(OAC$D$8?7RF.J;0J9*G1/P/?^:%.'%,)^fc^_ZMMTStsX׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2Ϝ,Κ/Κ}ܶj۴Pթrݸ6Ϝq۷Cѡ[ذRНcԨ_ڲ ˔5О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ7Пnjň8џ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ*͙3Н{޻Vէ޼qܸ|ݸ*͘q޼bدņ&̗ +ƉMԦmݹx߾yݹzܷ%˔ņKОVҠ(˔CҢNԫȍ_س1ϝ,Ι2ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ8џNjosrqrr #&-*/DB>A::k\]K &W,n%CtxwH W=.fMJqG@k--b-/q//j!)T##V18`&2W)0[%2P0CN$HJ*=>4M=*E0*B.$&2'7>:%4,EE>UUffCCX׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2Ϝ-Κ8ѡW֫vڳhڳIԦ~y޻|tܸ>ϛ6͗3Н)͘2Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ7Пnjň8џ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ*͘3П޺Mѡ\թiذ0ϜkݹDӥ[ٰGԦhܶÄv߽u۴uڳt޻ȎHԦʑ4ϟ#̔R׫߾_׬Dңw߼'ʓBӤ&̗3ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ8џNjosrlll +CDQ.%&-/>!5M,;#G9JZP bU>A4~8*2%")!&)m+-v<;-3qBB&+b+6bC0WBCEWc!(5>@,781;0qz,B6VdVSTSRX׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2ϝ)͘N֪q޼Dӣ~ܷb׫f۴Dӥ*͘ +Ɖ=Ѡ Nj4Нbٱ^د.Λ-Κ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ7Пnjň8џ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ-Κ*Κwܵ)͘e۶Zٰjܷ\ٰbڳĆy߽'̖x߾FӦq޻$ʒ<П=ҡ)͘2ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ8џNjosroop '46G90<=,bF1l=w_yL^{ RZa%q,~5/-+  ("$y?%[9F&:$)19>N$,9*(3#)."7?544OPX׭ʑ6О1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ2ϝ$̖ʑ%˓#̖$̖"̕&͗$̖'͗ɏ)͘0ϛ7Ϟ1ϝ2Ϝ+Ι(͘2ϝ ˔"̕3Н'͗+Ι2Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ7Пnjň8џ0Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ.Λ2ϝP֫Ȍ)Ι-Ϝ˔Aӣ5О$̖ɏɐʑɐɏ+Ι&̗Kթ7џ#̗%͘1ϝP֫˓ʑ˓-Λ)͙˒)͘-Κ,Ι4ϝ.Ϝ*Ι4ϝ)͘0Κ.Λ0Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ8џNjosrqqq%):8(.6;H._ YQ H WQU9B ; :- +7 04CG$HB!,]#D38AG-4:6B<2>65=8;=6X׭ʑ5О0Ϝ0Ϝ1Ϝ1Ϝ1Ϝ1Ϝ0Ϝ3ϝ3Н1ϝ2Ϝ2Ϝ2Ϝ0ϛ1Ϝ1Ϝ4О2Ϝ0Ϝ-Κ/ϛ0Ϝ1Ϝ0Ϝ.Λ2Ϝ1Ϝ.Λ1Ϝ1Ϝ0Ϝ1Ϝ1Ϝ1Ϝ1Ϝ0Ϝ0Ϝ6ПnjŇ7П0ϛ0Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ0Ϝ1Ϝ.Κ$̖2ϝ/Λ.Κ0ϛ(͘-Κ2Ϝ4О5О5О5О5О1Ϝ2ϝ'͗)͘0ϛ/Λ+Ι%̖3ϝ5О3ϝ.Κ/Λ1Ϝ/Λ/Λ0Ϝ,Κ-Κ/ϛ-Κ.Κ-Κ0ϛ1Ϝ0Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ1Ϝ0Ϝ0Ϝ7ПNjqusoop'%@%0 $@.L,o#Ey)_c/nN ZY&P%HI#Y/BMEPS"B +L!%s#G49U,,H@FK,162@:/:)hiLM[ٰ"̕<Ң7џ8џ8џ8џ8џ8џ8џ8џ8џ8џ7џ7џ7џ7џ7џ7џ7џ8џ8џ8Ѡ8џ8џ8џ8џ8џ7џ7џ8џ8џ8џ8џ8џ8џ8џ8џ8џ7џ>ҢɐNj>ң7П8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8Ѡ:Ѡ7П7џ7џ7џ9Ѡ8Ѡ7џ7џ7џ7џ7џ7џ8џ7џ:Ѡ9Ѡ7џ7џ8Ѡ:Ѡ7џ8џ7џ7џ7џ7џ7џ7џ8џ8Ѡ8Ѡ8џ8Ѡ8џ8Ѡ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ8џ7џ<Ϡ"֜i~osX\[ppp//?34G6)=RATC!6lEqyZs]l,aGAI%@<, +A#,:/ -"['H'1=%(7!+0*35 --86%%8:2-E/1133SҢ~nj Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ ŊǍxݻtǍ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ Ŋ ŊŋɄdvxw5/?G;P,!!u8mqtz{ uwwwx ge +Q#R%>!- &$&*473B8@:#,EFJ]ek[[WVqrr+ # ')*.6!8!= C1U_ kh gdaj g +d i[]Q5F8;97#>2$@2(B3&<2&=(>##H44IEnwk~yyz}yŵȶн::{{ppp % % ('+ 8;@ D F +M +O MN L KPMIE C=31($%!!  ($)"&/&)-(*1$(2'-6018..8&/:#.7(5>*1<*1;-*2),5(/5#07+2?2.A*6?1:?/472PT%$b%QUJZJJ<0*<POOOOOOOOOOOOOOOOOOOOOOOOPNOOOOOOOOOOOONQRNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOP HQ/ppp)   & $-4 ; 7?@ D HGGDFB:; 2-*))(&)'!#")##-'%,-*,''+++021110.102012)/00-0110,02006*'&=EFlupGML\bfGLK=EC8;;'%&,//,,.0///3247 +02F5= +Id4a2a2a2b2a2c4c4a2b2b2c4a2a2b3d5a2b2a2c4b3a2b3c4a1],d5b3c4a2b2a2a2a2a2b2a2b2b3b3b2b3b2a2a2a2a2a2a2a2a2a2a2a2a2a2a2a2b2b3b3b3b2b2a2a2a2a2a2a2a2a2a2b2a2b3b2b3b2c3a2a2a2a2a2a2a2a2a2a2b3b2b3b2a2b2a2b3c3b2c4c4c4a2b3c4b2b3c4c3d5c4c3d6b2c4b2a2b2a2a2c4[*\-opp# $($(.5:98: 8@=7:;9882603%1/*&( #%%'&(-%'*$)(&#&'""!!&(#%$),(+0)-/,242%' ACDU# 8". 32.0D&&7&*1 1 !%(dhcb`acca7>=!"   "'& !"# KUNoxm396!  HMQzACTT {Ke7c4c4c4f7T!e7~Wb0g5a,j7i;e6f6vMY)Y(_0f:T"qwge\,e7d5c4c4c4e7V"\zl?^*sPPX&c4Pd5R]-S k?V$],d5c4d6Z)uLnB}VsIjS!V"c5Rd6T \,d6c4g9O|r@tKj:]3T X'_/[*`0Ta3_.Q yzNpA].e6Sk>b1xsHa[wf7S hd6>bqGKhrOf8c4c4d6],^-X7xgkBknMpɷqds^+qqq "('.?;AMOQZ(NZ&\)\)X&Z%|STuE`1X%^-tKoD^.d5c4e7U"[gxk9vT]2r+~qMxMe5a2e6d5Z)uLl_3:ƵpF;zgX&e7g9Nzf1i8@ t< sG}1qCl=a3RhWOh;ySdvzb2\+l@SYV$QxPW$e7c4d6],],aCocwzgx`*n}x[[ZZKe7c4c4c3h:JfpFi;z}YY&],j@~SP[+d6W%`/i>dwHwPnCPfwJ[*d5c4e7U"Zevi7dCLo?-D sIQ]-e7Z(tKfa4l-{d5a/h;Ra2h:Nxe1g7< yT>{Vg.zuFlg}SgñS"uIZ4ɷZoA|S\+\*uLu°[-κa3`2Z+xKj]-~RtwKU"Z(f8Nf8c4c4d5],_.{hfdMxtc|mɵpWjjRT`+c6d5c5d6e8\,a2a2Q_/j>f8U"`1b3`1a2a3d6`1c4g:f9b4c5c5c4e7e7f8[+_0e8d6d6d6e8_/\,\+_0U"OS e8f9[*N^/hw{u|gXA=u]dtqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrqqqqqrpq85YWTRTRTRTRTRWTTRTRTRUSVSTRUSUSVTVTTQZX96¡jXu2B`5r`@RVVTTRURVSTQUSUSVTVTTRTRURRPECUSMKVSTRTRUSXUWUWUXUWUXUWUTRTRTRVTUSTQTRTRTRTRjA)vr>?QfaNW]YZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZZ\Z\YZYZZ\Y[YZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZYZY[VXUUqrr)*)MKmkhfihkijhjh_\jhjhjhca`^ljecge`^_]jhmkOMȪ{jCVhBwWhk_\hffdcaljdbhf`^b`kjhfiggeYWgeb`jhhfjhcaXUZXYWYWZXYWZXjijhki`^cakijiighfhhkdZ682wEnsZfggegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegehf`^a^ifhea^echegdgegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegegeheecfcWWWIGigca\YQOVSNKzyRQ\ZZXspEDkiYWus}{\ZkjKHǨxg}@Rc:zgGTX|{YWb`ljSPigSQzxmkTRfdeccaUSdb^\fdfd`^poROXVSQwujiQOUS_]edfbajj1U6]^`uClpYdeecececececececececececececececececececececececececececececececececececececececececececfd^\qolk][`^sqdcecigigecgehfiggeebgehghfecfdhfigfdecececececececececececececececececececececececececececececececececececececececececececececececececbadab`bJGjh^\ ս̯ǦusVT}}ģomӻ~WUmkKHǩxg}@Sx`ΥӺusB@ywb`fdcaVSdb^\fdfdb`kiťigͲγվig_]gdebtPj efZP\MheececececececececececececececececececececececececececececececececececececececececececececigNK LKSPãonSPRPPNb`\ZTRQNVTgeVTQOTQeca_SQPN][fdecececececececececececececececececececececececececececececececececececececececececececececececfdcada_]_JGigdbOMâHFzyrqԽĤϵŦPMƨQOnlKHǩxg}@Soس\ZMJcb[ZuscaeccaVSdb^\fdechfTRomӻҸ75poCA~DAvt\Zgdgc[:vfT;1icP7pLcgececececececececececececececececececececececececececececececececececececececececececececigRP74ŧca̯ʬRO~|ѸGD϶OMa_¤Ӻus][geececececececececececececececececececececececececececececececececececececececececececececececfdcada_]_wvӻжyxxxJGigfdZXǨNLZXx-*ƨYXȭllnläвzwYWljKIǩxg}@S}gܻäxvcbMK~|Ȫvt]ZgecaVSdb^\fdecgeZX~}жҹUSYWãpq _]ZX`]ecfcghQ9wYb`C_MkUfbecececececececececececececececececececececececececececececececececececececececececececececigQO^\USjhppZXSQVSQP¡ŸѷNLoma^fdececececececececececececececececececececececececececececececececececececececececececececececfdcada_]_ħ[ZĤѸǦŧԿJGigfdGEƦQO_]ťKHƧ\[ut{{XUmkKIǩxg}@Sͣá[Y{{nmĦTRԽebdafdcaVSdb^\fdechgRPig˯ҹѹӻB?][MJWTigdbdcfcfhuILgmru^\jgedececececececececececececececececececececececececececececececececececececececececececececececigQNdatsȬa_Խ}qoA?yxu($kh<:ɫƨ][cafdececececececececececececececececececececececececececececececececececececececececececececececfdcada_]_orqpŦ~JGjh\ZӾqn><[XͰhfxwZYljKIǩxg}@SvOزy{{TRβ\Yäu*(̱hfNLececcaVSdb^\fdfdb`b`ĢȪqnyyqsz{jjc`fcghwJIjjts]ZgeecececececececececececececececececececececececececececececececececececececececececececececececigQOywFDȨQN_^~}KIǨYXǨc`sqս~|XVgeececececececececececececececececececececececececececececececececececececececececececececececfdcada_]_tszxʹ¢̱JGjh_]XVZXȪ`]YVurǪQPnlKIǩxg}@SlIдvszxJH͵ägddbdbVSdb^\fdfd`^mk̳jhϵ_]{xδӼyw\ZdbfcfhwJIjjts]Zgeecececececececececececececececececececececececececececececececececececececececececececececececge][ywki_]RPURmkqonlYW[YebŪQNqo[Xececececececececececececececececececececececececececececececececececececececececececececececececfdcada][]|}á`_fdŧи̰ˬJGigecVTkhQOvtzx^\}~nl\Zqo\ZljKIǩxg}@SuZŗ{WUVT`^hfjhljspdbeccaVSdb^\fdecdba_}|KHQOVT}|ŦtrVSUSsqֽqp^\gdfhwJIjjts\ZgeececececececececececececececececececececececececececececececececececececececececececececececdbechfcaecigecYWcaXVSPXUa^`^cajhb`jha_TRTQdb\ZPMVSa_caecececececececececececececececececececececececececececececececececececececececececececececececfdcadageg̯~|̱ĥ϶ŦJGigecb`WTB?USJHHEVT][IF][\ZcaROHF[YfdjhKIǩxg}@S\.hT3=@=;HFfdhfb`YWQNUR`^^\ececcaVSdb^\fdececdbXVWUgeb`_]TRWU[Y>;HFSQTRGD?=`^fdecghwJIjjts\Zgeecececececececececececececececececececececececececececececececececececececececececececececcab`fd[YZX[YXVfdeccab_`^ecdbed_]PMSQMKQOTR^]ecb`fdcbhfca^\dbecececececececececececececececececececececececececececececececececececececececececececececfdcada0/0}}}SQɫжŧиJGji^\sqzxljXUUSDBqqb_b`jhKIǩxg}@SrUlŸZX[Ya_SPus\ZeccaeccaVSdb^\fdececdbZX`^URmj]Zdb[Ya_cafcfhwJIjjts\ZgeecececececececececececececececececececececececececececececececececececececececececececdbgeTRB?|{~|_]WUji£RO`]ZWnlģáZYhf¡MJ[YҼ][a_a_ececececececececececececececececececececececececececececececececececececececececececececfdcadaXWXJGjhdbROεԽss{yзվYWljKIǩxg}@S]3yԬtx]ZδFE̯жʬ¡fdcadbVSdb^\fdechfSQϵʰȫ£`]ǨGEGEռnl\ZgdfhwJIjjts\Zgeecececececececececececececececececececececececececececececececececececececececececececfda^ecnlǩѸKHgegfѸŨȭkjYYRPDA}}âgeb`fdececececececececececececececececececececececececececececececececececececececececececfdcadaa_aJGigdbyz}zƪ¢ԺԽYWcbqo^[жnl_]kiKIǩxg}@SkFӫӼ;;om̰kk\YgecaVSdb^\fdechfNL{55YY[[[Z^\Ͳb`âb`ki][gdfhwJIjjts\Zgeececececececececececececececececececececececececececececececececececececececececececececca^\ӻjholKJҺw.,QPKHԼȫwyӼ\[qoȮggz/,`^XVgeecececececececececececececececececececececececececececececececececececececececececececfdcada_]_ƩJGjh`]kkũģѹɫvuŦ_\ZXgejhKIǩxg}@ShAδŸ_^WTӺɫäMJgeeccaVSdb^\fdechfPNoma_|yZWжb`ťa`lj][gdfhwJIjjts\ZgeecececececececececececececececececececececececececececececececececececececececececececececTRտзģйZXrpŸTQ{zolŤxv@>ŨƥҼRPhfecececececececececececececececececececececececececececececececececececececececececececfdcada_]_xxpoγ̰JGigigHEƧԾԻqoUSrrHEfdjhKIǩxg}@SrWkphhSQnoPPCC[YgecaVSdb^\fdechfROԽ~}ɬOMecվ|zɫϴ}jh][gdfhwJIjjts\Zgeecececececececececececececececececececececececececececececececececececececececececececfd^\pnZXywvt;9SQnlRPrqgiϸhe˯FCwvhgb`fdecececececececececececececececececececececececececececececececececececececececececececfdcada_]_ʭ~~abֽJGkiZX~|zy|}иhjrrå{ysp\Z}}gfigKIǩxg}@S`6zi¦WTnlECrp~}~URhfcaVSdb^\fddbgeRPDBJI>GE`^JFֽ~â־hgig̰ȯsq^[fdecececececececececececececececececececececececececececececececececececececececececececbada_]_yz[YklӼijJGjha_cbifNKfcyzYVgdeb[YOMQNrptq[XljKHǩxg}@Re>~Òu}vusrVSc``]fdececcaVSdb^\fdfd^[utjiywtrhf`]geihzz_\ecfcfgwJIjjts]Zgeecececececececececececececececececececececececececececececececececececececececececececfda_nlsqmlROji^\_\rp`]on]ZigonfdfdrqTRvt~YW_][YjhKIigqoTR`^tr\Zfdecececececececececececececececececececececececececececececececececececececececececececfdcada`_`ssһͲԽɬӸHKgkdg`dUX_bgk_cSVY\dh`c`ccggjgj\_\_dhhlJMťui{?Vd<bHS\VYUX[^`cehY\UW`ddhcgcfdgbeTWbe]`ehcfdg_b_bVYUXUXWZUXX[\_addgad^aVXY[cfcgdfekvJLfknqWWac_a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a_`abZ[VWZ[bc]^`a_`[\_`[[ab]^[\`a`a[[abWXST`aab`a]^efZ[WXcd_`RSVW`a_a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a`a_a`a]^``\^\ɪzz]]̷βƧãR5qVlQnRoTnRmQnRpToSmQnRnRmRmQmQnSnSlQrWT6̬YGClDs|BmXoToTnSnRmQoSpTnRmQmQmQmRkO^CkSgJnSmQmQnRnRoToToToToToSnSmRmQnRnRoToTmRmQnQoVT;vdulZveucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucuctcudveudtcuducucuducvdtcududtctcuducvdweuctcucuctbvdvetcucweveucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucucudsao`('(kmk̲n3}UPPPPPPPPPPPPPPPPPS|DkZh0T-ZOPPPPPPPPPPPPP~GMMQPPPPPPPPPPPPPPPPPPPPOsB{tWuyzyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyyzwwqqq< +]0X*X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X+X*Y,PHH^,A7d2V*X+X+X+X+X+X+X+X+X+X+X+X+X+W)LV'Y+X+X+X+X+X+X+Y+X+X+Y+X+X+X+X+Y+X+X+X+X+X+Y+Z*Z(K#<?<9:99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999;3 A!ŸIi;e5e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6e6g8h;g:o>K?q=e7f7e6e7f7e6e6e6f7e6e5f7e6e6e6h:h9e6e6g9f7e6e6f7c3e5f7c4f6f7e6e6b2e6e6e6g8e6e6e7f4c1^5\4U4W5W6W5W5W5W6W6W6W6W6W5W6W6W6W6V5W5W6V5W5V5W6W5W5W5W5W5W5W5W5W5W5W5W6V5W5W6W6W6V5W5W6W6W6W6W5W5W5W5W5W5W5W5W5W5W6W6W5V5W6W5W5W5W5W6W6W6W5W6V5W5W6W6W5W6W6W6W6W6W6W5W5W5W5W5W5W5W5W5W5W6W6W5W6W6W6W6W5W6W6W6W6W5W6W6W6W6W6W6W6W5W5W5W5W5W5W5W5W5W5W5X7Q-V4Gg9b3c4c4c4c4c4c4c4c4c4c4c4c4d6c5c5c4b3a2c4c4a2j9I=p=Y(`0c5_-^.c5b3d6`1],e6]-b3d6c4a2W%a2d5X'_0c4d5`0b3_/]-a1\,_/b3`1f9a2c4b3\,c5b3`1c5c3f0b0a1a/a/a/a/b0_-[(_-]*\)b0_,\(\(_,d3a.a/c2a/c2a.a/b0a0a0a/a/a/a0a0b0a/`.b1c1\)\(`-d2b0_,\(\)\)a/b0a0a0a/a/a/a0a/b0a/]*a/c1b0b0b0b0c1\)[(b0b0_,d3a/a/^,b1^+\(\(^+^,^+b0a/a0a0a/a/a/a0a/b0a/\)a.^,\(\(a0b0['^+^,[(a/`.\(\)\)_-]*a/b0a/a0a0a0a0a0a0a0a0a/c1['^.Gg9c3c4c4c4c4c4c4c4c4c4c4c4d5W%W%a1b3\+Y'`0c4^.d1F?f/}Xh;T!nsF]-e6]-W$X'rEe6[)d6c4ja2[*^j9c5g9NoC]+`0m?e7V$Rb3_/zO\,d5c5_/c5b4d5g8g5g4f3d0b-d/k9X!a+k9[$_*h5h5^(T`*VZ"g4X!W^(d/d0d/d0e1d0d/d0c/_*`+`*Sg4j7[$X!a,_)h5g3i6a,d/d0d/d0e0d/d/d0c.]&i6d0_)W ]'d0c/Y!i6j7S[%a+Vg4^(d0[#b.h5h5e2f1d/^'d0d0d/d0e0d/d/d0c.\%h6[$^(h4i6VZ#m;]'\%l:^)\%g4g3i6b-i5]&c.d0d0d0d0d0d0d0d0d0d/e2^+_.Gg9c3c4c4c4c4c4c4c4c4c4c4g8OcOV#rLT e3A]$rHrf6X&`0^-j>e7b],tJ\+JtId66X*MZ)tHcsuMxVZ)W$],me7V \,d5]-d5a1QPPU#e7Z)zRwT!}nDvNd7V$g9rHX&e7e7c5Z)e6e7e7V$}W~;sl@Ke4a2c4f8b3\+f8d5f9Pv_-OïfRZ)]_1tG?jY%ƶxoxLƷ_/_0c4e8b3\+f8d6f9PvuP{°d5}ȹW%oAwPg9c4c4c4c4c4c4c4c4c4d6]-^.Gg9c3c4c4c4c4c4c4c4c4c4c5b3_-xPC u_.Kw3CW_~ů^,|UmCwMtkNn{Shawnj>[(tͼP_/tD^/gb4W R lLe7c4qlra\*d6^,1}a:_-(b5ɱY>snCW$g9RL8X$f8U!Zdd<B +lFH/AD ]-c4d5LLw8^-h;Nwf@I^ST [2nd5pCɲF\,j=r)B N@ +~g9]-d6NMz8],h;M|g1h;-(xZ&4OF:C Jd>wNg9c4c4c4c4c4c4c4c4c4d6],^.zcƴGg:c3c4c4c4c4c4c4c4c4c4e7U"wSE$=vaLB 8oU4}fDuFǴeQL{~VFl?Ef8a1SxM^.O{zKj>nDɴ`-MPQd4pDxOg9c4c4c4c4c4c4c4c4c4d6],^.dHp]ſƶǼmXŲzfGg9c3c4c4c4c4c4c4c4c4b3g9GzLnr]A ?rpsFZpDT\+zTwKİ}SNd4O?A +~Z,Pb2D lvKV#[`6m;]/W!c5X&h;Z)d5}w}j[(d5g9HeP\+k<l)p{QmYv}TW%_.nCsɹfrH^.V$[ZE\)V0NCVV_/e7Z)zQw`g:c5Oyk?U!y¸Hb5C oBkRP&X%X&qGq?W\&Kf8_/\+uLx`j=c4N|wGg;~ZqsI[*MKT!VOVRrHwNg9c4c4c4c4c4c4c4c4c4d6],^.|^acYe}nsp´suGg:b4c5c5c5c5c5c5c5c4d6[,oBLJmwShQ&@ CG y]i9|Tg:Ni=vqBoyMj<\,].[Li<\,k@~yOdrsFvV}S'aQAc2W+ɷ[)a3a1f2c/d0e1`1c4g9HgO_0E H_~XXtIDZyRU"g:X&T!B ^-f8U!Yph:a7N}C +Y*g=h=c4a2e7SW'Bb3h:N{b2{oMMvKƳc6?lPa2ͻ^,X&pET$i?lAOf9]-e7U!W&B a2h:M|yJnC=RZ(iʱoqass̿Hh8c2d3d3d3d3d3d3d3d3f5Z&{QT_-k9cyMnAyLpKjC 9gxn[`MtHodd4[(X#tIHi:^+f6b0pvM`,k=c1RbeOm;nALh9c2a0a1a0a3c5c4e7T"wKX'`1a_.X&sGlo@yKX&LunA\+d5d6c4`1d5d6d5[+qD^A |UU#V$~qB^/d5e7c4a2e6d5g9NyW.wtKY(V$ck=tFɺ~Z%`1_/z`0_.b2Fzh:]-c4e6c4a2e6d5g9Nzn;]+y\+h:e6e7U#ihV$W&iwI]5xOg9c4c4c4c4c4c4c4c4c4d6],^.}sϻwT(wU+eH f4b.b.b.b.b.b.b.b.b.b.d0Y#Pc/c/](UY"\&Y#Rd0f+M:Lo>^(k;d1h6e2](g4n@b0|P]&VZ$a-`,`+X!`,b/_+b.b-^,h7Z%Z$a0Z$^)a.`,d2e3X!^)i8wJ\'h9[%c0b.b.b.b.b0e0c1c4c5S[(d6a1Y%b3e6Z)U!\*[*_/Ma3U!],d5c3c4c4b2c4c4c3d5],Y&g:T!OX$La2b3QOOQ]-c4c3c4c3b2c4b3g9NzKZ)d5c5W#],W%SZ(Ma2d5`0Ta1d5_/OOPOk>a1_.c4c4c3b2c4b3g9NxV$Sc5c3c4b3d6W#V"d5c5U NPNSyNg9c3c4c4c4c4c4c4c4c4d5],^.yk}ĩvfE}ľ=Y2U-U-U-U-U-U-U-U-U-U-U-W/Y2U-U-V/X0W0W/W/Z2R+T0*"P#BU,R(S*Q(R)V/S*O%R(JT,W0V.U-U-S+W/V.S*U-U.U-V.Q(U-V.S)V.V.U-U-R)Q(V/V.O&HX1dBL W/U-U-U-U-T.[1a4h5g9f;j?h=f:g;i=g:f:i=i>hi;g9h:h:h:h:g:h:h:g9i;ih;l?h:h:k?k?k?k?i;g:h:h:h:h:g:g:h;c4j=`k=h;h:g9j=i;j=i=g9k?h:g:h:j>h:g:h;k?k?lAe8{QZ_/h:h:h:h:h:g:g:i;c4h;ej=g:h:h:h:h:g9j=j=g9g:j>k@k@i=j=cj=c4h;g:h:h:h:h:h:h:h:g:i;b2b2U>tZCǼV8}rPŶ{41111111111111111111132 7{2222122232121121122111221211112211230 +31112139>JQPPPPPPPPPPPPNKLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLMH?KLLLLLLLMLLLLLLLLLLLMD @LLLLLLLLKLH=IMLLLLLLLLLLLLMJ?HMLLLLLLLLLLNE J$hrqqqqqqqqqqqqqqqqqqqqpyfllA>toqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqrqqqqqqpp{kwuuuuuuuuuuuuuuuuuuuuuux_ {wuwuuuuuuuuuwxvuvxwuuuuuuuuuuuuuuuuuuuuuuuuuvsyBĠz\rnoonopnnoooqqpoqnonopoponponoooooooooooooonopnoqopqpnnpqonoooooopfC|]rnnppnonppoonoooooonoqqpnpqpnopi n/Ua_`````````````````````_nf"qb%uc_[U`_````__`VP]b]QT``````````````````````````^cvy*pIc^_^_[Va_Z]]QOX\V`^`]V^V^_V[_^____________^_ZXb^S_UOZ_`UOZ_^____^`Um6sJc^`XY`^`YYYY_^_^^^__[PPZ`ZOUa^`XXppp?>?[geeeeeeeeeeeeeeeeeeeeeefcok)xijcoF^igiffij_:yV_ZiPA|Zeeeeeeeeeeeeeeeeeeeeeeeefci{+qPjeefbgo5Sdjc +_ IUo'ap5Xha]r0Zv0b_v2gbfeeeeeeeeeeeefapm.Va EYv5XhaXvTgf_a!nlnZgeeeeeeeeeeeeeeeeeeeeeeefaZeVUOUj@xYWWPaaPSZSwJQXVheeeeeeeeeeeeeeeeeeeeeeeci{+qPieehTSw@}Eyh&t8̮Vi"|Mi2\LǻP]LaSheeeeeeeeeeeefagY k6̷S +Ӿ}VҸI~SµTp"`feeeeef[t6sQijLȰOaYīW o YQa QcVa QQ}zwLyX˻UVi_` hfhZgeeeeeeeeeeeeeeeeeeeeeeeceR{pQ}Cx#bd[Tz\ZeTI`_B5\zRheeeeeeeeeeeeeeeeeeeeeeeci{+qPieehTYg§z@te$v=i{CM~OϹ~FyKȬV*ռZL`SheeeeeeeeeeeeehRr9мҿKlz{A мKƸtIRSeeeeeeef[t6sQiiTjkz@]g(n*;ҹǬMWռYPPl2iTf p1¤|Oj_`!igiZgeeeeeeeeeeeeeeeeeeeeeeeb]Pk,\fLN|tG[NQh ZG|Xgeeeeeeeeeeeeeeeeeeeeeeeci{+qPieehSdg9xo|bm+l3ťKUֽ~LdзT&Ի[N_Sheeeeeeeeeeeeedlx<dLL¥xy@ѽiSheeeeef[t6sQiiQ}l7GȬƮèvKp>q̲y@f1Ū{YQ[eh=W^d%ӻWdf_`!igiZgeeeeeeeeeeeeeeeeeeeeeee` f0\Cw&Tx'c IRPD!oA[FvGideeeeeeeeeeeeeeeeeeeeeeeci{+qPieehS_My@̵Ӿ\y@|aw9Ha־\(qh*ªQL u9aSheeeeeeeeeeeeeiN{QȺGrӿg#кo=u8T8Sfeeeeef[t6sQiiPYhɯqKèètHn~nC!jai2xUUYk+u_feeeeeeeeeeeeeeeeeeeeeeeci{+qPieef`m jcYw:a a`js/dGQo3\ hARo/edo)Zgeeeeeeeeeeeeef]z1}IW]XORiNQhd\`bfeeeeef[t6sQif^s,_l}EOz8s/iW äoҾX{ELCrh&chfe%TO[ks*_h_`!babīɭpWZgeeeeeeeeeeeeeeeeffgfeefec`j[_eYbS9zrAZh]RX_TR]jYTR]feeegiggfeeeeeeeeeeeeeeeeci{+qPieeef`bfi^ffVR]bZi_eb\j_TU`geeeeeeeeeeeegeef\ZhdVfWQXgaSTcfeefgeef[t6sQief^fbYh[]eMͲvw<^hYQ^aRR`gVUR^ff_`!EEE}ϺȰYDZgeeeeeeeeeeeeeeegaa\afe^ehXQ[iejXR Wsd\RXjhfhk_RVeifeefhZRX\afeeeeeeeeeeeeeeeci{+qPieeeee`aSURT\d`a][_af]Ya`]]eeeeeeeeeeeee]eeeggdfhehhhdfihfeef`[gef[t6sQiedh_^heggfda a ggehhgfhifeh_igef_`!srslRϷ]мZgeeeeeeeeeeeeeeg[&ig3u!fa`/u]PThKLfNTgTK[IeTUeegW8sidhdgfibM;|lF(w$h]feeeeeeeeeeeeeeci{+qPieeegWyY n{¡m.x-qLfH`m!\{9zw6^feeeeeeeeef\w4ahchdhcchdhchfdgeefan}м[ +df_`!igilжʮ̲ϵѼzFZgeeeeeeeeeeeeeiQs:sJ#NO}7grOvFrpQuO~ Xg _H3OOqST#_|?obS olRsyOieeeeeeeeeeeeeci{+qPieegZw4_lθwPb˼fzMx=gbjdi`feeeeeee`g!éy>tkx?ɻZ"εtUiGsxN̰y@κVdRҾ§y?ѹ_l2sQj[t6sQiiN˳ɰTŶ~De0qxAȰx>ūNm;_+o0g6Mp2Ũ`cf_`!igiZgeeeeeeeeeeeeeiQq9pJMXp-aINRXUNJNI|cW:~h\G8;O{9o@SZSUvOieeeeeeeeeeeeeci{+qPieeg[y?ιIxWйrMǭnJe8ϻXcϴͭrIx@Էofafeeeeeee`h!u9׻eh&wc0ǫmxq0UzPx>R Zi̴m/̱\m3sQj[t6sQiiMϼ{{Gm.d,nxI`kK +ϼ^m.su9c5~s6{пo1ħ`cf_` gfgZgeeeeeeeeeeeeeiQxh?bF7M|{EdzWoH8tUh]OT deX*gmijkBWSHWVheeeeeeeeeeeeeci{+qPieedhOȮ`~оy]h'nyMҽmMлj2]ӻx5\[u0ͱ_ceeeeeeeeeXξ\i%Ʀ|SZkvJ] \S|DĪX [ʪ}r,Խo:շXwFwPj[t6sQif[t+w=Ũ]ƪ{f#ʺnJ|INgo.ux=e3¨cµʷt6ҽ[ +df_`!qpqZgeeeeeeeeeeeeef`gWlca]3u\QBzR;uLgQBzQB{N\3vfcefjg cKR4qR ZLL +[`RGQ5w"kQfeeeeeeeeeeeeeeci{+qPieeef[̵kһbaũ^oQj4ҽKŰW δb^ϼϴPhdeeeeeeeiQc_Gw;q8vr2SQUp dh]l_fo!U}?y7n$[òh#_g[t6sQieeVųgXOlBǬ|Hl*UK\s.bc +kZw6] n%QIZp¢Qhf__GFG[hffffffffffffffhY:~p\fgd]gh[V\jfi[W[ig]dfffffdYW^ifXXfghYXVr&m^gffffffffffffffdi{*sSl hhhid{2po Y]c m|9]dla aZdi_lg \ p$ehhhhhhhhhhi_ z8eezJjx4_[Ycfejchebj]^]pX[ji_v:vTl hj_q.ocUe z]eY\h`ggdi_gbY\ZRjciiba#Ub```````````````bW\b``ab``bcb```bcb``ba`````accb`acca``ccc\\b``````````````a^e{~)ɍq?ZUVVVVNQRXXURMVVTUWXUSURTVQVVVVVVVVVVVVVNVWWORVXXVVVUWVVWUXWXRHWUWKh6Ðs@ZUUWPRWXSNTWXXVWVVVUXVWXXXIRWUWOS!hrqqqqqqqqqqqqqqqqsrqqqqqqqqqqqqqqqqrqpqrqqqqqrqqqqqqqqqqqprrpqqqqqqqqqqqqqqqpqxwbehsgqgqgqgqgqhshqhrgpgqgqgqhsgqgqgqgqgqgqgqhrgqhrhqgqhrgqgqgqgqgqgqgqgqgqgqgqgqgqhsiphqgqgq\qdqhqgqgqgqgqgqgqgqgqgqgqgqgqgphritgqgqgreijtbehsgqgqgphrgqgpgqgqgqgqgqgqgqgqgqgqgqgqgqgqgqgqgqgqgpithrgpgqhrblmȽ<LIIIIIIIIIIIIIIIIIIIIIIIIIIII@@DG?A>CKD=D?EJD=IIIIIIIIIIIIIIIIIIIIIIIIIIIIIK?e' !gyxxxxxxxxxxxxxxxxxxxxxxxxxxzm s/lx$n)øoxxxxxxxxxxxxxxxxxxxxxxxxxxxxzmO2#xp]os4?mIp*sʵ(z{a10 !ɘƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑȔ~tٸčTϦ)ËZөxɗÍÌs֯XəȔƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑƑœʊƩ`/p:j{+> !Š͙̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘ΜÆ{Ĉ}ǎ\׮Wس„Cլ˗6Νjת ɓʕ̛͙̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘̘͌ɭ`5{}?gw/ +u!‹̠˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝̠i׷ŒNӭǕ;Ѩșwwش'͙)ԩyĐ̟˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˝˟̓ɮa6|z=#\!‹͟˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜̞Ď^ڻɗƑE԰ɗ͠ÍV֭ʗu ǒŒ'˜ƒ̞˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˜˞̑ɮM-b kr!̞ʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛ˛ƑǕ˜ʚőȖ˛ʛ̝ő ǒ"ѦĎȗƓʚ̞ȗƒ˛ʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛʛ˛ʝ̐Ȭ!ǔ ő ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒƓƓ Œ ƒƓƒ Œ ƒ őǓ ŒÍƓ ƒƓ ƒ őƒƓ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ ƒ Ŕ LJ ê        ,yxyXYXtttlll888X-322222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222320ѥa'$$$$(%$$$$$$$$$$$$$&$%%$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$&$$$$$$$$(%$$$$$$$$$%($$$$$&$$$$$$$$''$$$&$%&&(('$$&$$''$$&%$&(%$%%%&$$$$%&$%()%$$'&$$&$$''$$%&$&($$''$$$&$$'&%(('$$$$$$$$''&($$$&||*&<7785%4:79898999788706268989979899889897899878:87:977:977:87997777:8789889985197989986&09:879:77:3%6:97707:878:88'*:860:7/.!$)8:.6:)'9 Ɣ3#6231.m0'/&!&-+'500-H/@2/+1((3+1*+-0-/+4.+'050#16&+63$-63$/8()6244$.6-*.-),04D'3*--'1,gB*%27*&47%3l/&)5.J0"062$2&^X(1J$CBrbT&L1U]D9Ak%)E%&I+34!"L%$u߉2" fJK1U\!!"NIo$Tg!$L0"J>ArbS02-+'56SP6r-2328 Ș2#724.1_14";J04 \B(EG$A*B<9.93E'::H,!)^*N<!Y8 $U,HB6-U0<=32@=#J.-E63M&[[%DQ!"2_JH2`,"$X$_e)+[+]wWC1Y=3@߅P߁]q'BT"-}['-<7J"55338 Ș2#724/*Yp_= JeJj}ތ{ oR*ow$$$ށl'|`Gr.}!Z15w_Xbl F[|nw߄;xr)+7!XwQ$KM߄IYwJ"=5LRl_#6328 șT#>ʹ,'94451-!$!*$[ ,$,3,30),1)+7#%.!!,,'$+%.$&* #"1&D10f +"3(&" -"!#/.'2 //##+45'5 )55,3-,2-3%.16$!6776'7$.)1-3-+7& /$-%8)5<*&7 *4[ +%# &6444; œI>ǴQ 722227365435/8424573232374733747415657376637363654536363545545455546357&8G03355639/626454644863567645523636254637353322562642237235532732545222562222561554834452372355415636453655147214516427/74255485651223-||ںf4,idF +ŷ      fƶ-oGHDi<4z{xWVwu{WV \ No newline at end of file diff --git a/am-kernels/kernels/slider/main.c b/am-kernels/kernels/slider/main.c new file mode 100644 index 0000000..338b121 --- /dev/null +++ b/am-kernels/kernels/slider/main.c @@ -0,0 +1,32 @@ +#include +#include +#include + +extern uint32_t image[][400][300]; +extern uint32_t image_end[][400][300]; +#define NR_IMG (image_end - image) + +void display_image(int i) { + io_write(AM_GPU_FBDRAW, 0, 0, &image[i][0][0], 400, 300, true); +} + +int main() { + ioe_init(); + + int i = 0; + unsigned long last = 0; + unsigned long current; + + display_image(i); + + while (1) { + current = io_read(AM_TIMER_UPTIME).us / 1000; + if (current - last > 5000) { + // change image every 5s + i = (i + 1) % NR_IMG; + display_image(i); + last = current; + } + } + return 0; +} diff --git a/am-kernels/kernels/snake/LICENSE b/am-kernels/kernels/snake/LICENSE new file mode 100644 index 0000000..eca0bfc --- /dev/null +++ b/am-kernels/kernels/snake/LICENSE @@ -0,0 +1,42 @@ +This software is licensed under a BSD Style License + +Copyright (c) 2015 Battelle Memorial Institute. All Rights Reserved. +http://www.battelle.org/ + +Redistribution and use of this software and associated documentation +("Software"), with or without modification, are permitted provided that the +following conditions are met: + +1. Redistributions of source code must retain copyright statements and + notices. Redistributions must also contain a copy of this document. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. The names "M/o/Vfuscator" and "Battelle" must not be used to endorse or + promote products derived from this Software without prior written + permission of Battelle Memorial Institute. For written permission, + please contact solutions@battelle.org + +4. Products derived from this Software may not be called "M/o/Vfuscator" or + "Battelle", nor may "M/o/Vfuscator" or "Battelle" appear in their names + without prior written permission of Battelle Memorial Institute. + Battelle is a registered trademark of Battelle Memorial Institute. + +5. Due credit should be given to the Battelle Memorial Institute. + +THIS SOFTWARE IS PROVIDED BY BATTELLE MEMORIAL INSTITUTE "AS IS" AND ANY +EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL BATTELLE MEMORIAL INSTITUTE OR ITS +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The original author of this software is Christopher P. Domas, an employee of +the Battelle Memorial Institute. diff --git a/am-kernels/kernels/snake/Makefile b/am-kernels/kernels/snake/Makefile new file mode 100644 index 0000000..a4fb92c --- /dev/null +++ b/am-kernels/kernels/snake/Makefile @@ -0,0 +1,3 @@ +NAME = snake +SRCS = snake.c +include $(AM_HOME)/Makefile diff --git a/am-kernels/kernels/snake/snake.c b/am-kernels/kernels/snake/snake.c new file mode 100644 index 0000000..817f98e --- /dev/null +++ b/am-kernels/kernels/snake/snake.c @@ -0,0 +1,188 @@ +#include +#include +#include +#include +#include + +#define MAX_LENGTH 100 +#define TILE_W 8 + +typedef enum { NONE, UP, DOWN, LEFT, RIGHT } dir_t; + +typedef struct { + int x, y; +} point_t; + +typedef struct { + int width, height; +} dim_t; + +typedef struct { + int top, bottom, left, right; +} rect_t; + +typedef struct { + point_t body[MAX_LENGTH]; + int length; + int index; + int dead; +} snake_t; + +static void refresh() { + io_write(AM_GPU_FBDRAW, 0, 0, NULL, 0, 0, true); +} + +static void draw_tile(int y, int x, uint32_t color) { + static uint32_t buf[TILE_W * TILE_W]; + uint32_t last_color = 0xffffffff; + if (last_color != color) { + for (int i = 0; i < LENGTH(buf); i ++) { buf[i] = color; } + } + io_write(AM_GPU_FBDRAW, x * TILE_W, y * TILE_W, buf, TILE_W, TILE_W, false); +} + +static int read_key() { + while (1) { + AM_INPUT_KEYBRD_T ev = io_read(AM_INPUT_KEYBRD); + if (ev.keydown || ev.keycode == AM_KEY_NONE) return ev.keycode; + } +} + +static point_t create_food(dim_t game_size) { + point_t f; + f.x = rand() % game_size.width; + f.y = rand() % game_size.height; + return f; +} + +static void print_board(rect_t board) { + uint32_t color = 0x0000ff00; + for (int i = board.left; i <= board.right; i++) { + draw_tile(board.top, i, color); + draw_tile(board.bottom, i, color); + } + for (int i = board.top; i <= board.bottom; i++) { + draw_tile(i, board.left, color); + draw_tile(i, board.right, color); + } +} + +static void print_food(point_t food, rect_t board) { + draw_tile(food.y + board.top + 1, food.x + board.left + 1, 0x000000ff); +} + +static void print_head(snake_t* snake, rect_t board) { + point_t *p = &snake->body[snake->index]; + draw_tile(p->y + board.top + 1, p->x + board.left + 1, 0x00ff0000); +} + +static void clear_tail(snake_t* snake, rect_t board) { + int t = snake->index-snake->length; + if (t < 0) { t += MAX_LENGTH; } + draw_tile(snake->body[t].y + board.top + 1, snake->body[t].x + board.left + 1, 0); +} + +static dir_t get_dir(int c) { + switch (c) { + case AM_KEY_LEFT: return LEFT; + case AM_KEY_UP: return UP; + case AM_KEY_RIGHT: return RIGHT; + case AM_KEY_DOWN: return DOWN; + default: return NONE; + } +} + +static void move_snake(snake_t* snake, dir_t dir) { + point_t p = snake->body[snake->index]; + switch (dir) { + case LEFT: p.x --; break; + case DOWN: p.y ++; break; + case RIGHT: p.x ++; break; + case UP: p.y --; break; + default: break; + } + snake->index ++; + if (snake->index == MAX_LENGTH) { snake->index = 0; } + snake->body[snake->index] = p; +} + +static int is_dead(snake_t* snake, dim_t game_size) { + point_t head = snake->body[snake->index]; + if (head.x == -1) return 1; + if (head.x == game_size.width) return 1; + if (head.y == -1) return 1; + if (head.y == game_size.height) return 1; + + for (int i = 1; i != snake->length; i ++) { + int j = snake->index-i; + if (j < 0) { j += MAX_LENGTH; } + if (head.x == snake->body[j].x && head.y == snake->body[j].y) { return 1; } + } + return 0; +} + +static int has_food(snake_t* snake, point_t food) { + return snake->body[snake->index].x == food.x && snake->body[snake->index].y == food.y; +} + +int main() { + snake_t snake = {0}; + rect_t board; + dim_t screen; + dim_t game_size; + dir_t dir = RIGHT; + + ioe_init(); + screen.height = io_read(AM_GPU_CONFIG).height / TILE_W; + screen.width = io_read(AM_GPU_CONFIG).width / TILE_W; + + game_size.width = screen.width - 2; + game_size.height = screen.height - 2; + + snake.body[0].x = game_size.width / 2; + snake.body[0].y = game_size.height / 2; + snake.body[1].x = game_size.width / 2; + snake.body[1].y = game_size.height / 2 + 1; + snake.length = 2; + snake.index = 1; + + board.left = screen.width / 2 - game_size.width / 2 - 1; + board.right = board.left + game_size.width + 1; + board.top = screen.height / 2 - game_size.height / 2 - 1; + board.bottom = board.top + game_size.height + 1; + print_board(board); + + point_t food = create_food(game_size); + print_food(food, board); + do { + print_head(&snake, board); + clear_tail(&snake, board); + + dir_t move_dir = get_dir(read_key()); + switch (move_dir) { + case UP: if (dir != DOWN) dir = move_dir; break; + case DOWN: if (dir != UP) dir = move_dir; break; + case LEFT: if (dir != RIGHT) dir = move_dir; break; + case RIGHT: if (dir != LEFT) dir = move_dir; break; + default: break; + } + + move_snake(&snake, dir); + snake.dead = is_dead(&snake, game_size); + + if (has_food(&snake, food)) { + snake.length ++; + food = create_food(game_size); + print_food(food, board); + } + refresh(); + + uint64_t sleep = 100000 - snake.length * 5000 < 5000 ? 5000 : 100000 - snake.length * 5000; + uint64_t next_us = io_read(AM_TIMER_UPTIME).us + sleep; + while (io_read(AM_TIMER_UPTIME).us < next_us) ; + } while (!snake.dead); + + printf("GAME OVER\nPress Q to Exit\n"); + while (read_key() != AM_KEY_Q); + return 0; +} diff --git a/am-kernels/kernels/thread-os/Makefile b/am-kernels/kernels/thread-os/Makefile new file mode 100644 index 0000000..3998b17 --- /dev/null +++ b/am-kernels/kernels/thread-os/Makefile @@ -0,0 +1,3 @@ +NAME = thread-os +SRCS = thread-os.c +include $(AM_HOME)/Makefile diff --git a/am-kernels/kernels/thread-os/thread-os.c b/am-kernels/kernels/thread-os/thread-os.c new file mode 100644 index 0000000..b8f9aa3 --- /dev/null +++ b/am-kernels/kernels/thread-os/thread-os.c @@ -0,0 +1,70 @@ +#include +#include +#include + +#define MAX_CPU 8 + +typedef union task { + struct { + const char *name; + union task *next; + void (*entry)(void *); + Context *context; + }; + uint8_t stack[4096 * 3]; +} Task; + +Task *currents[MAX_CPU]; +#define current currents[cpu_current()] + +// user-defined tasks + +int locked = 0; +void lock() { while (atomic_xchg(&locked, 1)); } +void unlock() { atomic_xchg(&locked, 0); } + +void func(void *arg) { + while (1) { + lock(); + printf("Thread-%s on CPU #%d\n", arg, cpu_current()); + unlock(); + for (int volatile i = 0; i < 100000; i++) ; + } +} + +Task tasks[] = { + { .name = "A", .entry = func }, + { .name = "B", .entry = func }, + { .name = "C", .entry = func }, + { .name = "D", .entry = func }, + { .name = "E", .entry = func }, +}; + +// ------------------ + +Context *on_interrupt(Event ev, Context *ctx) { + extern Task tasks[]; + if (!current) current = &tasks[0]; + else current->context = ctx; + do { + current = current->next; + } while ((current - tasks) % cpu_count() != cpu_current()); + return current->context; +} + +void mp_entry() { + iset(true); + yield(); +} + +int main() { + cte_init(on_interrupt); + + for (int i = 0; i < LENGTH(tasks); i++) { + Task *task = &tasks[i]; + Area stack = (Area) { &task->context + 1, task + 1 }; + task->context = kcontext(stack, task->entry, (void *)task->name); + task->next = &tasks[(i + 1) % LENGTH(tasks)]; + } + mpe_init(mp_entry); +} diff --git a/am-kernels/kernels/typing-game/Makefile b/am-kernels/kernels/typing-game/Makefile new file mode 100644 index 0000000..58717ba --- /dev/null +++ b/am-kernels/kernels/typing-game/Makefile @@ -0,0 +1,3 @@ +NAME = typing-game +SRCS = game.c font.c +include $(AM_HOME)/Makefile diff --git a/am-kernels/kernels/typing-game/font.c b/am-kernels/kernels/typing-game/font.c new file mode 100644 index 0000000..07f5194 --- /dev/null +++ b/am-kernels/kernels/typing-game/font.c @@ -0,0 +1,28 @@ +char font[] = { + 0x00, 0x00, 0x1c, 0x36, 0x63, 0x63, 0x63, 0x7f, 0x63, 0x63, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7e, 0x63, 0x63, 0x63, 0x7e, 0x63, 0x63, 0x63, 0x63, 0x7e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1e, 0x33, 0x61, 0x60, 0x60, 0x60, 0x60, 0x61, 0x33, 0x1e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7c, 0x66, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x66, 0x7c, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0x60, 0x60, 0x60, 0x7e, 0x60, 0x60, 0x60, 0x60, 0x7f, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0x60, 0x60, 0x60, 0x7c, 0x60, 0x60, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x1e, 0x33, 0x63, 0x60, 0x60, 0x67, 0x63, 0x63, 0x33, 0x1e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x63, 0x63, 0x63, 0x63, 0x7f, 0x63, 0x63, 0x63, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x66, 0x66, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x66, 0x66, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x60, 0x7e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x63, 0x77, 0x7f, 0x6b, 0x6b, 0x63, 0x63, 0x63, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x63, 0x63, 0x73, 0x6b, 0x67, 0x63, 0x63, 0x63, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x3e, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x3e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7e, 0x63, 0x63, 0x63, 0x63, 0x7e, 0x60, 0x60, 0x60, 0x60, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x3e, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x7b, 0x6f, 0x3e, 0x06, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x7e, 0x63, 0x63, 0x63, 0x7e, 0x6c, 0x66, 0x66, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x3e, 0x63, 0x63, 0x30, 0x18, 0x0c, 0x06, 0x63, 0x63, 0x3e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x3e, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x63, 0x36, 0x1c, 0x08, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x63, 0x63, 0x63, 0x63, 0x63, 0x6b, 0x6b, 0x7f, 0x77, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x63, 0x63, 0x22, 0x36, 0x1c, 0x1c, 0x36, 0x22, 0x63, 0x63, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x63, 0x63, 0x63, 0x63, 0x3e, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x7f, 0x03, 0x03, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x60, 0x7f, 0x00, 0x00, 0x00, 0x00, +}; diff --git a/am-kernels/kernels/typing-game/game.c b/am-kernels/kernels/typing-game/game.c new file mode 100644 index 0000000..77b4b07 --- /dev/null +++ b/am-kernels/kernels/typing-game/game.c @@ -0,0 +1,178 @@ +#include +#include +#include + +#define FPS 30 +#define CPS 5 +#define CHAR_W 8 +#define CHAR_H 16 +#define NCHAR 128 +#define COL_WHITE 0xeeeeee +#define COL_RED 0xff0033 +#define COL_GREEN 0x00cc33 +#define COL_PURPLE 0x2a0a29 + +enum { WHITE = 0, RED, GREEN, PURPLE }; +struct character { + char ch; + int x, y, v, t; +} chars[NCHAR]; + +int screen_w, screen_h, hit, miss, wrong; +uint32_t texture[3][26][CHAR_W * CHAR_H], blank[CHAR_W * CHAR_H]; + +int min(int a, int b) { + return (a < b) ? a : b; +} + +int randint(int l, int r) { + return l + (rand() & 0x7fffffff) % (r - l + 1); +} + +void new_char() { + for (int i = 0; i < LENGTH(chars); i++) { + struct character *c = &chars[i]; + if (!c->ch) { + c->ch = 'A' + randint(0, 25); + c->x = randint(0, screen_w - CHAR_W); + c->y = 0; + c->v = (screen_h - CHAR_H + 1) / randint(FPS * 3 / 2, FPS * 2); + c->t = 0; + return; + } + } +} + +void game_logic_update(int frame) { + if (frame % (FPS / CPS) == 0) new_char(); + for (int i = 0; i < LENGTH(chars); i++) { + struct character *c = &chars[i]; + if (c->ch) { + if (c->t > 0) { + if (--c->t == 0) { + c->ch = '\0'; + } + } else { + c->y += c->v; + if (c->y < 0) { + c->ch = '\0'; + } + if (c->y + CHAR_H >= screen_h) { + miss++; + c->v = 0; + c->y = screen_h - CHAR_H; + c->t = FPS; + } + } + } + } +} + +void render() { + static int x[NCHAR], y[NCHAR], n = 0; + + for (int i = 0; i < n; i++) { + io_write(AM_GPU_FBDRAW, x[i], y[i], blank, CHAR_W, CHAR_H, false); + } + + n = 0; + for (int i = 0; i < LENGTH(chars); i++) { + struct character *c = &chars[i]; + if (c->ch) { + x[n] = c->x; y[n] = c->y; n++; + int col = (c->v > 0) ? WHITE : (c->v < 0 ? GREEN : RED); + io_write(AM_GPU_FBDRAW, c->x, c->y, texture[col][c->ch - 'A'], CHAR_W, CHAR_H, false); + } + } + io_write(AM_GPU_FBDRAW, 0, 0, NULL, 0, 0, true); + for (int i = 0; i < 40; i++) putch('\b'); + printf("Hit: %d; Miss: %d; Wrong: %d", hit, miss, wrong); +} + +void check_hit(char ch) { + int m = -1; + for (int i = 0; i < LENGTH(chars); i++) { + struct character *c = &chars[i]; + if (ch == c->ch && c->v > 0 && (m < 0 || c->y > chars[m].y)) { + m = i; + } + } + if (m == -1) { + wrong++; + } else { + hit++; + chars[m].v = -(screen_h - CHAR_H + 1) / (FPS); + } +} + + +void video_init() { + screen_w = io_read(AM_GPU_CONFIG).width; + screen_h = io_read(AM_GPU_CONFIG).height; + + extern char font[]; + for (int i = 0; i < CHAR_W * CHAR_H; i++) + blank[i] = COL_PURPLE; + + uint32_t blank_line[screen_w]; + for (int i = 0; i < screen_w; i++) + blank_line[i] = COL_PURPLE; + + for (int y = 0; y < screen_h; y ++) + io_write(AM_GPU_FBDRAW, 0, y, blank_line, screen_w, 1, false); + + for (int ch = 0; ch < 26; ch++) { + char *c = &font[CHAR_H * ch]; + for (int i = 0, y = 0; y < CHAR_H; y++) + for (int x = 0; x < CHAR_W; x++, i++) { + int t = (c[y] >> (CHAR_W - x - 1)) & 1; + texture[WHITE][ch][i] = t ? COL_WHITE : COL_PURPLE; + texture[GREEN][ch][i] = t ? COL_GREEN : COL_PURPLE; + texture[RED ][ch][i] = t ? COL_RED : COL_PURPLE; + } + } +} + +char lut[256] = { + [AM_KEY_A] = 'A', [AM_KEY_B] = 'B', [AM_KEY_C] = 'C', [AM_KEY_D] = 'D', + [AM_KEY_E] = 'E', [AM_KEY_F] = 'F', [AM_KEY_G] = 'G', [AM_KEY_H] = 'H', + [AM_KEY_I] = 'I', [AM_KEY_J] = 'J', [AM_KEY_K] = 'K', [AM_KEY_L] = 'L', + [AM_KEY_M] = 'M', [AM_KEY_N] = 'N', [AM_KEY_O] = 'O', [AM_KEY_P] = 'P', + [AM_KEY_Q] = 'Q', [AM_KEY_R] = 'R', [AM_KEY_S] = 'S', [AM_KEY_T] = 'T', + [AM_KEY_U] = 'U', [AM_KEY_V] = 'V', [AM_KEY_W] = 'W', [AM_KEY_X] = 'X', + [AM_KEY_Y] = 'Y', [AM_KEY_Z] = 'Z', +}; + +int main() { + ioe_init(); + video_init(); + + panic_on(!io_read(AM_TIMER_CONFIG).present, "requires timer"); + panic_on(!io_read(AM_INPUT_CONFIG).present, "requires keyboard"); + + printf("Type 'ESC' to exit\n"); + + int current = 0, rendered = 0; + uint64_t t0 = io_read(AM_TIMER_UPTIME).us; + while (1) { + int frames = (io_read(AM_TIMER_UPTIME).us - t0) / (1000000 / FPS); + + for (; current < frames; current++) { + game_logic_update(current); + } + + while (1) { + AM_INPUT_KEYBRD_T ev = io_read(AM_INPUT_KEYBRD); + if (ev.keycode == AM_KEY_NONE) break; + if (ev.keydown && ev.keycode == AM_KEY_ESCAPE) halt(0); + if (ev.keydown && lut[ev.keycode]) { + check_hit(lut[ev.keycode]); + } + }; + + if (current > rendered) { + render(); + rendered = current; + } + } +} diff --git a/am-kernels/kernels/yield-os/Makefile b/am-kernels/kernels/yield-os/Makefile new file mode 100644 index 0000000..ba8c264 --- /dev/null +++ b/am-kernels/kernels/yield-os/Makefile @@ -0,0 +1,3 @@ +NAME = yield-os +SRCS = yield-os.c +include $(AM_HOME)/Makefile diff --git a/am-kernels/kernels/yield-os/yield-os.c b/am-kernels/kernels/yield-os/yield-os.c new file mode 100644 index 0000000..90eb3ff --- /dev/null +++ b/am-kernels/kernels/yield-os/yield-os.c @@ -0,0 +1,31 @@ +#include +#include + +#define STACK_SIZE (4096 * 8) +typedef union { + uint8_t stack[STACK_SIZE]; + struct { Context *cp; }; +} PCB; +static PCB pcb[2], pcb_boot, *current = &pcb_boot; + +static void f(void *arg) { + while (1) { + putch("?AB"[(uintptr_t)arg > 2 ? 0 : (uintptr_t)arg]); + for (int volatile i = 0; i < 100000; i++) ; + yield(); + } +} + +static Context *schedule(Event ev, Context *prev) { + current->cp = prev; + current = (current == &pcb[0] ? &pcb[1] : &pcb[0]); + return current->cp; +} + +int main() { + cte_init(schedule); + pcb[0].cp = kcontext((Area) { pcb[0].stack, &pcb[0] + 1 }, f, (void *)1L); + pcb[1].cp = kcontext((Area) { pcb[1].stack, &pcb[1] + 1 }, f, (void *)2L); + yield(); + panic("Should not reach here!"); +} diff --git a/am-kernels/tests/alu-tests/LICENSE b/am-kernels/tests/alu-tests/LICENSE new file mode 100644 index 0000000..eca0bfc --- /dev/null +++ b/am-kernels/tests/alu-tests/LICENSE @@ -0,0 +1,42 @@ +This software is licensed under a BSD Style License + +Copyright (c) 2015 Battelle Memorial Institute. All Rights Reserved. +http://www.battelle.org/ + +Redistribution and use of this software and associated documentation +("Software"), with or without modification, are permitted provided that the +following conditions are met: + +1. Redistributions of source code must retain copyright statements and + notices. Redistributions must also contain a copy of this document. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. The names "M/o/Vfuscator" and "Battelle" must not be used to endorse or + promote products derived from this Software without prior written + permission of Battelle Memorial Institute. For written permission, + please contact solutions@battelle.org + +4. Products derived from this Software may not be called "M/o/Vfuscator" or + "Battelle", nor may "M/o/Vfuscator" or "Battelle" appear in their names + without prior written permission of Battelle Memorial Institute. + Battelle is a registered trademark of Battelle Memorial Institute. + +5. Due credit should be given to the Battelle Memorial Institute. + +THIS SOFTWARE IS PROVIDED BY BATTELLE MEMORIAL INSTITUTE "AS IS" AND ANY +EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL BATTELLE MEMORIAL INSTITUTE OR ITS +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +The original author of this software is Christopher P. Domas, an employee of +the Battelle Memorial Institute. diff --git a/am-kernels/tests/alu-tests/Makefile b/am-kernels/tests/alu-tests/Makefile new file mode 100644 index 0000000..ac9e507 --- /dev/null +++ b/am-kernels/tests/alu-tests/Makefile @@ -0,0 +1,11 @@ +NAME = alutest +SRCS = build/alu_test.c +include $(AM_HOME)/Makefile + +GENERATOR = build/gen_alu_test + +$(GENERATOR): gen_alu_test.c + gcc -O2 -Wall -Werror $^ -o $@ + +$(SRCS): $(GENERATOR) + $^ > $@ diff --git a/am-kernels/tests/alu-tests/build/alu_test.c b/am-kernels/tests/alu-tests/build/alu_test.c new file mode 100644 index 0000000..c01d838 --- /dev/null +++ b/am-kernels/tests/alu-tests/build/alu_test.c @@ -0,0 +1,22365 @@ +#include +int main(void) { + int exit_code = 0; +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x+y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"+",0x80000000,0x0,(signed int)(x+y)==0x0?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x+y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"+",0x80000001,0x1,(signed int)(x+y)==0x1?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x+y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"+",0xfffffffe,0x7ffffffe,(signed int)(x+y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x+y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"+",0xffffffff,0x7fffffff,(signed int)(x+y)==0x7fffffff?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x+y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"+",0x0,0x80000000,(signed int)(x+y)==0x80000000?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x+y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"+",0x1,0x80000001,(signed int)(x+y)==0x80000001?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x+y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"+",0x2,0x80000002,(signed int)(x+y)==0x80000002?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x+y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"+",0x7ffffffe,0xfffffffe,(signed int)(x+y)==0xfffffffe?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x+y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"+",0x7fffffff,0xffffffff,(signed int)(x+y)==0xffffffff?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x+y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"+",0x80000001,0x2,(signed int)(x+y)==0x2?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x+y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"+",0xfffffffe,0x7fffffff,(signed int)(x+y)==0x7fffffff?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x+y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"+",0xffffffff,0x80000000,(signed int)(x+y)==0x80000000?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x+y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"+",0x0,0x80000001,(signed int)(x+y)==0x80000001?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x+y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"+",0x1,0x80000002,(signed int)(x+y)==0x80000002?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x+y)!=(signed int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"+",0x2,0x80000003,(signed int)(x+y)==0x80000003?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x+y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"+",0x7ffffffe,0xffffffff,(signed int)(x+y)==0xffffffff?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x+y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"+",0x7fffffff,0x0,(signed int)(x+y)==0x0?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x+y)!=(signed int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"+",0xfffffffe,0xfffffffc,(signed int)(x+y)==0xfffffffc?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x+y)!=(signed int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"+",0xffffffff,0xfffffffd,(signed int)(x+y)==0xfffffffd?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x+y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"+",0x0,0xfffffffe,(signed int)(x+y)==0xfffffffe?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x+y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"+",0x1,0xffffffff,(signed int)(x+y)==0xffffffff?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x+y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"+",0x2,0x0,(signed int)(x+y)==0x0?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x+y)!=(signed int)2147483644) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"+",0x7ffffffe,0x7ffffffc,(signed int)(x+y)==0x7ffffffc?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x+y)!=(signed int)2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"+",0x7fffffff,0x7ffffffd,(signed int)(x+y)==0x7ffffffd?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x+y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"+",0xffffffff,0xfffffffe,(signed int)(x+y)==0xfffffffe?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x+y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"+",0x0,0xffffffff,(signed int)(x+y)==0xffffffff?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x+y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"+",0x1,0x0,(signed int)(x+y)==0x0?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x+y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"+",0x2,0x1,(signed int)(x+y)==0x1?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x+y)!=(signed int)2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"+",0x7ffffffe,0x7ffffffd,(signed int)(x+y)==0x7ffffffd?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x+y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"+",0x7fffffff,0x7ffffffe,(signed int)(x+y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x+y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"+",0x0,0x0,(signed int)(x+y)==0x0?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x+y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"+",0x1,0x1,(signed int)(x+y)==0x1?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x+y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"+",0x2,0x2,(signed int)(x+y)==0x2?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x+y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"+",0x7ffffffe,0x7ffffffe,(signed int)(x+y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x+y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"+",0x7fffffff,0x7fffffff,(signed int)(x+y)==0x7fffffff?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x+y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"+",0x1,0x2,(signed int)(x+y)==0x2?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x+y)!=(signed int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"+",0x2,0x3,(signed int)(x+y)==0x3?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x+y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"+",0x7ffffffe,0x7fffffff,(signed int)(x+y)==0x7fffffff?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x+y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"+",0x7fffffff,0x80000000,(signed int)(x+y)==0x80000000?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x+y)!=(signed int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"+",0x2,0x4,(signed int)(x+y)==0x4?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x+y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"+",0x7ffffffe,0x80000000,(signed int)(x+y)==0x80000000?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x+y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"+",0x7fffffff,0x80000001,(signed int)(x+y)==0x80000001?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x+y)!=(signed int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"+",0x7ffffffe,0xfffffffc,(signed int)(x+y)==0xfffffffc?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x+y)!=(signed int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"+",0x7fffffff,0xfffffffd,(signed int)(x+y)==0xfffffffd?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x+y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"+",0x7fffffff,0xfffffffe,(signed int)(x+y)==0xfffffffe?"PASS":"FAIL",(signed int)(x+y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x-y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"-",0x80000000,0x0,(signed int)(x-y)==0x0?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x-y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"-",0x80000001,0xffffffff,(signed int)(x-y)==0xffffffff?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x-y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"-",0xfffffffe,0x80000002,(signed int)(x-y)==0x80000002?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x-y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"-",0xffffffff,0x80000001,(signed int)(x-y)==0x80000001?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x-y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"-",0x0,0x80000000,(signed int)(x-y)==0x80000000?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x-y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"-",0x1,0x7fffffff,(signed int)(x-y)==0x7fffffff?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x-y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"-",0x2,0x7ffffffe,(signed int)(x-y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x-y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"-",0x7ffffffe,0x2,(signed int)(x-y)==0x2?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x-y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"-",0x7fffffff,0x1,(signed int)(x-y)==0x1?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x-y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"-",0x80000001,0x0,(signed int)(x-y)==0x0?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x-y)!=(signed int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"-",0xfffffffe,0x80000003,(signed int)(x-y)==0x80000003?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x-y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"-",0xffffffff,0x80000002,(signed int)(x-y)==0x80000002?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x-y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"-",0x0,0x80000001,(signed int)(x-y)==0x80000001?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x-y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"-",0x1,0x80000000,(signed int)(x-y)==0x80000000?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x-y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"-",0x2,0x7fffffff,(signed int)(x-y)==0x7fffffff?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x-y)!=(signed int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"-",0x7ffffffe,0x3,(signed int)(x-y)==0x3?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x-y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"-",0x7fffffff,0x2,(signed int)(x-y)==0x2?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x-y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"-",0xfffffffe,0x0,(signed int)(x-y)==0x0?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x-y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"-",0xffffffff,0xffffffff,(signed int)(x-y)==0xffffffff?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x-y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"-",0x0,0xfffffffe,(signed int)(x-y)==0xfffffffe?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x-y)!=(signed int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"-",0x1,0xfffffffd,(signed int)(x-y)==0xfffffffd?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x-y)!=(signed int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"-",0x2,0xfffffffc,(signed int)(x-y)==0xfffffffc?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x-y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"-",0x7ffffffe,0x80000000,(signed int)(x-y)==0x80000000?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x-y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"-",0x7fffffff,0x7fffffff,(signed int)(x-y)==0x7fffffff?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x-y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"-",0xffffffff,0x0,(signed int)(x-y)==0x0?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x-y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"-",0x0,0xffffffff,(signed int)(x-y)==0xffffffff?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x-y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"-",0x1,0xfffffffe,(signed int)(x-y)==0xfffffffe?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x-y)!=(signed int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"-",0x2,0xfffffffd,(signed int)(x-y)==0xfffffffd?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x-y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"-",0x7ffffffe,0x80000001,(signed int)(x-y)==0x80000001?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x-y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"-",0x7fffffff,0x80000000,(signed int)(x-y)==0x80000000?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x-y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"-",0x0,0x0,(signed int)(x-y)==0x0?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x-y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"-",0x1,0xffffffff,(signed int)(x-y)==0xffffffff?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x-y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"-",0x2,0xfffffffe,(signed int)(x-y)==0xfffffffe?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x-y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"-",0x7ffffffe,0x80000002,(signed int)(x-y)==0x80000002?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x-y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"-",0x7fffffff,0x80000001,(signed int)(x-y)==0x80000001?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x-y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"-",0x1,0x0,(signed int)(x-y)==0x0?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x-y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"-",0x2,0xffffffff,(signed int)(x-y)==0xffffffff?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x-y)!=(signed int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"-",0x7ffffffe,0x80000003,(signed int)(x-y)==0x80000003?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x-y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"-",0x7fffffff,0x80000002,(signed int)(x-y)==0x80000002?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x-y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"-",0x2,0x0,(signed int)(x-y)==0x0?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x-y)!=(signed int)-2147483644) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"-",0x7ffffffe,0x80000004,(signed int)(x-y)==0x80000004?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x-y)!=(signed int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"-",0x7fffffff,0x80000003,(signed int)(x-y)==0x80000003?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x-y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"-",0x7ffffffe,0x0,(signed int)(x-y)==0x0?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x-y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"-",0x7fffffff,0xffffffff,(signed int)(x-y)==0xffffffff?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x-y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"-",0x7fffffff,0x0,(signed int)(x-y)==0x0?"PASS":"FAIL",(signed int)(x-y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x^y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"^",0x80000000,0x0,(signed int)(x^y)==0x0?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x^y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"^",0x80000001,0x1,(signed int)(x^y)==0x1?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x^y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"^",0xfffffffe,0x7ffffffe,(signed int)(x^y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x^y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"^",0xffffffff,0x7fffffff,(signed int)(x^y)==0x7fffffff?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x^y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"^",0x0,0x80000000,(signed int)(x^y)==0x80000000?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x^y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"^",0x1,0x80000001,(signed int)(x^y)==0x80000001?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x^y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"^",0x2,0x80000002,(signed int)(x^y)==0x80000002?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x^y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"^",0x7ffffffe,0xfffffffe,(signed int)(x^y)==0xfffffffe?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x^y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"^",0x7fffffff,0xffffffff,(signed int)(x^y)==0xffffffff?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x^y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"^",0x80000001,0x0,(signed int)(x^y)==0x0?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x^y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"^",0xfffffffe,0x7fffffff,(signed int)(x^y)==0x7fffffff?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x^y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"^",0xffffffff,0x7ffffffe,(signed int)(x^y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x^y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"^",0x0,0x80000001,(signed int)(x^y)==0x80000001?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x^y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"^",0x1,0x80000000,(signed int)(x^y)==0x80000000?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x^y)!=(signed int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"^",0x2,0x80000003,(signed int)(x^y)==0x80000003?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x^y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"^",0x7ffffffe,0xffffffff,(signed int)(x^y)==0xffffffff?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x^y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"^",0x7fffffff,0xfffffffe,(signed int)(x^y)==0xfffffffe?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x^y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"^",0xfffffffe,0x0,(signed int)(x^y)==0x0?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x^y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"^",0xffffffff,0x1,(signed int)(x^y)==0x1?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x^y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"^",0x0,0xfffffffe,(signed int)(x^y)==0xfffffffe?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x^y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"^",0x1,0xffffffff,(signed int)(x^y)==0xffffffff?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x^y)!=(signed int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"^",0x2,0xfffffffc,(signed int)(x^y)==0xfffffffc?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x^y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"^",0x7ffffffe,0x80000000,(signed int)(x^y)==0x80000000?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x^y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"^",0x7fffffff,0x80000001,(signed int)(x^y)==0x80000001?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x^y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"^",0xffffffff,0x0,(signed int)(x^y)==0x0?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x^y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"^",0x0,0xffffffff,(signed int)(x^y)==0xffffffff?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x^y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"^",0x1,0xfffffffe,(signed int)(x^y)==0xfffffffe?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x^y)!=(signed int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"^",0x2,0xfffffffd,(signed int)(x^y)==0xfffffffd?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x^y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"^",0x7ffffffe,0x80000001,(signed int)(x^y)==0x80000001?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x^y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"^",0x7fffffff,0x80000000,(signed int)(x^y)==0x80000000?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x^y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"^",0x0,0x0,(signed int)(x^y)==0x0?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x^y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"^",0x1,0x1,(signed int)(x^y)==0x1?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x^y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"^",0x2,0x2,(signed int)(x^y)==0x2?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x^y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"^",0x7ffffffe,0x7ffffffe,(signed int)(x^y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x^y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"^",0x7fffffff,0x7fffffff,(signed int)(x^y)==0x7fffffff?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x^y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"^",0x1,0x0,(signed int)(x^y)==0x0?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x^y)!=(signed int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"^",0x2,0x3,(signed int)(x^y)==0x3?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x^y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"^",0x7ffffffe,0x7fffffff,(signed int)(x^y)==0x7fffffff?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x^y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"^",0x7fffffff,0x7ffffffe,(signed int)(x^y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x^y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"^",0x2,0x0,(signed int)(x^y)==0x0?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x^y)!=(signed int)2147483644) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"^",0x7ffffffe,0x7ffffffc,(signed int)(x^y)==0x7ffffffc?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x^y)!=(signed int)2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"^",0x7fffffff,0x7ffffffd,(signed int)(x^y)==0x7ffffffd?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x^y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"^",0x7ffffffe,0x0,(signed int)(x^y)==0x0?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x^y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"^",0x7fffffff,0x1,(signed int)(x^y)==0x1?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x^y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"^",0x7fffffff,0x0,(signed int)(x^y)==0x0?"PASS":"FAIL",(signed int)(x^y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x&y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&",0x80000000,0x80000000,(signed int)(x&y)==0x80000000?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x&y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&",0x80000001,0x80000000,(signed int)(x&y)==0x80000000?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x&y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&",0xfffffffe,0x80000000,(signed int)(x&y)==0x80000000?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x&y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&",0xffffffff,0x80000000,(signed int)(x&y)==0x80000000?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&",0x0,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&",0x1,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&",0x2,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&",0x7ffffffe,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&",0x7fffffff,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x&y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&",0x80000001,0x80000001,(signed int)(x&y)==0x80000001?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x&y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&",0xfffffffe,0x80000000,(signed int)(x&y)==0x80000000?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x&y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&",0xffffffff,0x80000001,(signed int)(x&y)==0x80000001?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&",0x0,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&",0x1,0x1,(signed int)(x&y)==0x1?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&",0x2,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&",0x7ffffffe,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&",0x7fffffff,0x1,(signed int)(x&y)==0x1?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x&y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&",0xfffffffe,0xfffffffe,(signed int)(x&y)==0xfffffffe?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x&y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&",0xffffffff,0xfffffffe,(signed int)(x&y)==0xfffffffe?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&",0x0,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&",0x1,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x&y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&",0x2,0x2,(signed int)(x&y)==0x2?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x&y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&",0x7ffffffe,0x7ffffffe,(signed int)(x&y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x&y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&",0x7fffffff,0x7ffffffe,(signed int)(x&y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x&y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&",0xffffffff,0xffffffff,(signed int)(x&y)==0xffffffff?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&",0x0,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&",0x1,0x1,(signed int)(x&y)==0x1?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x&y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&",0x2,0x2,(signed int)(x&y)==0x2?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x&y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&",0x7ffffffe,0x7ffffffe,(signed int)(x&y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x&y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&",0x7fffffff,0x7fffffff,(signed int)(x&y)==0x7fffffff?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&",0x0,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&",0x1,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&",0x2,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&",0x7ffffffe,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&",0x7fffffff,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"&",0x1,0x1,(signed int)(x&y)==0x1?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"&",0x2,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"&",0x7ffffffe,0x0,(signed int)(x&y)==0x0?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"&",0x7fffffff,0x1,(signed int)(x&y)==0x1?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x&y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"&",0x2,0x2,(signed int)(x&y)==0x2?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x&y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"&",0x7ffffffe,0x2,(signed int)(x&y)==0x2?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x&y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"&",0x7fffffff,0x2,(signed int)(x&y)==0x2?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x&y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"&",0x7ffffffe,0x7ffffffe,(signed int)(x&y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x&y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"&",0x7fffffff,0x7ffffffe,(signed int)(x&y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x&y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"&",0x7fffffff,0x7fffffff,(signed int)(x&y)==0x7fffffff?"PASS":"FAIL",(signed int)(x&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x|y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"|",0x80000000,0x80000000,(signed int)(x|y)==0x80000000?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x|y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"|",0x80000001,0x80000001,(signed int)(x|y)==0x80000001?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x|y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"|",0xfffffffe,0xfffffffe,(signed int)(x|y)==0xfffffffe?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"|",0xffffffff,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x|y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"|",0x0,0x80000000,(signed int)(x|y)==0x80000000?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x|y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"|",0x1,0x80000001,(signed int)(x|y)==0x80000001?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x|y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"|",0x2,0x80000002,(signed int)(x|y)==0x80000002?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x|y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"|",0x7ffffffe,0xfffffffe,(signed int)(x|y)==0xfffffffe?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"|",0x7fffffff,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x|y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"|",0x80000001,0x80000001,(signed int)(x|y)==0x80000001?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"|",0xfffffffe,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"|",0xffffffff,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x|y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"|",0x0,0x80000001,(signed int)(x|y)==0x80000001?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x|y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"|",0x1,0x80000001,(signed int)(x|y)==0x80000001?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x|y)!=(signed int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"|",0x2,0x80000003,(signed int)(x|y)==0x80000003?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"|",0x7ffffffe,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"|",0x7fffffff,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x|y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"|",0xfffffffe,0xfffffffe,(signed int)(x|y)==0xfffffffe?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"|",0xffffffff,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x|y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"|",0x0,0xfffffffe,(signed int)(x|y)==0xfffffffe?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"|",0x1,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x|y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"|",0x2,0xfffffffe,(signed int)(x|y)==0xfffffffe?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x|y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"|",0x7ffffffe,0xfffffffe,(signed int)(x|y)==0xfffffffe?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"|",0x7fffffff,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"|",0xffffffff,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"|",0x0,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"|",0x1,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"|",0x2,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"|",0x7ffffffe,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x|y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"|",0x7fffffff,0xffffffff,(signed int)(x|y)==0xffffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x|y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"|",0x0,0x0,(signed int)(x|y)==0x0?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x|y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"|",0x1,0x1,(signed int)(x|y)==0x1?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x|y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"|",0x2,0x2,(signed int)(x|y)==0x2?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x|y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"|",0x7ffffffe,0x7ffffffe,(signed int)(x|y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x|y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"|",0x7fffffff,0x7fffffff,(signed int)(x|y)==0x7fffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x|y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"|",0x1,0x1,(signed int)(x|y)==0x1?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x|y)!=(signed int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"|",0x2,0x3,(signed int)(x|y)==0x3?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x|y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"|",0x7ffffffe,0x7fffffff,(signed int)(x|y)==0x7fffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x|y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"|",0x7fffffff,0x7fffffff,(signed int)(x|y)==0x7fffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x|y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"|",0x2,0x2,(signed int)(x|y)==0x2?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x|y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"|",0x7ffffffe,0x7ffffffe,(signed int)(x|y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x|y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"|",0x7fffffff,0x7fffffff,(signed int)(x|y)==0x7fffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x|y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"|",0x7ffffffe,0x7ffffffe,(signed int)(x|y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x|y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"|",0x7fffffff,0x7fffffff,(signed int)(x|y)==0x7fffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x|y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"|",0x7fffffff,0x7fffffff,(signed int)(x|y)==0x7fffffff?"PASS":"FAIL",(signed int)(x|y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x< %s (%d)\n",__LINE__,"signed int",0x80000000,"<<",0x0,0x80000000,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x80000000,"<<",0x1,0x0,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x80000000,"<<",0x2,0x0,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x80000001,"<<",0x0,0x80000001,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x80000001,"<<",0x1,0x2,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x80000001,"<<",0x2,0x4,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<<",0x0,0xfffffffe,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<<",0x1,0xfffffffc,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<<",0x2,0xfffffff8,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0xffffffff,"<<",0x0,0xffffffff,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0xffffffff,"<<",0x1,0xfffffffe,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0xffffffff,"<<",0x2,0xfffffffc,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x0,"<<",0x0,0x0,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x0,"<<",0x1,0x0,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x0,"<<",0x2,0x0,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x1,"<<",0x1,0x2,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x1,"<<",0x2,0x4,(signed int)(x< %s (%d)\n",__LINE__,"signed int",0x2,"<<",0x2,0x8,(signed int)(x<>y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">>",0x0,0x80000000,(signed int)(x>>y)==0x80000000?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x>>y)!=(signed int)-1073741824) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">>",0x1,0xc0000000,(signed int)(x>>y)==0xc0000000?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x>>y)!=(signed int)-536870912) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">>",0x2,0xe0000000,(signed int)(x>>y)==0xe0000000?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x>>y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">>",0x0,0x80000001,(signed int)(x>>y)==0x80000001?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x>>y)!=(signed int)-1073741824) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">>",0x1,0xc0000000,(signed int)(x>>y)==0xc0000000?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x>>y)!=(signed int)-536870912) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">>",0x2,0xe0000000,(signed int)(x>>y)==0xe0000000?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x>>y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">>",0x0,0xfffffffe,(signed int)(x>>y)==0xfffffffe?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x>>y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">>",0x1,0xffffffff,(signed int)(x>>y)==0xffffffff?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x>>y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">>",0x2,0xffffffff,(signed int)(x>>y)==0xffffffff?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x>>y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">>",0x0,0xffffffff,(signed int)(x>>y)==0xffffffff?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x>>y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">>",0x1,0xffffffff,(signed int)(x>>y)==0xffffffff?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x>>y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">>",0x2,0xffffffff,(signed int)(x>>y)==0xffffffff?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x>>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">>",0x0,0x0,(signed int)(x>>y)==0x0?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x>>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">>",0x1,0x0,(signed int)(x>>y)==0x0?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x>>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">>",0x2,0x0,(signed int)(x>>y)==0x0?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x>>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">>",0x1,0x0,(signed int)(x>>y)==0x0?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x>>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">>",0x2,0x0,(signed int)(x>>y)==0x0?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x>>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,">>",0x2,0x0,(signed int)(x>>y)==0x0?"PASS":"FAIL",(signed int)(x>>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&&",0x80000000,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&&",0x80000001,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&&",0xfffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&&",0xffffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x&&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&&",0x0,0x0,(signed int)(x&&y)==0x0?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&&",0x1,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&&",0x2,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&&",0x7ffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"&&",0x7fffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&&",0x80000001,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&&",0xfffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&&",0xffffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x&&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&&",0x0,0x0,(signed int)(x&&y)==0x0?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&&",0x1,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&&",0x2,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&&",0x7ffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"&&",0x7fffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&&",0xfffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&&",0xffffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x&&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&&",0x0,0x0,(signed int)(x&&y)==0x0?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&&",0x1,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&&",0x2,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&&",0x7ffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"&&",0x7fffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&&",0xffffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x&&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&&",0x0,0x0,(signed int)(x&&y)==0x0?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&&",0x1,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&&",0x2,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&&",0x7ffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"&&",0x7fffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x&&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&&",0x0,0x0,(signed int)(x&&y)==0x0?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x&&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&&",0x1,0x0,(signed int)(x&&y)==0x0?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x&&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&&",0x2,0x0,(signed int)(x&&y)==0x0?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x&&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&&",0x7ffffffe,0x0,(signed int)(x&&y)==0x0?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x&&y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"&&",0x7fffffff,0x0,(signed int)(x&&y)==0x0?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"&&",0x1,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"&&",0x2,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"&&",0x7ffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"&&",0x7fffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"&&",0x2,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"&&",0x7ffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"&&",0x7fffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"&&",0x7ffffffe,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"&&",0x7fffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x&&y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"&&",0x7fffffff,0x1,(signed int)(x&&y)==0x1?"PASS":"FAIL",(signed int)(x&&y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"||",0x80000000,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"||",0x80000001,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"||",0xfffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"||",0xffffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"||",0x0,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"||",0x1,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"||",0x2,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"||",0x7ffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"||",0x7fffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"||",0x80000001,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"||",0xfffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"||",0xffffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"||",0x0,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"||",0x1,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"||",0x2,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"||",0x7ffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"||",0x7fffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"||",0xfffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"||",0xffffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"||",0x0,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"||",0x1,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"||",0x2,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"||",0x7ffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"||",0x7fffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"||",0xffffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"||",0x0,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"||",0x1,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"||",0x2,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"||",0x7ffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"||",0x7fffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x||y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"||",0x0,0x0,(signed int)(x||y)==0x0?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"||",0x1,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"||",0x2,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"||",0x7ffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"||",0x7fffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"||",0x1,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"||",0x2,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"||",0x7ffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"||",0x7fffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"||",0x2,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"||",0x7ffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"||",0x7fffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"||",0x7ffffffe,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"||",0x7fffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x||y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"||",0x7fffffff,0x1,(signed int)(x||y)==0x1?"PASS":"FAIL",(signed int)(x||y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">",0x80000000,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">",0x80000001,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">",0xfffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">",0xffffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">",0x0,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">",0x1,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">",0x2,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">",0x7ffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">",0x7fffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">",0x80000001,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">",0xfffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">",0xffffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">",0x0,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">",0x1,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">",0x2,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">",0x7ffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">",0x7fffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">",0xfffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">",0xffffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">",0x0,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">",0x1,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">",0x2,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">",0x7ffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">",0x7fffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">",0xffffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">",0x0,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">",0x1,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">",0x2,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">",0x7ffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">",0x7fffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">",0x0,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">",0x1,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">",0x2,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">",0x7ffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">",0x7fffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">",0x1,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">",0x2,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">",0x7ffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">",0x7fffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,">",0x2,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,">",0x7ffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,">",0x7fffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,">",0x7ffffffe,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,">",0x7fffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x>y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,">",0x7fffffff,0x0,(signed int)(x>y)==0x0?"PASS":"FAIL",(signed int)(x>y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000000,"<",0x80000000,0x0,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000000,"<",0x80000001,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000000,"<",0xfffffffe,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000000,"<",0xffffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000000,"<",0x0,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000000,"<",0x1,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000000,"<",0x2,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000000,"<",0x7ffffffe,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000000,"<",0x7fffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000001,"<",0x80000001,0x0,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000001,"<",0xfffffffe,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000001,"<",0xffffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000001,"<",0x0,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000001,"<",0x1,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000001,"<",0x2,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000001,"<",0x7ffffffe,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x80000001,"<",0x7fffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<",0xfffffffe,0x0,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<",0xffffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<",0x0,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<",0x1,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<",0x2,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<",0x7ffffffe,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<",0x7fffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xffffffff,"<",0xffffffff,0x0,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xffffffff,"<",0x0,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xffffffff,"<",0x1,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xffffffff,"<",0x2,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xffffffff,"<",0x7ffffffe,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0xffffffff,"<",0x7fffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x0,"<",0x0,0x0,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x0,"<",0x1,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x0,"<",0x2,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x0,"<",0x7ffffffe,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x0,"<",0x7fffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x1,"<",0x1,0x0,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x1,"<",0x2,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x1,"<",0x7ffffffe,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x1,"<",0x7fffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x2,"<",0x2,0x0,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x2,"<",0x7ffffffe,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x2,"<",0x7fffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"<",0x7ffffffe,0x0,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"<",0x7fffffff,0x1,(signed int)(x %s (%d)\n",__LINE__,"signed int",0x7fffffff,"<",0x7fffffff,0x0,(signed int)(x=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">=",0x80000000,0x1,(signed int)(x>=y)==0x1?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">=",0x80000001,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">=",0xfffffffe,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">=",0xffffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">=",0x0,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">=",0x1,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">=",0x2,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">=",0x7ffffffe,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,">=",0x7fffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x>=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">=",0x80000001,0x1,(signed int)(x>=y)==0x1?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">=",0xfffffffe,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">=",0xffffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">=",0x0,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">=",0x1,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">=",0x2,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">=",0x7ffffffe,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,">=",0x7fffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x>=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">=",0xfffffffe,0x1,(signed int)(x>=y)==0x1?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">=",0xffffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">=",0x0,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">=",0x1,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">=",0x2,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">=",0x7ffffffe,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,">=",0x7fffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x>=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">=",0xffffffff,0x1,(signed int)(x>=y)==0x1?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">=",0x0,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">=",0x1,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">=",0x2,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">=",0x7ffffffe,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,">=",0x7fffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x>=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">=",0x0,0x1,(signed int)(x>=y)==0x1?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">=",0x1,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">=",0x2,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">=",0x7ffffffe,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,">=",0x7fffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x>=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">=",0x1,0x1,(signed int)(x>=y)==0x1?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">=",0x2,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">=",0x7ffffffe,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,">=",0x7fffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x>=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,">=",0x2,0x1,(signed int)(x>=y)==0x1?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,">=",0x7ffffffe,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,">=",0x7fffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x>=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,">=",0x7ffffffe,0x1,(signed int)(x>=y)==0x1?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x>=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,">=",0x7fffffff,0x0,(signed int)(x>=y)==0x0?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x>=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,">=",0x7fffffff,0x1,(signed int)(x>=y)==0x1?"PASS":"FAIL",(signed int)(x>=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"<=",0x80000000,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"<=",0x80000001,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"<=",0xfffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"<=",0xffffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"<=",0x0,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"<=",0x1,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"<=",0x2,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"<=",0x7ffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"<=",0x7fffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"<=",0x80000001,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"<=",0xfffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"<=",0xffffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"<=",0x0,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"<=",0x1,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"<=",0x2,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"<=",0x7ffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"<=",0x7fffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<=",0xfffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<=",0xffffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<=",0x0,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<=",0x1,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<=",0x2,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<=",0x7ffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"<=",0x7fffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"<=",0xffffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"<=",0x0,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"<=",0x1,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"<=",0x2,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"<=",0x7ffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"<=",0x7fffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"<=",0x0,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"<=",0x1,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"<=",0x2,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"<=",0x7ffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"<=",0x7fffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"<=",0x1,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"<=",0x2,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"<=",0x7ffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"<=",0x7fffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"<=",0x2,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"<=",0x7ffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"<=",0x7fffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"<=",0x7ffffffe,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"<=",0x7fffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x<=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"<=",0x7fffffff,0x1,(signed int)(x<=y)==0x1?"PASS":"FAIL",(signed int)(x<=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x==y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"==",0x80000000,0x1,(signed int)(x==y)==0x1?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"==",0x80000001,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"==",0xfffffffe,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"==",0xffffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"==",0x0,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"==",0x1,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"==",0x2,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"==",0x7ffffffe,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"==",0x7fffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x==y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"==",0x80000001,0x1,(signed int)(x==y)==0x1?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"==",0xfffffffe,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"==",0xffffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"==",0x0,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"==",0x1,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"==",0x2,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"==",0x7ffffffe,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"==",0x7fffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x==y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"==",0xfffffffe,0x1,(signed int)(x==y)==0x1?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"==",0xffffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"==",0x0,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"==",0x1,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"==",0x2,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"==",0x7ffffffe,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"==",0x7fffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x==y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"==",0xffffffff,0x1,(signed int)(x==y)==0x1?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"==",0x0,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"==",0x1,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"==",0x2,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"==",0x7ffffffe,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"==",0x7fffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x==y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"==",0x0,0x1,(signed int)(x==y)==0x1?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"==",0x1,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"==",0x2,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"==",0x7ffffffe,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"==",0x7fffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x==y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"==",0x1,0x1,(signed int)(x==y)==0x1?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"==",0x2,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"==",0x7ffffffe,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"==",0x7fffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x==y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"==",0x2,0x1,(signed int)(x==y)==0x1?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"==",0x7ffffffe,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"==",0x7fffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x==y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"==",0x7ffffffe,0x1,(signed int)(x==y)==0x1?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x==y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"==",0x7fffffff,0x0,(signed int)(x==y)==0x0?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x==y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"==",0x7fffffff,0x1,(signed int)(x==y)==0x1?"PASS":"FAIL",(signed int)(x==y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x!=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"!=",0x80000000,0x0,(signed int)(x!=y)==0x0?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"!=",0x80000001,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"!=",0xfffffffe,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"!=",0xffffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"!=",0x0,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"!=",0x1,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"!=",0x2,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"!=",0x7ffffffe,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"!=",0x7fffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x!=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"!=",0x80000001,0x0,(signed int)(x!=y)==0x0?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"!=",0xfffffffe,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"!=",0xffffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"!=",0x0,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"!=",0x1,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"!=",0x2,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"!=",0x7ffffffe,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"!=",0x7fffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x!=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"!=",0xfffffffe,0x0,(signed int)(x!=y)==0x0?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"!=",0xffffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"!=",0x0,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"!=",0x1,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"!=",0x2,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"!=",0x7ffffffe,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"!=",0x7fffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x!=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"!=",0xffffffff,0x0,(signed int)(x!=y)==0x0?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"!=",0x0,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"!=",0x1,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"!=",0x2,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"!=",0x7ffffffe,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"!=",0x7fffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x!=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"!=",0x0,0x0,(signed int)(x!=y)==0x0?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"!=",0x1,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"!=",0x2,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"!=",0x7ffffffe,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"!=",0x7fffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x!=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"!=",0x1,0x0,(signed int)(x!=y)==0x0?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"!=",0x2,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"!=",0x7ffffffe,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"!=",0x7fffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x!=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"!=",0x2,0x0,(signed int)(x!=y)==0x0?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"!=",0x7ffffffe,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"!=",0x7fffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x!=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"!=",0x7ffffffe,0x0,(signed int)(x!=y)==0x0?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x!=y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"!=",0x7fffffff,0x1,(signed int)(x!=y)==0x1?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x!=y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"!=",0x7fffffff,0x0,(signed int)(x!=y)==0x0?"PASS":"FAIL",(signed int)(x!=y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"*",0x80000000,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x*y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"*",0x80000001,0x80000000,(signed int)(x*y)==0x80000000?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"*",0xfffffffe,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-1; + if ((signed int)(x*y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"*",0xffffffff,0x80000000,(signed int)(x*y)==0x80000000?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=0; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"*",0x0,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x*y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"*",0x1,0x80000000,(signed int)(x*y)==0x80000000?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"*",0x2,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"*",0x7ffffffe,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x*y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"*",0x7fffffff,0x80000000,(signed int)(x*y)==0x80000000?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x*y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"*",0x80000001,0x1,(signed int)(x*y)==0x1?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x*y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"*",0xfffffffe,0xfffffffe,(signed int)(x*y)==0xfffffffe?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x*y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"*",0xffffffff,0x7fffffff,(signed int)(x*y)==0x7fffffff?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=0; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"*",0x0,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x*y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"*",0x1,0x80000001,(signed int)(x*y)==0x80000001?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x*y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"*",0x2,0x2,(signed int)(x*y)==0x2?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x*y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"*",0x7ffffffe,0x7ffffffe,(signed int)(x*y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x*y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"*",0x7fffffff,0xffffffff,(signed int)(x*y)==0xffffffff?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x*y)!=(signed int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"*",0xfffffffe,0x4,(signed int)(x*y)==0x4?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x*y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"*",0xffffffff,0x2,(signed int)(x*y)==0x2?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=0; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"*",0x0,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x*y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"*",0x1,0xfffffffe,(signed int)(x*y)==0xfffffffe?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x*y)!=(signed int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"*",0x2,0xfffffffc,(signed int)(x*y)==0xfffffffc?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x*y)!=(signed int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"*",0x7ffffffe,0x4,(signed int)(x*y)==0x4?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x*y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"*",0x7fffffff,0x2,(signed int)(x*y)==0x2?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x*y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"*",0xffffffff,0x1,(signed int)(x*y)==0x1?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=0; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"*",0x0,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x*y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"*",0x1,0xffffffff,(signed int)(x*y)==0xffffffff?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x*y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"*",0x2,0xfffffffe,(signed int)(x*y)==0xfffffffe?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x*y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"*",0x7ffffffe,0x80000002,(signed int)(x*y)==0x80000002?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x*y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"*",0x7fffffff,0x80000001,(signed int)(x*y)==0x80000001?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=0; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"*",0x0,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"*",0x1,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"*",0x2,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"*",0x7ffffffe,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x*y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"*",0x7fffffff,0x0,(signed int)(x*y)==0x0?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x*y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"*",0x1,0x1,(signed int)(x*y)==0x1?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x*y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"*",0x2,0x2,(signed int)(x*y)==0x2?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x*y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"*",0x7ffffffe,0x7ffffffe,(signed int)(x*y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x*y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"*",0x7fffffff,0x7fffffff,(signed int)(x*y)==0x7fffffff?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x*y)!=(signed int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"*",0x2,0x4,(signed int)(x*y)==0x4?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x*y)!=(signed int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"*",0x7ffffffe,0xfffffffc,(signed int)(x*y)==0xfffffffc?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x*y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"*",0x7fffffff,0xfffffffe,(signed int)(x*y)==0xfffffffe?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x*y)!=(signed int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"*",0x7ffffffe,0x4,(signed int)(x*y)==0x4?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x*y)!=(signed int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"*",0x7fffffff,0x80000002,(signed int)(x*y)==0x80000002?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x*y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"*",0x7fffffff,0x1,(signed int)(x*y)==0x1?"PASS":"FAIL",(signed int)(x*y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x/y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"/",0x80000000,0x1,(signed int)(x/y)==0x1?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x/y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"/",0x80000001,0x1,(signed int)(x/y)==0x1?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x/y)!=(signed int)1073741824) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"/",0xfffffffe,0x40000000,(signed int)(x/y)==0x40000000?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x/y)!=(signed int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"/",0x1,0x80000000,(signed int)(x/y)==0x80000000?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x/y)!=(signed int)-1073741824) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"/",0x2,0xc0000000,(signed int)(x/y)==0xc0000000?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x/y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"/",0x7ffffffe,0xffffffff,(signed int)(x/y)==0xffffffff?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x/y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"/",0x7fffffff,0xffffffff,(signed int)(x/y)==0xffffffff?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x/y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"/",0x80000001,0x1,(signed int)(x/y)==0x1?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x/y)!=(signed int)1073741823) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"/",0xfffffffe,0x3fffffff,(signed int)(x/y)==0x3fffffff?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x/y)!=(signed int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"/",0xffffffff,0x7fffffff,(signed int)(x/y)==0x7fffffff?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x/y)!=(signed int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"/",0x1,0x80000001,(signed int)(x/y)==0x80000001?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x/y)!=(signed int)-1073741823) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"/",0x2,0xc0000001,(signed int)(x/y)==0xc0000001?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x/y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"/",0x7ffffffe,0xffffffff,(signed int)(x/y)==0xffffffff?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x/y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"/",0x7fffffff,0xffffffff,(signed int)(x/y)==0xffffffff?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x/y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"/",0xfffffffe,0x1,(signed int)(x/y)==0x1?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x/y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"/",0xffffffff,0x2,(signed int)(x/y)==0x2?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x/y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"/",0x1,0xfffffffe,(signed int)(x/y)==0xfffffffe?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x/y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"/",0x2,0xffffffff,(signed int)(x/y)==0xffffffff?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"/",0x7ffffffe,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"/",0x7fffffff,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x/y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"/",0xffffffff,0x1,(signed int)(x/y)==0x1?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x/y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"/",0x1,0xffffffff,(signed int)(x/y)==0xffffffff?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"/",0x2,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"/",0x7ffffffe,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"/",0x7fffffff,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"/",0x1,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"/",0x2,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"/",0x7ffffffe,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"/",0x7fffffff,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x/y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"/",0x1,0x1,(signed int)(x/y)==0x1?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"/",0x2,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"/",0x7ffffffe,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"/",0x7fffffff,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x/y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"/",0x2,0x1,(signed int)(x/y)==0x1?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"/",0x7ffffffe,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"/",0x7fffffff,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x/y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"/",0x7ffffffe,0x1,(signed int)(x/y)==0x1?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x/y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"/",0x7fffffff,0x0,(signed int)(x/y)==0x0?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x/y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"/",0x7fffffff,0x1,(signed int)(x/y)==0x1?"PASS":"FAIL",(signed int)(x/y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483648; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"%",0x80000000,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2147483647; + if ((signed int)(x%y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"%",0x80000001,0xffffffff,(signed int)(x%y)==0xffffffff?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=-2; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"%",0xfffffffe,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=1; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"%",0x1,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"%",0x2,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483646; + if ((signed int)(x%y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"%",0x7ffffffe,0xfffffffe,(signed int)(x%y)==0xfffffffe?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483648; volatile signed int y=2147483647; + if ((signed int)(x%y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000000,"%",0x7fffffff,0xffffffff,(signed int)(x%y)==0xffffffff?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2147483647; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"%",0x80000001,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-2; + if ((signed int)(x%y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"%",0xfffffffe,0xffffffff,(signed int)(x%y)==0xffffffff?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=-1; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"%",0xffffffff,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=1; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"%",0x1,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2; + if ((signed int)(x%y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"%",0x2,0xffffffff,(signed int)(x%y)==0xffffffff?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483646; + if ((signed int)(x%y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"%",0x7ffffffe,0xffffffff,(signed int)(x%y)==0xffffffff?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2147483647; volatile signed int y=2147483647; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x80000001,"%",0x7fffffff,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-2; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"%",0xfffffffe,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=-1; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"%",0xffffffff,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=1; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"%",0x1,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"%",0x2,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483646; + if ((signed int)(x%y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"%",0x7ffffffe,0xfffffffe,(signed int)(x%y)==0xfffffffe?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-2; volatile signed int y=2147483647; + if ((signed int)(x%y)!=(signed int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xfffffffe,"%",0x7fffffff,0xfffffffe,(signed int)(x%y)==0xfffffffe?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=-1; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"%",0xffffffff,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=1; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"%",0x1,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2; + if ((signed int)(x%y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"%",0x2,0xffffffff,(signed int)(x%y)==0xffffffff?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483646; + if ((signed int)(x%y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"%",0x7ffffffe,0xffffffff,(signed int)(x%y)==0xffffffff?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=-1; volatile signed int y=2147483647; + if ((signed int)(x%y)!=(signed int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0xffffffff,"%",0x7fffffff,0xffffffff,(signed int)(x%y)==0xffffffff?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=1; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"%",0x1,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"%",0x2,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483646; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"%",0x7ffffffe,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=0; volatile signed int y=2147483647; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x0,"%",0x7fffffff,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=1; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"%",0x1,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2; + if ((signed int)(x%y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"%",0x2,0x1,(signed int)(x%y)==0x1?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483646; + if ((signed int)(x%y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"%",0x7ffffffe,0x1,(signed int)(x%y)==0x1?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=1; volatile signed int y=2147483647; + if ((signed int)(x%y)!=(signed int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x1,"%",0x7fffffff,0x1,(signed int)(x%y)==0x1?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"%",0x2,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483646; + if ((signed int)(x%y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"%",0x7ffffffe,0x2,(signed int)(x%y)==0x2?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=2; volatile signed int y=2147483647; + if ((signed int)(x%y)!=(signed int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x2,"%",0x7fffffff,0x2,(signed int)(x%y)==0x2?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483646; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"%",0x7ffffffe,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=2147483646; volatile signed int y=2147483647; + if ((signed int)(x%y)!=(signed int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7ffffffe,"%",0x7fffffff,0x7ffffffe,(signed int)(x%y)==0x7ffffffe?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed int x=2147483647; volatile signed int y=2147483647; + if ((signed int)(x%y)!=(signed int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed int",0x7fffffff,"%",0x7fffffff,0x0,(signed int)(x%y)==0x0?"PASS":"FAIL",(signed int)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x+y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"+",0xffff8000,0x0,(signed short)(x+y)==0x0?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x+y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"+",0xffff8001,0x1,(signed short)(x+y)==0x1?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x+y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"+",0xfffffffe,0x7ffe,(signed short)(x+y)==0x7ffe?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x+y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"+",0xffffffff,0x7fff,(signed short)(x+y)==0x7fff?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x+y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"+",0x0,0xffff8000,(signed short)(x+y)==0xffff8000?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x+y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"+",0x1,0xffff8001,(signed short)(x+y)==0xffff8001?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x+y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"+",0x2,0xffff8002,(signed short)(x+y)==0xffff8002?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x+y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"+",0x7ffe,0xfffffffe,(signed short)(x+y)==0xfffffffe?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x+y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"+",0x7fff,0xffffffff,(signed short)(x+y)==0xffffffff?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x+y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"+",0xffff8001,0x2,(signed short)(x+y)==0x2?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x+y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"+",0xfffffffe,0x7fff,(signed short)(x+y)==0x7fff?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x+y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"+",0xffffffff,0xffff8000,(signed short)(x+y)==0xffff8000?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x+y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"+",0x0,0xffff8001,(signed short)(x+y)==0xffff8001?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x+y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"+",0x1,0xffff8002,(signed short)(x+y)==0xffff8002?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x+y)!=(signed short)-32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"+",0x2,0xffff8003,(signed short)(x+y)==0xffff8003?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x+y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"+",0x7ffe,0xffffffff,(signed short)(x+y)==0xffffffff?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x+y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"+",0x7fff,0x0,(signed short)(x+y)==0x0?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x+y)!=(signed short)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"+",0xfffffffe,0xfffffffc,(signed short)(x+y)==0xfffffffc?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x+y)!=(signed short)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"+",0xffffffff,0xfffffffd,(signed short)(x+y)==0xfffffffd?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x+y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"+",0x0,0xfffffffe,(signed short)(x+y)==0xfffffffe?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x+y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"+",0x1,0xffffffff,(signed short)(x+y)==0xffffffff?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x+y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"+",0x2,0x0,(signed short)(x+y)==0x0?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x+y)!=(signed short)32764) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"+",0x7ffe,0x7ffc,(signed short)(x+y)==0x7ffc?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x+y)!=(signed short)32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"+",0x7fff,0x7ffd,(signed short)(x+y)==0x7ffd?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x+y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"+",0xffffffff,0xfffffffe,(signed short)(x+y)==0xfffffffe?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x+y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"+",0x0,0xffffffff,(signed short)(x+y)==0xffffffff?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x+y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"+",0x1,0x0,(signed short)(x+y)==0x0?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x+y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"+",0x2,0x1,(signed short)(x+y)==0x1?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x+y)!=(signed short)32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"+",0x7ffe,0x7ffd,(signed short)(x+y)==0x7ffd?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x+y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"+",0x7fff,0x7ffe,(signed short)(x+y)==0x7ffe?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x+y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"+",0x0,0x0,(signed short)(x+y)==0x0?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x+y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"+",0x1,0x1,(signed short)(x+y)==0x1?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x+y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"+",0x2,0x2,(signed short)(x+y)==0x2?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x+y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"+",0x7ffe,0x7ffe,(signed short)(x+y)==0x7ffe?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x+y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"+",0x7fff,0x7fff,(signed short)(x+y)==0x7fff?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x+y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"+",0x1,0x2,(signed short)(x+y)==0x2?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x+y)!=(signed short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"+",0x2,0x3,(signed short)(x+y)==0x3?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x+y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"+",0x7ffe,0x7fff,(signed short)(x+y)==0x7fff?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x+y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"+",0x7fff,0xffff8000,(signed short)(x+y)==0xffff8000?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x+y)!=(signed short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"+",0x2,0x4,(signed short)(x+y)==0x4?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x+y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"+",0x7ffe,0xffff8000,(signed short)(x+y)==0xffff8000?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x+y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"+",0x7fff,0xffff8001,(signed short)(x+y)==0xffff8001?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x+y)!=(signed short)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"+",0x7ffe,0xfffffffc,(signed short)(x+y)==0xfffffffc?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x+y)!=(signed short)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"+",0x7fff,0xfffffffd,(signed short)(x+y)==0xfffffffd?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x+y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"+",0x7fff,0xfffffffe,(signed short)(x+y)==0xfffffffe?"PASS":"FAIL",(signed short)(x+y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x-y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"-",0xffff8000,0x0,(signed short)(x-y)==0x0?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x-y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"-",0xffff8001,0xffffffff,(signed short)(x-y)==0xffffffff?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x-y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"-",0xfffffffe,0xffff8002,(signed short)(x-y)==0xffff8002?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x-y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"-",0xffffffff,0xffff8001,(signed short)(x-y)==0xffff8001?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x-y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"-",0x0,0xffff8000,(signed short)(x-y)==0xffff8000?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x-y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"-",0x1,0x7fff,(signed short)(x-y)==0x7fff?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x-y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"-",0x2,0x7ffe,(signed short)(x-y)==0x7ffe?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x-y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"-",0x7ffe,0x2,(signed short)(x-y)==0x2?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x-y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"-",0x7fff,0x1,(signed short)(x-y)==0x1?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x-y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"-",0xffff8001,0x0,(signed short)(x-y)==0x0?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x-y)!=(signed short)-32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"-",0xfffffffe,0xffff8003,(signed short)(x-y)==0xffff8003?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x-y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"-",0xffffffff,0xffff8002,(signed short)(x-y)==0xffff8002?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x-y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"-",0x0,0xffff8001,(signed short)(x-y)==0xffff8001?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x-y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"-",0x1,0xffff8000,(signed short)(x-y)==0xffff8000?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x-y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"-",0x2,0x7fff,(signed short)(x-y)==0x7fff?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x-y)!=(signed short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"-",0x7ffe,0x3,(signed short)(x-y)==0x3?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x-y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"-",0x7fff,0x2,(signed short)(x-y)==0x2?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x-y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"-",0xfffffffe,0x0,(signed short)(x-y)==0x0?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x-y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"-",0xffffffff,0xffffffff,(signed short)(x-y)==0xffffffff?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x-y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"-",0x0,0xfffffffe,(signed short)(x-y)==0xfffffffe?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x-y)!=(signed short)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"-",0x1,0xfffffffd,(signed short)(x-y)==0xfffffffd?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x-y)!=(signed short)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"-",0x2,0xfffffffc,(signed short)(x-y)==0xfffffffc?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x-y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"-",0x7ffe,0xffff8000,(signed short)(x-y)==0xffff8000?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x-y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"-",0x7fff,0x7fff,(signed short)(x-y)==0x7fff?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x-y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"-",0xffffffff,0x0,(signed short)(x-y)==0x0?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x-y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"-",0x0,0xffffffff,(signed short)(x-y)==0xffffffff?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x-y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"-",0x1,0xfffffffe,(signed short)(x-y)==0xfffffffe?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x-y)!=(signed short)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"-",0x2,0xfffffffd,(signed short)(x-y)==0xfffffffd?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x-y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"-",0x7ffe,0xffff8001,(signed short)(x-y)==0xffff8001?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x-y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"-",0x7fff,0xffff8000,(signed short)(x-y)==0xffff8000?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x-y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"-",0x0,0x0,(signed short)(x-y)==0x0?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x-y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"-",0x1,0xffffffff,(signed short)(x-y)==0xffffffff?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x-y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"-",0x2,0xfffffffe,(signed short)(x-y)==0xfffffffe?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x-y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"-",0x7ffe,0xffff8002,(signed short)(x-y)==0xffff8002?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x-y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"-",0x7fff,0xffff8001,(signed short)(x-y)==0xffff8001?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x-y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"-",0x1,0x0,(signed short)(x-y)==0x0?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x-y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"-",0x2,0xffffffff,(signed short)(x-y)==0xffffffff?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x-y)!=(signed short)-32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"-",0x7ffe,0xffff8003,(signed short)(x-y)==0xffff8003?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x-y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"-",0x7fff,0xffff8002,(signed short)(x-y)==0xffff8002?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x-y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"-",0x2,0x0,(signed short)(x-y)==0x0?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x-y)!=(signed short)-32764) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"-",0x7ffe,0xffff8004,(signed short)(x-y)==0xffff8004?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x-y)!=(signed short)-32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"-",0x7fff,0xffff8003,(signed short)(x-y)==0xffff8003?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x-y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"-",0x7ffe,0x0,(signed short)(x-y)==0x0?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x-y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"-",0x7fff,0xffffffff,(signed short)(x-y)==0xffffffff?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x-y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"-",0x7fff,0x0,(signed short)(x-y)==0x0?"PASS":"FAIL",(signed short)(x-y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x^y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"^",0xffff8000,0x0,(signed short)(x^y)==0x0?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x^y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"^",0xffff8001,0x1,(signed short)(x^y)==0x1?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x^y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"^",0xfffffffe,0x7ffe,(signed short)(x^y)==0x7ffe?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x^y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"^",0xffffffff,0x7fff,(signed short)(x^y)==0x7fff?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x^y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"^",0x0,0xffff8000,(signed short)(x^y)==0xffff8000?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x^y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"^",0x1,0xffff8001,(signed short)(x^y)==0xffff8001?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x^y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"^",0x2,0xffff8002,(signed short)(x^y)==0xffff8002?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x^y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"^",0x7ffe,0xfffffffe,(signed short)(x^y)==0xfffffffe?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x^y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"^",0x7fff,0xffffffff,(signed short)(x^y)==0xffffffff?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x^y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"^",0xffff8001,0x0,(signed short)(x^y)==0x0?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x^y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"^",0xfffffffe,0x7fff,(signed short)(x^y)==0x7fff?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x^y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"^",0xffffffff,0x7ffe,(signed short)(x^y)==0x7ffe?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x^y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"^",0x0,0xffff8001,(signed short)(x^y)==0xffff8001?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x^y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"^",0x1,0xffff8000,(signed short)(x^y)==0xffff8000?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x^y)!=(signed short)-32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"^",0x2,0xffff8003,(signed short)(x^y)==0xffff8003?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x^y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"^",0x7ffe,0xffffffff,(signed short)(x^y)==0xffffffff?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x^y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"^",0x7fff,0xfffffffe,(signed short)(x^y)==0xfffffffe?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x^y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"^",0xfffffffe,0x0,(signed short)(x^y)==0x0?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x^y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"^",0xffffffff,0x1,(signed short)(x^y)==0x1?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x^y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"^",0x0,0xfffffffe,(signed short)(x^y)==0xfffffffe?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x^y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"^",0x1,0xffffffff,(signed short)(x^y)==0xffffffff?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x^y)!=(signed short)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"^",0x2,0xfffffffc,(signed short)(x^y)==0xfffffffc?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x^y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"^",0x7ffe,0xffff8000,(signed short)(x^y)==0xffff8000?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x^y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"^",0x7fff,0xffff8001,(signed short)(x^y)==0xffff8001?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x^y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"^",0xffffffff,0x0,(signed short)(x^y)==0x0?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x^y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"^",0x0,0xffffffff,(signed short)(x^y)==0xffffffff?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x^y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"^",0x1,0xfffffffe,(signed short)(x^y)==0xfffffffe?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x^y)!=(signed short)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"^",0x2,0xfffffffd,(signed short)(x^y)==0xfffffffd?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x^y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"^",0x7ffe,0xffff8001,(signed short)(x^y)==0xffff8001?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x^y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"^",0x7fff,0xffff8000,(signed short)(x^y)==0xffff8000?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x^y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"^",0x0,0x0,(signed short)(x^y)==0x0?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x^y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"^",0x1,0x1,(signed short)(x^y)==0x1?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x^y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"^",0x2,0x2,(signed short)(x^y)==0x2?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x^y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"^",0x7ffe,0x7ffe,(signed short)(x^y)==0x7ffe?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x^y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"^",0x7fff,0x7fff,(signed short)(x^y)==0x7fff?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x^y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"^",0x1,0x0,(signed short)(x^y)==0x0?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x^y)!=(signed short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"^",0x2,0x3,(signed short)(x^y)==0x3?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x^y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"^",0x7ffe,0x7fff,(signed short)(x^y)==0x7fff?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x^y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"^",0x7fff,0x7ffe,(signed short)(x^y)==0x7ffe?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x^y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"^",0x2,0x0,(signed short)(x^y)==0x0?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x^y)!=(signed short)32764) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"^",0x7ffe,0x7ffc,(signed short)(x^y)==0x7ffc?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x^y)!=(signed short)32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"^",0x7fff,0x7ffd,(signed short)(x^y)==0x7ffd?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x^y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"^",0x7ffe,0x0,(signed short)(x^y)==0x0?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x^y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"^",0x7fff,0x1,(signed short)(x^y)==0x1?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x^y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"^",0x7fff,0x0,(signed short)(x^y)==0x0?"PASS":"FAIL",(signed short)(x^y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x&y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&",0xffff8000,0xffff8000,(signed short)(x&y)==0xffff8000?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x&y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&",0xffff8001,0xffff8000,(signed short)(x&y)==0xffff8000?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x&y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&",0xfffffffe,0xffff8000,(signed short)(x&y)==0xffff8000?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x&y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&",0xffffffff,0xffff8000,(signed short)(x&y)==0xffff8000?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&",0x0,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&",0x1,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&",0x2,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&",0x7ffe,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&",0x7fff,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x&y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&",0xffff8001,0xffff8001,(signed short)(x&y)==0xffff8001?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x&y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&",0xfffffffe,0xffff8000,(signed short)(x&y)==0xffff8000?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x&y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&",0xffffffff,0xffff8001,(signed short)(x&y)==0xffff8001?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&",0x0,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&",0x1,0x1,(signed short)(x&y)==0x1?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&",0x2,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&",0x7ffe,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&",0x7fff,0x1,(signed short)(x&y)==0x1?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x&y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&",0xfffffffe,0xfffffffe,(signed short)(x&y)==0xfffffffe?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x&y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&",0xffffffff,0xfffffffe,(signed short)(x&y)==0xfffffffe?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&",0x0,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&",0x1,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x&y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&",0x2,0x2,(signed short)(x&y)==0x2?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x&y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&",0x7ffe,0x7ffe,(signed short)(x&y)==0x7ffe?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x&y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&",0x7fff,0x7ffe,(signed short)(x&y)==0x7ffe?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x&y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&",0xffffffff,0xffffffff,(signed short)(x&y)==0xffffffff?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&",0x0,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&",0x1,0x1,(signed short)(x&y)==0x1?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x&y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&",0x2,0x2,(signed short)(x&y)==0x2?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x&y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&",0x7ffe,0x7ffe,(signed short)(x&y)==0x7ffe?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x&y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&",0x7fff,0x7fff,(signed short)(x&y)==0x7fff?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&",0x0,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&",0x1,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&",0x2,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&",0x7ffe,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&",0x7fff,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"&",0x1,0x1,(signed short)(x&y)==0x1?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"&",0x2,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"&",0x7ffe,0x0,(signed short)(x&y)==0x0?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"&",0x7fff,0x1,(signed short)(x&y)==0x1?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x&y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"&",0x2,0x2,(signed short)(x&y)==0x2?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x&y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"&",0x7ffe,0x2,(signed short)(x&y)==0x2?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x&y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"&",0x7fff,0x2,(signed short)(x&y)==0x2?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x&y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"&",0x7ffe,0x7ffe,(signed short)(x&y)==0x7ffe?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x&y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"&",0x7fff,0x7ffe,(signed short)(x&y)==0x7ffe?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x&y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"&",0x7fff,0x7fff,(signed short)(x&y)==0x7fff?"PASS":"FAIL",(signed short)(x&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x|y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"|",0xffff8000,0xffff8000,(signed short)(x|y)==0xffff8000?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x|y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"|",0xffff8001,0xffff8001,(signed short)(x|y)==0xffff8001?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x|y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"|",0xfffffffe,0xfffffffe,(signed short)(x|y)==0xfffffffe?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"|",0xffffffff,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x|y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"|",0x0,0xffff8000,(signed short)(x|y)==0xffff8000?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x|y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"|",0x1,0xffff8001,(signed short)(x|y)==0xffff8001?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x|y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"|",0x2,0xffff8002,(signed short)(x|y)==0xffff8002?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x|y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"|",0x7ffe,0xfffffffe,(signed short)(x|y)==0xfffffffe?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"|",0x7fff,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x|y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"|",0xffff8001,0xffff8001,(signed short)(x|y)==0xffff8001?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"|",0xfffffffe,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"|",0xffffffff,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x|y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"|",0x0,0xffff8001,(signed short)(x|y)==0xffff8001?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x|y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"|",0x1,0xffff8001,(signed short)(x|y)==0xffff8001?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x|y)!=(signed short)-32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"|",0x2,0xffff8003,(signed short)(x|y)==0xffff8003?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"|",0x7ffe,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"|",0x7fff,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x|y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"|",0xfffffffe,0xfffffffe,(signed short)(x|y)==0xfffffffe?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"|",0xffffffff,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x|y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"|",0x0,0xfffffffe,(signed short)(x|y)==0xfffffffe?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"|",0x1,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x|y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"|",0x2,0xfffffffe,(signed short)(x|y)==0xfffffffe?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x|y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"|",0x7ffe,0xfffffffe,(signed short)(x|y)==0xfffffffe?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"|",0x7fff,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"|",0xffffffff,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"|",0x0,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"|",0x1,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"|",0x2,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"|",0x7ffe,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x|y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"|",0x7fff,0xffffffff,(signed short)(x|y)==0xffffffff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x|y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"|",0x0,0x0,(signed short)(x|y)==0x0?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x|y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"|",0x1,0x1,(signed short)(x|y)==0x1?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x|y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"|",0x2,0x2,(signed short)(x|y)==0x2?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x|y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"|",0x7ffe,0x7ffe,(signed short)(x|y)==0x7ffe?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x|y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"|",0x7fff,0x7fff,(signed short)(x|y)==0x7fff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x|y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"|",0x1,0x1,(signed short)(x|y)==0x1?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x|y)!=(signed short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"|",0x2,0x3,(signed short)(x|y)==0x3?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x|y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"|",0x7ffe,0x7fff,(signed short)(x|y)==0x7fff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x|y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"|",0x7fff,0x7fff,(signed short)(x|y)==0x7fff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x|y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"|",0x2,0x2,(signed short)(x|y)==0x2?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x|y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"|",0x7ffe,0x7ffe,(signed short)(x|y)==0x7ffe?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x|y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"|",0x7fff,0x7fff,(signed short)(x|y)==0x7fff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x|y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"|",0x7ffe,0x7ffe,(signed short)(x|y)==0x7ffe?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x|y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"|",0x7fff,0x7fff,(signed short)(x|y)==0x7fff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x|y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"|",0x7fff,0x7fff,(signed short)(x|y)==0x7fff?"PASS":"FAIL",(signed short)(x|y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x< %s (%d)\n",__LINE__,"signed short",0xffff8000,"<<",0x0,0xffff8000,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xffff8000,"<<",0x1,0x0,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xffff8000,"<<",0x2,0x0,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xffff8001,"<<",0x0,0xffff8001,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xffff8001,"<<",0x1,0x2,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xffff8001,"<<",0x2,0x4,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<<",0x0,0xfffffffe,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<<",0x1,0xfffffffc,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<<",0x2,0xfffffff8,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xffffffff,"<<",0x0,0xffffffff,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xffffffff,"<<",0x1,0xfffffffe,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0xffffffff,"<<",0x2,0xfffffffc,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0x0,"<<",0x0,0x0,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0x0,"<<",0x1,0x0,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0x0,"<<",0x2,0x0,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0x1,"<<",0x1,0x2,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0x1,"<<",0x2,0x4,(signed short)(x< %s (%d)\n",__LINE__,"signed short",0x2,"<<",0x2,0x8,(signed short)(x<>y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">>",0x0,0xffff8000,(signed short)(x>>y)==0xffff8000?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x>>y)!=(signed short)-16384) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">>",0x1,0xffffc000,(signed short)(x>>y)==0xffffc000?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x>>y)!=(signed short)-8192) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">>",0x2,0xffffe000,(signed short)(x>>y)==0xffffe000?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x>>y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">>",0x0,0xffff8001,(signed short)(x>>y)==0xffff8001?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x>>y)!=(signed short)-16384) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">>",0x1,0xffffc000,(signed short)(x>>y)==0xffffc000?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x>>y)!=(signed short)-8192) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">>",0x2,0xffffe000,(signed short)(x>>y)==0xffffe000?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x>>y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">>",0x0,0xfffffffe,(signed short)(x>>y)==0xfffffffe?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x>>y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">>",0x1,0xffffffff,(signed short)(x>>y)==0xffffffff?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x>>y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">>",0x2,0xffffffff,(signed short)(x>>y)==0xffffffff?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x>>y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">>",0x0,0xffffffff,(signed short)(x>>y)==0xffffffff?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x>>y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">>",0x1,0xffffffff,(signed short)(x>>y)==0xffffffff?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x>>y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">>",0x2,0xffffffff,(signed short)(x>>y)==0xffffffff?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x>>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">>",0x0,0x0,(signed short)(x>>y)==0x0?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x>>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">>",0x1,0x0,(signed short)(x>>y)==0x0?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x>>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">>",0x2,0x0,(signed short)(x>>y)==0x0?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x>>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">>",0x1,0x0,(signed short)(x>>y)==0x0?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x>>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">>",0x2,0x0,(signed short)(x>>y)==0x0?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x>>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,">>",0x2,0x0,(signed short)(x>>y)==0x0?"PASS":"FAIL",(signed short)(x>>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&&",0xffff8000,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&&",0xffff8001,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&&",0xfffffffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&&",0xffffffff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x&&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&&",0x0,0x0,(signed short)(x&&y)==0x0?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&&",0x1,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&&",0x2,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&&",0x7ffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"&&",0x7fff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&&",0xffff8001,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&&",0xfffffffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&&",0xffffffff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x&&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&&",0x0,0x0,(signed short)(x&&y)==0x0?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&&",0x1,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&&",0x2,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&&",0x7ffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"&&",0x7fff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&&",0xfffffffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&&",0xffffffff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x&&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&&",0x0,0x0,(signed short)(x&&y)==0x0?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&&",0x1,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&&",0x2,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&&",0x7ffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"&&",0x7fff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&&",0xffffffff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x&&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&&",0x0,0x0,(signed short)(x&&y)==0x0?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&&",0x1,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&&",0x2,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&&",0x7ffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"&&",0x7fff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x&&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&&",0x0,0x0,(signed short)(x&&y)==0x0?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x&&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&&",0x1,0x0,(signed short)(x&&y)==0x0?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x&&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&&",0x2,0x0,(signed short)(x&&y)==0x0?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x&&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&&",0x7ffe,0x0,(signed short)(x&&y)==0x0?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x&&y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"&&",0x7fff,0x0,(signed short)(x&&y)==0x0?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"&&",0x1,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"&&",0x2,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"&&",0x7ffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"&&",0x7fff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"&&",0x2,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"&&",0x7ffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"&&",0x7fff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"&&",0x7ffe,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"&&",0x7fff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x&&y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"&&",0x7fff,0x1,(signed short)(x&&y)==0x1?"PASS":"FAIL",(signed short)(x&&y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"||",0xffff8000,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"||",0xffff8001,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"||",0xfffffffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"||",0xffffffff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"||",0x0,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"||",0x1,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"||",0x2,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"||",0x7ffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"||",0x7fff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"||",0xffff8001,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"||",0xfffffffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"||",0xffffffff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"||",0x0,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"||",0x1,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"||",0x2,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"||",0x7ffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"||",0x7fff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"||",0xfffffffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"||",0xffffffff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"||",0x0,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"||",0x1,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"||",0x2,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"||",0x7ffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"||",0x7fff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"||",0xffffffff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"||",0x0,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"||",0x1,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"||",0x2,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"||",0x7ffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"||",0x7fff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x||y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"||",0x0,0x0,(signed short)(x||y)==0x0?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"||",0x1,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"||",0x2,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"||",0x7ffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"||",0x7fff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"||",0x1,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"||",0x2,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"||",0x7ffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"||",0x7fff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"||",0x2,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"||",0x7ffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"||",0x7fff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"||",0x7ffe,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"||",0x7fff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x||y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"||",0x7fff,0x1,(signed short)(x||y)==0x1?"PASS":"FAIL",(signed short)(x||y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">",0xffff8000,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">",0xffff8001,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">",0xfffffffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">",0xffffffff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">",0x0,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">",0x1,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">",0x2,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">",0x7ffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">",0x7fff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">",0xffff8001,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">",0xfffffffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">",0xffffffff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">",0x0,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">",0x1,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">",0x2,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">",0x7ffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">",0x7fff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">",0xfffffffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">",0xffffffff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">",0x0,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">",0x1,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">",0x2,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">",0x7ffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">",0x7fff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">",0xffffffff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">",0x0,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">",0x1,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">",0x2,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">",0x7ffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">",0x7fff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">",0x0,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">",0x1,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">",0x2,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">",0x7ffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">",0x7fff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">",0x1,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">",0x2,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">",0x7ffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">",0x7fff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,">",0x2,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,">",0x7ffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,">",0x7fff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,">",0x7ffe,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,">",0x7fff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x>y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,">",0x7fff,0x0,(signed short)(x>y)==0x0?"PASS":"FAIL",(signed short)(x>y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8000,"<",0xffff8000,0x0,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8000,"<",0xffff8001,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8000,"<",0xfffffffe,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8000,"<",0xffffffff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8000,"<",0x0,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8000,"<",0x1,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8000,"<",0x2,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8000,"<",0x7ffe,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8000,"<",0x7fff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8001,"<",0xffff8001,0x0,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8001,"<",0xfffffffe,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8001,"<",0xffffffff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8001,"<",0x0,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8001,"<",0x1,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8001,"<",0x2,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8001,"<",0x7ffe,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffff8001,"<",0x7fff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<",0xfffffffe,0x0,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<",0xffffffff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<",0x0,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<",0x1,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<",0x2,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<",0x7ffe,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<",0x7fff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffffffff,"<",0xffffffff,0x0,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffffffff,"<",0x0,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffffffff,"<",0x1,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffffffff,"<",0x2,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffffffff,"<",0x7ffe,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0xffffffff,"<",0x7fff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x0,"<",0x0,0x0,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x0,"<",0x1,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x0,"<",0x2,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x0,"<",0x7ffe,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x0,"<",0x7fff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x1,"<",0x1,0x0,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x1,"<",0x2,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x1,"<",0x7ffe,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x1,"<",0x7fff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x2,"<",0x2,0x0,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x2,"<",0x7ffe,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x2,"<",0x7fff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x7ffe,"<",0x7ffe,0x0,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x7ffe,"<",0x7fff,0x1,(signed short)(x %s (%d)\n",__LINE__,"signed short",0x7fff,"<",0x7fff,0x0,(signed short)(x=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">=",0xffff8000,0x1,(signed short)(x>=y)==0x1?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">=",0xffff8001,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">=",0xfffffffe,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">=",0xffffffff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">=",0x0,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">=",0x1,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">=",0x2,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">=",0x7ffe,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,">=",0x7fff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x>=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">=",0xffff8001,0x1,(signed short)(x>=y)==0x1?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">=",0xfffffffe,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">=",0xffffffff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">=",0x0,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">=",0x1,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">=",0x2,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">=",0x7ffe,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,">=",0x7fff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x>=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">=",0xfffffffe,0x1,(signed short)(x>=y)==0x1?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">=",0xffffffff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">=",0x0,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">=",0x1,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">=",0x2,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">=",0x7ffe,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,">=",0x7fff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x>=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">=",0xffffffff,0x1,(signed short)(x>=y)==0x1?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">=",0x0,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">=",0x1,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">=",0x2,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">=",0x7ffe,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,">=",0x7fff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x>=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">=",0x0,0x1,(signed short)(x>=y)==0x1?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">=",0x1,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">=",0x2,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">=",0x7ffe,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,">=",0x7fff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x>=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">=",0x1,0x1,(signed short)(x>=y)==0x1?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">=",0x2,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">=",0x7ffe,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,">=",0x7fff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x>=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,">=",0x2,0x1,(signed short)(x>=y)==0x1?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,">=",0x7ffe,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,">=",0x7fff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x>=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,">=",0x7ffe,0x1,(signed short)(x>=y)==0x1?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x>=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,">=",0x7fff,0x0,(signed short)(x>=y)==0x0?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x>=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,">=",0x7fff,0x1,(signed short)(x>=y)==0x1?"PASS":"FAIL",(signed short)(x>=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"<=",0xffff8000,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"<=",0xffff8001,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"<=",0xfffffffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"<=",0xffffffff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"<=",0x0,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"<=",0x1,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"<=",0x2,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"<=",0x7ffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"<=",0x7fff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"<=",0xffff8001,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"<=",0xfffffffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"<=",0xffffffff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"<=",0x0,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"<=",0x1,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"<=",0x2,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"<=",0x7ffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"<=",0x7fff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<=",0xfffffffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<=",0xffffffff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<=",0x0,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<=",0x1,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<=",0x2,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<=",0x7ffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"<=",0x7fff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"<=",0xffffffff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"<=",0x0,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"<=",0x1,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"<=",0x2,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"<=",0x7ffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"<=",0x7fff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"<=",0x0,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"<=",0x1,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"<=",0x2,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"<=",0x7ffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"<=",0x7fff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"<=",0x1,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"<=",0x2,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"<=",0x7ffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"<=",0x7fff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"<=",0x2,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"<=",0x7ffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"<=",0x7fff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"<=",0x7ffe,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"<=",0x7fff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x<=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"<=",0x7fff,0x1,(signed short)(x<=y)==0x1?"PASS":"FAIL",(signed short)(x<=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x==y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"==",0xffff8000,0x1,(signed short)(x==y)==0x1?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"==",0xffff8001,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"==",0xfffffffe,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"==",0xffffffff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"==",0x0,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"==",0x1,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"==",0x2,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"==",0x7ffe,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"==",0x7fff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x==y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"==",0xffff8001,0x1,(signed short)(x==y)==0x1?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"==",0xfffffffe,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"==",0xffffffff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"==",0x0,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"==",0x1,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"==",0x2,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"==",0x7ffe,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"==",0x7fff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x==y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"==",0xfffffffe,0x1,(signed short)(x==y)==0x1?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"==",0xffffffff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"==",0x0,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"==",0x1,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"==",0x2,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"==",0x7ffe,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"==",0x7fff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x==y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"==",0xffffffff,0x1,(signed short)(x==y)==0x1?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"==",0x0,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"==",0x1,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"==",0x2,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"==",0x7ffe,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"==",0x7fff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x==y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"==",0x0,0x1,(signed short)(x==y)==0x1?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"==",0x1,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"==",0x2,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"==",0x7ffe,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"==",0x7fff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x==y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"==",0x1,0x1,(signed short)(x==y)==0x1?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"==",0x2,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"==",0x7ffe,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"==",0x7fff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x==y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"==",0x2,0x1,(signed short)(x==y)==0x1?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"==",0x7ffe,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"==",0x7fff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x==y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"==",0x7ffe,0x1,(signed short)(x==y)==0x1?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x==y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"==",0x7fff,0x0,(signed short)(x==y)==0x0?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x==y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"==",0x7fff,0x1,(signed short)(x==y)==0x1?"PASS":"FAIL",(signed short)(x==y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x!=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"!=",0xffff8000,0x0,(signed short)(x!=y)==0x0?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"!=",0xffff8001,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"!=",0xfffffffe,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"!=",0xffffffff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"!=",0x0,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"!=",0x1,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"!=",0x2,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"!=",0x7ffe,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"!=",0x7fff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x!=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"!=",0xffff8001,0x0,(signed short)(x!=y)==0x0?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"!=",0xfffffffe,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"!=",0xffffffff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"!=",0x0,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"!=",0x1,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"!=",0x2,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"!=",0x7ffe,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"!=",0x7fff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x!=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"!=",0xfffffffe,0x0,(signed short)(x!=y)==0x0?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"!=",0xffffffff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"!=",0x0,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"!=",0x1,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"!=",0x2,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"!=",0x7ffe,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"!=",0x7fff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x!=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"!=",0xffffffff,0x0,(signed short)(x!=y)==0x0?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"!=",0x0,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"!=",0x1,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"!=",0x2,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"!=",0x7ffe,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"!=",0x7fff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x!=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"!=",0x0,0x0,(signed short)(x!=y)==0x0?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"!=",0x1,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"!=",0x2,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"!=",0x7ffe,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"!=",0x7fff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x!=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"!=",0x1,0x0,(signed short)(x!=y)==0x0?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"!=",0x2,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"!=",0x7ffe,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"!=",0x7fff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x!=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"!=",0x2,0x0,(signed short)(x!=y)==0x0?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"!=",0x7ffe,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"!=",0x7fff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x!=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"!=",0x7ffe,0x0,(signed short)(x!=y)==0x0?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x!=y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"!=",0x7fff,0x1,(signed short)(x!=y)==0x1?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x!=y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"!=",0x7fff,0x0,(signed short)(x!=y)==0x0?"PASS":"FAIL",(signed short)(x!=y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"*",0xffff8000,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x*y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"*",0xffff8001,0xffff8000,(signed short)(x*y)==0xffff8000?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"*",0xfffffffe,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x*y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"*",0xffffffff,0xffff8000,(signed short)(x*y)==0xffff8000?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=0; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"*",0x0,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x*y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"*",0x1,0xffff8000,(signed short)(x*y)==0xffff8000?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"*",0x2,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"*",0x7ffe,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x*y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"*",0x7fff,0xffff8000,(signed short)(x*y)==0xffff8000?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x*y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"*",0xffff8001,0x1,(signed short)(x*y)==0x1?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x*y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"*",0xfffffffe,0xfffffffe,(signed short)(x*y)==0xfffffffe?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x*y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"*",0xffffffff,0x7fff,(signed short)(x*y)==0x7fff?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=0; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"*",0x0,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x*y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"*",0x1,0xffff8001,(signed short)(x*y)==0xffff8001?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x*y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"*",0x2,0x2,(signed short)(x*y)==0x2?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x*y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"*",0x7ffe,0x7ffe,(signed short)(x*y)==0x7ffe?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x*y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"*",0x7fff,0xffffffff,(signed short)(x*y)==0xffffffff?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x*y)!=(signed short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"*",0xfffffffe,0x4,(signed short)(x*y)==0x4?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x*y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"*",0xffffffff,0x2,(signed short)(x*y)==0x2?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=0; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"*",0x0,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x*y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"*",0x1,0xfffffffe,(signed short)(x*y)==0xfffffffe?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x*y)!=(signed short)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"*",0x2,0xfffffffc,(signed short)(x*y)==0xfffffffc?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x*y)!=(signed short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"*",0x7ffe,0x4,(signed short)(x*y)==0x4?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x*y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"*",0x7fff,0x2,(signed short)(x*y)==0x2?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x*y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"*",0xffffffff,0x1,(signed short)(x*y)==0x1?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=0; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"*",0x0,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x*y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"*",0x1,0xffffffff,(signed short)(x*y)==0xffffffff?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x*y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"*",0x2,0xfffffffe,(signed short)(x*y)==0xfffffffe?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x*y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"*",0x7ffe,0xffff8002,(signed short)(x*y)==0xffff8002?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x*y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"*",0x7fff,0xffff8001,(signed short)(x*y)==0xffff8001?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=0; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"*",0x0,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"*",0x1,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"*",0x2,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"*",0x7ffe,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x*y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"*",0x7fff,0x0,(signed short)(x*y)==0x0?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x*y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"*",0x1,0x1,(signed short)(x*y)==0x1?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x*y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"*",0x2,0x2,(signed short)(x*y)==0x2?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x*y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"*",0x7ffe,0x7ffe,(signed short)(x*y)==0x7ffe?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x*y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"*",0x7fff,0x7fff,(signed short)(x*y)==0x7fff?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x*y)!=(signed short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"*",0x2,0x4,(signed short)(x*y)==0x4?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x*y)!=(signed short)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"*",0x7ffe,0xfffffffc,(signed short)(x*y)==0xfffffffc?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x*y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"*",0x7fff,0xfffffffe,(signed short)(x*y)==0xfffffffe?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x*y)!=(signed short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"*",0x7ffe,0x4,(signed short)(x*y)==0x4?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x*y)!=(signed short)-32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"*",0x7fff,0xffff8002,(signed short)(x*y)==0xffff8002?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x*y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"*",0x7fff,0x1,(signed short)(x*y)==0x1?"PASS":"FAIL",(signed short)(x*y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x/y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"/",0xffff8000,0x1,(signed short)(x/y)==0x1?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x/y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"/",0xffff8001,0x1,(signed short)(x/y)==0x1?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x/y)!=(signed short)16384) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"/",0xfffffffe,0x4000,(signed short)(x/y)==0x4000?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x/y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"/",0xffffffff,0xffff8000,(signed short)(x/y)==0xffff8000?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x/y)!=(signed short)-32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"/",0x1,0xffff8000,(signed short)(x/y)==0xffff8000?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x/y)!=(signed short)-16384) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"/",0x2,0xffffc000,(signed short)(x/y)==0xffffc000?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x/y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"/",0x7ffe,0xffffffff,(signed short)(x/y)==0xffffffff?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x/y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"/",0x7fff,0xffffffff,(signed short)(x/y)==0xffffffff?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x/y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"/",0xffff8001,0x1,(signed short)(x/y)==0x1?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x/y)!=(signed short)16383) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"/",0xfffffffe,0x3fff,(signed short)(x/y)==0x3fff?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x/y)!=(signed short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"/",0xffffffff,0x7fff,(signed short)(x/y)==0x7fff?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x/y)!=(signed short)-32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"/",0x1,0xffff8001,(signed short)(x/y)==0xffff8001?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x/y)!=(signed short)-16383) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"/",0x2,0xffffc001,(signed short)(x/y)==0xffffc001?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x/y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"/",0x7ffe,0xffffffff,(signed short)(x/y)==0xffffffff?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x/y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"/",0x7fff,0xffffffff,(signed short)(x/y)==0xffffffff?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x/y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"/",0xfffffffe,0x1,(signed short)(x/y)==0x1?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x/y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"/",0xffffffff,0x2,(signed short)(x/y)==0x2?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x/y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"/",0x1,0xfffffffe,(signed short)(x/y)==0xfffffffe?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x/y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"/",0x2,0xffffffff,(signed short)(x/y)==0xffffffff?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"/",0x7ffe,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"/",0x7fff,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x/y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"/",0xffffffff,0x1,(signed short)(x/y)==0x1?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x/y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"/",0x1,0xffffffff,(signed short)(x/y)==0xffffffff?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"/",0x2,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"/",0x7ffe,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"/",0x7fff,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"/",0x1,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"/",0x2,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"/",0x7ffe,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"/",0x7fff,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x/y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"/",0x1,0x1,(signed short)(x/y)==0x1?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"/",0x2,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"/",0x7ffe,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"/",0x7fff,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x/y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"/",0x2,0x1,(signed short)(x/y)==0x1?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"/",0x7ffe,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"/",0x7fff,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x/y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"/",0x7ffe,0x1,(signed short)(x/y)==0x1?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x/y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"/",0x7fff,0x0,(signed short)(x/y)==0x0?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x/y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"/",0x7fff,0x1,(signed short)(x/y)==0x1?"PASS":"FAIL",(signed short)(x/y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32768; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"%",0xffff8000,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-32767; + if ((signed short)(x%y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"%",0xffff8001,0xffffffff,(signed short)(x%y)==0xffffffff?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-2; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"%",0xfffffffe,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=-1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"%",0xffffffff,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"%",0x1,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=2; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"%",0x2,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32766; + if ((signed short)(x%y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"%",0x7ffe,0xfffffffe,(signed short)(x%y)==0xfffffffe?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32768; volatile signed short y=32767; + if ((signed short)(x%y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8000,"%",0x7fff,0xffffffff,(signed short)(x%y)==0xffffffff?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-32767; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"%",0xffff8001,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-2; + if ((signed short)(x%y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"%",0xfffffffe,0xffffffff,(signed short)(x%y)==0xffffffff?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=-1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"%",0xffffffff,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"%",0x1,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=2; + if ((signed short)(x%y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"%",0x2,0xffffffff,(signed short)(x%y)==0xffffffff?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32766; + if ((signed short)(x%y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"%",0x7ffe,0xffffffff,(signed short)(x%y)==0xffffffff?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-32767; volatile signed short y=32767; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffff8001,"%",0x7fff,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-2; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"%",0xfffffffe,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=-1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"%",0xffffffff,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"%",0x1,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=2; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"%",0x2,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32766; + if ((signed short)(x%y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"%",0x7ffe,0xfffffffe,(signed short)(x%y)==0xfffffffe?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-2; volatile signed short y=32767; + if ((signed short)(x%y)!=(signed short)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xfffffffe,"%",0x7fff,0xfffffffe,(signed short)(x%y)==0xfffffffe?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=-1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"%",0xffffffff,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"%",0x1,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=2; + if ((signed short)(x%y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"%",0x2,0xffffffff,(signed short)(x%y)==0xffffffff?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32766; + if ((signed short)(x%y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"%",0x7ffe,0xffffffff,(signed short)(x%y)==0xffffffff?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=-1; volatile signed short y=32767; + if ((signed short)(x%y)!=(signed short)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0xffffffff,"%",0x7fff,0xffffffff,(signed short)(x%y)==0xffffffff?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"%",0x1,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=2; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"%",0x2,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32766; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"%",0x7ffe,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=0; volatile signed short y=32767; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x0,"%",0x7fff,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=1; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"%",0x1,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=2; + if ((signed short)(x%y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"%",0x2,0x1,(signed short)(x%y)==0x1?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32766; + if ((signed short)(x%y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"%",0x7ffe,0x1,(signed short)(x%y)==0x1?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=1; volatile signed short y=32767; + if ((signed short)(x%y)!=(signed short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x1,"%",0x7fff,0x1,(signed short)(x%y)==0x1?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=2; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"%",0x2,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32766; + if ((signed short)(x%y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"%",0x7ffe,0x2,(signed short)(x%y)==0x2?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=2; volatile signed short y=32767; + if ((signed short)(x%y)!=(signed short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x2,"%",0x7fff,0x2,(signed short)(x%y)==0x2?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32766; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"%",0x7ffe,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=32766; volatile signed short y=32767; + if ((signed short)(x%y)!=(signed short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7ffe,"%",0x7fff,0x7ffe,(signed short)(x%y)==0x7ffe?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed short x=32767; volatile signed short y=32767; + if ((signed short)(x%y)!=(signed short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed short",0x7fff,"%",0x7fff,0x0,(signed short)(x%y)==0x0?"PASS":"FAIL",(signed short)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x+y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"+",0xffffff80,0x0,(signed char)(x+y)==0x0?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x+y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"+",0xffffff81,0x1,(signed char)(x+y)==0x1?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x+y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"+",0xfffffffe,0x7e,(signed char)(x+y)==0x7e?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x+y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"+",0xffffffff,0x7f,(signed char)(x+y)==0x7f?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x+y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"+",0x0,0xffffff80,(signed char)(x+y)==0xffffff80?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x+y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"+",0x1,0xffffff81,(signed char)(x+y)==0xffffff81?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x+y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"+",0x2,0xffffff82,(signed char)(x+y)==0xffffff82?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x+y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"+",0x7e,0xfffffffe,(signed char)(x+y)==0xfffffffe?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x+y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"+",0x7f,0xffffffff,(signed char)(x+y)==0xffffffff?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x+y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"+",0xffffff81,0x2,(signed char)(x+y)==0x2?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x+y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"+",0xfffffffe,0x7f,(signed char)(x+y)==0x7f?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x+y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"+",0xffffffff,0xffffff80,(signed char)(x+y)==0xffffff80?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x+y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"+",0x0,0xffffff81,(signed char)(x+y)==0xffffff81?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x+y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"+",0x1,0xffffff82,(signed char)(x+y)==0xffffff82?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x+y)!=(signed char)-125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"+",0x2,0xffffff83,(signed char)(x+y)==0xffffff83?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x+y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"+",0x7e,0xffffffff,(signed char)(x+y)==0xffffffff?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x+y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"+",0x7f,0x0,(signed char)(x+y)==0x0?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x+y)!=(signed char)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"+",0xfffffffe,0xfffffffc,(signed char)(x+y)==0xfffffffc?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x+y)!=(signed char)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"+",0xffffffff,0xfffffffd,(signed char)(x+y)==0xfffffffd?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x+y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"+",0x0,0xfffffffe,(signed char)(x+y)==0xfffffffe?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x+y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"+",0x1,0xffffffff,(signed char)(x+y)==0xffffffff?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x+y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"+",0x2,0x0,(signed char)(x+y)==0x0?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x+y)!=(signed char)124) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"+",0x7e,0x7c,(signed char)(x+y)==0x7c?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x+y)!=(signed char)125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"+",0x7f,0x7d,(signed char)(x+y)==0x7d?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x+y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"+",0xffffffff,0xfffffffe,(signed char)(x+y)==0xfffffffe?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x+y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"+",0x0,0xffffffff,(signed char)(x+y)==0xffffffff?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x+y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"+",0x1,0x0,(signed char)(x+y)==0x0?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x+y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"+",0x2,0x1,(signed char)(x+y)==0x1?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x+y)!=(signed char)125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"+",0x7e,0x7d,(signed char)(x+y)==0x7d?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x+y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"+",0x7f,0x7e,(signed char)(x+y)==0x7e?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x+y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"+",0x0,0x0,(signed char)(x+y)==0x0?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x+y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"+",0x1,0x1,(signed char)(x+y)==0x1?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x+y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"+",0x2,0x2,(signed char)(x+y)==0x2?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x+y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"+",0x7e,0x7e,(signed char)(x+y)==0x7e?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x+y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"+",0x7f,0x7f,(signed char)(x+y)==0x7f?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x+y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"+",0x1,0x2,(signed char)(x+y)==0x2?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x+y)!=(signed char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"+",0x2,0x3,(signed char)(x+y)==0x3?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x+y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"+",0x7e,0x7f,(signed char)(x+y)==0x7f?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x+y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"+",0x7f,0xffffff80,(signed char)(x+y)==0xffffff80?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x+y)!=(signed char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"+",0x2,0x4,(signed char)(x+y)==0x4?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x+y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"+",0x7e,0xffffff80,(signed char)(x+y)==0xffffff80?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x+y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"+",0x7f,0xffffff81,(signed char)(x+y)==0xffffff81?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x+y)!=(signed char)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"+",0x7e,0xfffffffc,(signed char)(x+y)==0xfffffffc?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x+y)!=(signed char)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"+",0x7f,0xfffffffd,(signed char)(x+y)==0xfffffffd?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x+y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"+",0x7f,0xfffffffe,(signed char)(x+y)==0xfffffffe?"PASS":"FAIL",(signed char)(x+y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x-y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"-",0xffffff80,0x0,(signed char)(x-y)==0x0?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x-y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"-",0xffffff81,0xffffffff,(signed char)(x-y)==0xffffffff?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x-y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"-",0xfffffffe,0xffffff82,(signed char)(x-y)==0xffffff82?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x-y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"-",0xffffffff,0xffffff81,(signed char)(x-y)==0xffffff81?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x-y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"-",0x0,0xffffff80,(signed char)(x-y)==0xffffff80?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x-y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"-",0x1,0x7f,(signed char)(x-y)==0x7f?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x-y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"-",0x2,0x7e,(signed char)(x-y)==0x7e?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x-y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"-",0x7e,0x2,(signed char)(x-y)==0x2?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x-y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"-",0x7f,0x1,(signed char)(x-y)==0x1?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x-y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"-",0xffffff81,0x0,(signed char)(x-y)==0x0?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x-y)!=(signed char)-125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"-",0xfffffffe,0xffffff83,(signed char)(x-y)==0xffffff83?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x-y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"-",0xffffffff,0xffffff82,(signed char)(x-y)==0xffffff82?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x-y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"-",0x0,0xffffff81,(signed char)(x-y)==0xffffff81?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x-y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"-",0x1,0xffffff80,(signed char)(x-y)==0xffffff80?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x-y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"-",0x2,0x7f,(signed char)(x-y)==0x7f?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x-y)!=(signed char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"-",0x7e,0x3,(signed char)(x-y)==0x3?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x-y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"-",0x7f,0x2,(signed char)(x-y)==0x2?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x-y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"-",0xfffffffe,0x0,(signed char)(x-y)==0x0?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x-y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"-",0xffffffff,0xffffffff,(signed char)(x-y)==0xffffffff?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x-y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"-",0x0,0xfffffffe,(signed char)(x-y)==0xfffffffe?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x-y)!=(signed char)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"-",0x1,0xfffffffd,(signed char)(x-y)==0xfffffffd?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x-y)!=(signed char)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"-",0x2,0xfffffffc,(signed char)(x-y)==0xfffffffc?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x-y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"-",0x7e,0xffffff80,(signed char)(x-y)==0xffffff80?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x-y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"-",0x7f,0x7f,(signed char)(x-y)==0x7f?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x-y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"-",0xffffffff,0x0,(signed char)(x-y)==0x0?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x-y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"-",0x0,0xffffffff,(signed char)(x-y)==0xffffffff?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x-y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"-",0x1,0xfffffffe,(signed char)(x-y)==0xfffffffe?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x-y)!=(signed char)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"-",0x2,0xfffffffd,(signed char)(x-y)==0xfffffffd?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x-y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"-",0x7e,0xffffff81,(signed char)(x-y)==0xffffff81?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x-y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"-",0x7f,0xffffff80,(signed char)(x-y)==0xffffff80?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x-y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"-",0x0,0x0,(signed char)(x-y)==0x0?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x-y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"-",0x1,0xffffffff,(signed char)(x-y)==0xffffffff?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x-y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"-",0x2,0xfffffffe,(signed char)(x-y)==0xfffffffe?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x-y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"-",0x7e,0xffffff82,(signed char)(x-y)==0xffffff82?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x-y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"-",0x7f,0xffffff81,(signed char)(x-y)==0xffffff81?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x-y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"-",0x1,0x0,(signed char)(x-y)==0x0?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x-y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"-",0x2,0xffffffff,(signed char)(x-y)==0xffffffff?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x-y)!=(signed char)-125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"-",0x7e,0xffffff83,(signed char)(x-y)==0xffffff83?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x-y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"-",0x7f,0xffffff82,(signed char)(x-y)==0xffffff82?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x-y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"-",0x2,0x0,(signed char)(x-y)==0x0?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x-y)!=(signed char)-124) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"-",0x7e,0xffffff84,(signed char)(x-y)==0xffffff84?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x-y)!=(signed char)-125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"-",0x7f,0xffffff83,(signed char)(x-y)==0xffffff83?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x-y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"-",0x7e,0x0,(signed char)(x-y)==0x0?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x-y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"-",0x7f,0xffffffff,(signed char)(x-y)==0xffffffff?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x-y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"-",0x7f,0x0,(signed char)(x-y)==0x0?"PASS":"FAIL",(signed char)(x-y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x^y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"^",0xffffff80,0x0,(signed char)(x^y)==0x0?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x^y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"^",0xffffff81,0x1,(signed char)(x^y)==0x1?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x^y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"^",0xfffffffe,0x7e,(signed char)(x^y)==0x7e?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x^y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"^",0xffffffff,0x7f,(signed char)(x^y)==0x7f?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x^y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"^",0x0,0xffffff80,(signed char)(x^y)==0xffffff80?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x^y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"^",0x1,0xffffff81,(signed char)(x^y)==0xffffff81?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x^y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"^",0x2,0xffffff82,(signed char)(x^y)==0xffffff82?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x^y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"^",0x7e,0xfffffffe,(signed char)(x^y)==0xfffffffe?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x^y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"^",0x7f,0xffffffff,(signed char)(x^y)==0xffffffff?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x^y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"^",0xffffff81,0x0,(signed char)(x^y)==0x0?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x^y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"^",0xfffffffe,0x7f,(signed char)(x^y)==0x7f?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x^y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"^",0xffffffff,0x7e,(signed char)(x^y)==0x7e?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x^y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"^",0x0,0xffffff81,(signed char)(x^y)==0xffffff81?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x^y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"^",0x1,0xffffff80,(signed char)(x^y)==0xffffff80?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x^y)!=(signed char)-125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"^",0x2,0xffffff83,(signed char)(x^y)==0xffffff83?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x^y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"^",0x7e,0xffffffff,(signed char)(x^y)==0xffffffff?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x^y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"^",0x7f,0xfffffffe,(signed char)(x^y)==0xfffffffe?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x^y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"^",0xfffffffe,0x0,(signed char)(x^y)==0x0?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x^y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"^",0xffffffff,0x1,(signed char)(x^y)==0x1?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x^y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"^",0x0,0xfffffffe,(signed char)(x^y)==0xfffffffe?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x^y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"^",0x1,0xffffffff,(signed char)(x^y)==0xffffffff?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x^y)!=(signed char)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"^",0x2,0xfffffffc,(signed char)(x^y)==0xfffffffc?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x^y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"^",0x7e,0xffffff80,(signed char)(x^y)==0xffffff80?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x^y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"^",0x7f,0xffffff81,(signed char)(x^y)==0xffffff81?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x^y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"^",0xffffffff,0x0,(signed char)(x^y)==0x0?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x^y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"^",0x0,0xffffffff,(signed char)(x^y)==0xffffffff?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x^y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"^",0x1,0xfffffffe,(signed char)(x^y)==0xfffffffe?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x^y)!=(signed char)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"^",0x2,0xfffffffd,(signed char)(x^y)==0xfffffffd?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x^y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"^",0x7e,0xffffff81,(signed char)(x^y)==0xffffff81?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x^y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"^",0x7f,0xffffff80,(signed char)(x^y)==0xffffff80?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x^y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"^",0x0,0x0,(signed char)(x^y)==0x0?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x^y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"^",0x1,0x1,(signed char)(x^y)==0x1?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x^y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"^",0x2,0x2,(signed char)(x^y)==0x2?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x^y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"^",0x7e,0x7e,(signed char)(x^y)==0x7e?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x^y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"^",0x7f,0x7f,(signed char)(x^y)==0x7f?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x^y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"^",0x1,0x0,(signed char)(x^y)==0x0?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x^y)!=(signed char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"^",0x2,0x3,(signed char)(x^y)==0x3?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x^y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"^",0x7e,0x7f,(signed char)(x^y)==0x7f?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x^y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"^",0x7f,0x7e,(signed char)(x^y)==0x7e?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x^y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"^",0x2,0x0,(signed char)(x^y)==0x0?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x^y)!=(signed char)124) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"^",0x7e,0x7c,(signed char)(x^y)==0x7c?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x^y)!=(signed char)125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"^",0x7f,0x7d,(signed char)(x^y)==0x7d?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x^y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"^",0x7e,0x0,(signed char)(x^y)==0x0?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x^y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"^",0x7f,0x1,(signed char)(x^y)==0x1?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x^y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"^",0x7f,0x0,(signed char)(x^y)==0x0?"PASS":"FAIL",(signed char)(x^y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x&y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&",0xffffff80,0xffffff80,(signed char)(x&y)==0xffffff80?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x&y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&",0xffffff81,0xffffff80,(signed char)(x&y)==0xffffff80?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x&y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&",0xfffffffe,0xffffff80,(signed char)(x&y)==0xffffff80?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x&y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&",0xffffffff,0xffffff80,(signed char)(x&y)==0xffffff80?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&",0x0,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&",0x1,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&",0x2,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&",0x7e,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&",0x7f,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x&y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&",0xffffff81,0xffffff81,(signed char)(x&y)==0xffffff81?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x&y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&",0xfffffffe,0xffffff80,(signed char)(x&y)==0xffffff80?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x&y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&",0xffffffff,0xffffff81,(signed char)(x&y)==0xffffff81?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&",0x0,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&",0x1,0x1,(signed char)(x&y)==0x1?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&",0x2,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&",0x7e,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&",0x7f,0x1,(signed char)(x&y)==0x1?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x&y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&",0xfffffffe,0xfffffffe,(signed char)(x&y)==0xfffffffe?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x&y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&",0xffffffff,0xfffffffe,(signed char)(x&y)==0xfffffffe?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&",0x0,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&",0x1,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x&y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&",0x2,0x2,(signed char)(x&y)==0x2?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x&y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&",0x7e,0x7e,(signed char)(x&y)==0x7e?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x&y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&",0x7f,0x7e,(signed char)(x&y)==0x7e?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x&y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&",0xffffffff,0xffffffff,(signed char)(x&y)==0xffffffff?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&",0x0,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&",0x1,0x1,(signed char)(x&y)==0x1?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x&y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&",0x2,0x2,(signed char)(x&y)==0x2?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x&y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&",0x7e,0x7e,(signed char)(x&y)==0x7e?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x&y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&",0x7f,0x7f,(signed char)(x&y)==0x7f?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&",0x0,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&",0x1,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&",0x2,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&",0x7e,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&",0x7f,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"&",0x1,0x1,(signed char)(x&y)==0x1?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"&",0x2,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"&",0x7e,0x0,(signed char)(x&y)==0x0?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"&",0x7f,0x1,(signed char)(x&y)==0x1?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x&y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"&",0x2,0x2,(signed char)(x&y)==0x2?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x&y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"&",0x7e,0x2,(signed char)(x&y)==0x2?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x&y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"&",0x7f,0x2,(signed char)(x&y)==0x2?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x&y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"&",0x7e,0x7e,(signed char)(x&y)==0x7e?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x&y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"&",0x7f,0x7e,(signed char)(x&y)==0x7e?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x&y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"&",0x7f,0x7f,(signed char)(x&y)==0x7f?"PASS":"FAIL",(signed char)(x&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x|y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"|",0xffffff80,0xffffff80,(signed char)(x|y)==0xffffff80?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x|y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"|",0xffffff81,0xffffff81,(signed char)(x|y)==0xffffff81?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x|y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"|",0xfffffffe,0xfffffffe,(signed char)(x|y)==0xfffffffe?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"|",0xffffffff,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x|y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"|",0x0,0xffffff80,(signed char)(x|y)==0xffffff80?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x|y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"|",0x1,0xffffff81,(signed char)(x|y)==0xffffff81?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x|y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"|",0x2,0xffffff82,(signed char)(x|y)==0xffffff82?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x|y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"|",0x7e,0xfffffffe,(signed char)(x|y)==0xfffffffe?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"|",0x7f,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x|y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"|",0xffffff81,0xffffff81,(signed char)(x|y)==0xffffff81?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"|",0xfffffffe,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"|",0xffffffff,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x|y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"|",0x0,0xffffff81,(signed char)(x|y)==0xffffff81?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x|y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"|",0x1,0xffffff81,(signed char)(x|y)==0xffffff81?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x|y)!=(signed char)-125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"|",0x2,0xffffff83,(signed char)(x|y)==0xffffff83?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"|",0x7e,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"|",0x7f,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x|y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"|",0xfffffffe,0xfffffffe,(signed char)(x|y)==0xfffffffe?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"|",0xffffffff,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x|y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"|",0x0,0xfffffffe,(signed char)(x|y)==0xfffffffe?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"|",0x1,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x|y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"|",0x2,0xfffffffe,(signed char)(x|y)==0xfffffffe?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x|y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"|",0x7e,0xfffffffe,(signed char)(x|y)==0xfffffffe?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"|",0x7f,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"|",0xffffffff,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"|",0x0,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"|",0x1,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"|",0x2,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"|",0x7e,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x|y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"|",0x7f,0xffffffff,(signed char)(x|y)==0xffffffff?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x|y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"|",0x0,0x0,(signed char)(x|y)==0x0?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x|y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"|",0x1,0x1,(signed char)(x|y)==0x1?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x|y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"|",0x2,0x2,(signed char)(x|y)==0x2?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x|y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"|",0x7e,0x7e,(signed char)(x|y)==0x7e?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x|y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"|",0x7f,0x7f,(signed char)(x|y)==0x7f?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x|y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"|",0x1,0x1,(signed char)(x|y)==0x1?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x|y)!=(signed char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"|",0x2,0x3,(signed char)(x|y)==0x3?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x|y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"|",0x7e,0x7f,(signed char)(x|y)==0x7f?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x|y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"|",0x7f,0x7f,(signed char)(x|y)==0x7f?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x|y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"|",0x2,0x2,(signed char)(x|y)==0x2?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x|y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"|",0x7e,0x7e,(signed char)(x|y)==0x7e?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x|y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"|",0x7f,0x7f,(signed char)(x|y)==0x7f?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x|y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"|",0x7e,0x7e,(signed char)(x|y)==0x7e?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x|y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"|",0x7f,0x7f,(signed char)(x|y)==0x7f?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x|y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"|",0x7f,0x7f,(signed char)(x|y)==0x7f?"PASS":"FAIL",(signed char)(x|y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x< %s (%d)\n",__LINE__,"signed char",0xffffff80,"<<",0x0,0xffffff80,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xffffff80,"<<",0x1,0x0,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xffffff80,"<<",0x2,0x0,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xffffff81,"<<",0x0,0xffffff81,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xffffff81,"<<",0x1,0x2,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xffffff81,"<<",0x2,0x4,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<<",0x0,0xfffffffe,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<<",0x1,0xfffffffc,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<<",0x2,0xfffffff8,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xffffffff,"<<",0x0,0xffffffff,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xffffffff,"<<",0x1,0xfffffffe,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0xffffffff,"<<",0x2,0xfffffffc,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0x0,"<<",0x0,0x0,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0x0,"<<",0x1,0x0,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0x0,"<<",0x2,0x0,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0x1,"<<",0x1,0x2,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0x1,"<<",0x2,0x4,(signed char)(x< %s (%d)\n",__LINE__,"signed char",0x2,"<<",0x2,0x8,(signed char)(x<>y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">>",0x0,0xffffff80,(signed char)(x>>y)==0xffffff80?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x>>y)!=(signed char)-64) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">>",0x1,0xffffffc0,(signed char)(x>>y)==0xffffffc0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x>>y)!=(signed char)-32) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">>",0x2,0xffffffe0,(signed char)(x>>y)==0xffffffe0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x>>y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">>",0x0,0xffffff81,(signed char)(x>>y)==0xffffff81?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x>>y)!=(signed char)-64) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">>",0x1,0xffffffc0,(signed char)(x>>y)==0xffffffc0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x>>y)!=(signed char)-32) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">>",0x2,0xffffffe0,(signed char)(x>>y)==0xffffffe0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x>>y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">>",0x0,0xfffffffe,(signed char)(x>>y)==0xfffffffe?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x>>y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">>",0x1,0xffffffff,(signed char)(x>>y)==0xffffffff?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x>>y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">>",0x2,0xffffffff,(signed char)(x>>y)==0xffffffff?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x>>y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">>",0x0,0xffffffff,(signed char)(x>>y)==0xffffffff?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x>>y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">>",0x1,0xffffffff,(signed char)(x>>y)==0xffffffff?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x>>y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">>",0x2,0xffffffff,(signed char)(x>>y)==0xffffffff?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x>>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">>",0x0,0x0,(signed char)(x>>y)==0x0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x>>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">>",0x1,0x0,(signed char)(x>>y)==0x0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x>>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">>",0x2,0x0,(signed char)(x>>y)==0x0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x>>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">>",0x1,0x0,(signed char)(x>>y)==0x0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x>>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">>",0x2,0x0,(signed char)(x>>y)==0x0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x>>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,">>",0x2,0x0,(signed char)(x>>y)==0x0?"PASS":"FAIL",(signed char)(x>>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&&",0xffffff80,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&&",0xffffff81,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&&",0xfffffffe,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&&",0xffffffff,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x&&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&&",0x0,0x0,(signed char)(x&&y)==0x0?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&&",0x1,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&&",0x2,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&&",0x7e,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"&&",0x7f,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&&",0xffffff81,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&&",0xfffffffe,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&&",0xffffffff,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x&&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&&",0x0,0x0,(signed char)(x&&y)==0x0?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&&",0x1,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&&",0x2,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&&",0x7e,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"&&",0x7f,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&&",0xfffffffe,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&&",0xffffffff,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x&&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&&",0x0,0x0,(signed char)(x&&y)==0x0?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&&",0x1,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&&",0x2,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&&",0x7e,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"&&",0x7f,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&&",0xffffffff,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x&&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&&",0x0,0x0,(signed char)(x&&y)==0x0?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&&",0x1,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&&",0x2,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&&",0x7e,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"&&",0x7f,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x&&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&&",0x0,0x0,(signed char)(x&&y)==0x0?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x&&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&&",0x1,0x0,(signed char)(x&&y)==0x0?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x&&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&&",0x2,0x0,(signed char)(x&&y)==0x0?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x&&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&&",0x7e,0x0,(signed char)(x&&y)==0x0?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x&&y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"&&",0x7f,0x0,(signed char)(x&&y)==0x0?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"&&",0x1,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"&&",0x2,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"&&",0x7e,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"&&",0x7f,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"&&",0x2,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"&&",0x7e,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"&&",0x7f,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"&&",0x7e,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"&&",0x7f,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x&&y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"&&",0x7f,0x1,(signed char)(x&&y)==0x1?"PASS":"FAIL",(signed char)(x&&y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"||",0xffffff80,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"||",0xffffff81,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"||",0xfffffffe,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"||",0xffffffff,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"||",0x0,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"||",0x1,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"||",0x2,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"||",0x7e,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"||",0x7f,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"||",0xffffff81,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"||",0xfffffffe,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"||",0xffffffff,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"||",0x0,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"||",0x1,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"||",0x2,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"||",0x7e,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"||",0x7f,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"||",0xfffffffe,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"||",0xffffffff,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"||",0x0,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"||",0x1,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"||",0x2,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"||",0x7e,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"||",0x7f,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"||",0xffffffff,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"||",0x0,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"||",0x1,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"||",0x2,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"||",0x7e,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"||",0x7f,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x||y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"||",0x0,0x0,(signed char)(x||y)==0x0?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"||",0x1,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"||",0x2,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"||",0x7e,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"||",0x7f,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"||",0x1,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"||",0x2,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"||",0x7e,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"||",0x7f,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"||",0x2,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"||",0x7e,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"||",0x7f,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"||",0x7e,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"||",0x7f,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x||y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"||",0x7f,0x1,(signed char)(x||y)==0x1?"PASS":"FAIL",(signed char)(x||y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">",0xffffff80,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">",0xffffff81,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">",0xfffffffe,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">",0xffffffff,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">",0x0,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">",0x1,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">",0x2,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">",0x7e,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">",0x7f,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">",0xffffff81,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">",0xfffffffe,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">",0xffffffff,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">",0x0,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">",0x1,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">",0x2,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">",0x7e,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">",0x7f,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">",0xfffffffe,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">",0xffffffff,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">",0x0,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">",0x1,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">",0x2,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">",0x7e,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">",0x7f,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">",0xffffffff,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">",0x0,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">",0x1,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">",0x2,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">",0x7e,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">",0x7f,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">",0x0,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">",0x1,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">",0x2,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">",0x7e,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">",0x7f,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">",0x1,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">",0x2,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">",0x7e,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">",0x7f,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,">",0x2,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,">",0x7e,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,">",0x7f,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,">",0x7e,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,">",0x7f,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x>y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,">",0x7f,0x0,(signed char)(x>y)==0x0?"PASS":"FAIL",(signed char)(x>y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff80,"<",0xffffff80,0x0,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff80,"<",0xffffff81,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff80,"<",0xfffffffe,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff80,"<",0xffffffff,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff80,"<",0x0,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff80,"<",0x1,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff80,"<",0x2,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff80,"<",0x7e,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff80,"<",0x7f,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff81,"<",0xffffff81,0x0,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff81,"<",0xfffffffe,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff81,"<",0xffffffff,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff81,"<",0x0,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff81,"<",0x1,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff81,"<",0x2,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff81,"<",0x7e,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffff81,"<",0x7f,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<",0xfffffffe,0x0,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<",0xffffffff,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<",0x0,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<",0x1,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<",0x2,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<",0x7e,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<",0x7f,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffffff,"<",0xffffffff,0x0,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffffff,"<",0x0,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffffff,"<",0x1,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffffff,"<",0x2,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffffff,"<",0x7e,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0xffffffff,"<",0x7f,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x0,"<",0x0,0x0,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x0,"<",0x1,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x0,"<",0x2,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x0,"<",0x7e,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x0,"<",0x7f,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x1,"<",0x1,0x0,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x1,"<",0x2,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x1,"<",0x7e,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x1,"<",0x7f,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x2,"<",0x2,0x0,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x2,"<",0x7e,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x2,"<",0x7f,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x7e,"<",0x7e,0x0,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x7e,"<",0x7f,0x1,(signed char)(x %s (%d)\n",__LINE__,"signed char",0x7f,"<",0x7f,0x0,(signed char)(x=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">=",0xffffff80,0x1,(signed char)(x>=y)==0x1?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">=",0xffffff81,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">=",0xfffffffe,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">=",0xffffffff,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">=",0x0,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">=",0x1,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">=",0x2,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">=",0x7e,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,">=",0x7f,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x>=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">=",0xffffff81,0x1,(signed char)(x>=y)==0x1?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">=",0xfffffffe,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">=",0xffffffff,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">=",0x0,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">=",0x1,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">=",0x2,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">=",0x7e,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,">=",0x7f,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x>=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">=",0xfffffffe,0x1,(signed char)(x>=y)==0x1?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">=",0xffffffff,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">=",0x0,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">=",0x1,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">=",0x2,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">=",0x7e,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,">=",0x7f,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x>=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">=",0xffffffff,0x1,(signed char)(x>=y)==0x1?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">=",0x0,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">=",0x1,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">=",0x2,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">=",0x7e,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,">=",0x7f,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x>=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">=",0x0,0x1,(signed char)(x>=y)==0x1?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">=",0x1,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">=",0x2,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">=",0x7e,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,">=",0x7f,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x>=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">=",0x1,0x1,(signed char)(x>=y)==0x1?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">=",0x2,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">=",0x7e,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,">=",0x7f,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x>=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,">=",0x2,0x1,(signed char)(x>=y)==0x1?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,">=",0x7e,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,">=",0x7f,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x>=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,">=",0x7e,0x1,(signed char)(x>=y)==0x1?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x>=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,">=",0x7f,0x0,(signed char)(x>=y)==0x0?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x>=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,">=",0x7f,0x1,(signed char)(x>=y)==0x1?"PASS":"FAIL",(signed char)(x>=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"<=",0xffffff80,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"<=",0xffffff81,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"<=",0xfffffffe,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"<=",0xffffffff,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"<=",0x0,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"<=",0x1,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"<=",0x2,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"<=",0x7e,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"<=",0x7f,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"<=",0xffffff81,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"<=",0xfffffffe,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"<=",0xffffffff,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"<=",0x0,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"<=",0x1,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"<=",0x2,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"<=",0x7e,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"<=",0x7f,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<=",0xfffffffe,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<=",0xffffffff,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<=",0x0,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<=",0x1,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<=",0x2,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<=",0x7e,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"<=",0x7f,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"<=",0xffffffff,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"<=",0x0,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"<=",0x1,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"<=",0x2,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"<=",0x7e,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"<=",0x7f,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"<=",0x0,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"<=",0x1,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"<=",0x2,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"<=",0x7e,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"<=",0x7f,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"<=",0x1,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"<=",0x2,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"<=",0x7e,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"<=",0x7f,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"<=",0x2,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"<=",0x7e,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"<=",0x7f,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"<=",0x7e,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"<=",0x7f,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x<=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"<=",0x7f,0x1,(signed char)(x<=y)==0x1?"PASS":"FAIL",(signed char)(x<=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x==y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"==",0xffffff80,0x1,(signed char)(x==y)==0x1?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"==",0xffffff81,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"==",0xfffffffe,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"==",0xffffffff,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"==",0x0,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"==",0x1,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"==",0x2,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"==",0x7e,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"==",0x7f,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x==y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"==",0xffffff81,0x1,(signed char)(x==y)==0x1?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"==",0xfffffffe,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"==",0xffffffff,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"==",0x0,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"==",0x1,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"==",0x2,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"==",0x7e,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"==",0x7f,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x==y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"==",0xfffffffe,0x1,(signed char)(x==y)==0x1?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"==",0xffffffff,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"==",0x0,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"==",0x1,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"==",0x2,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"==",0x7e,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"==",0x7f,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x==y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"==",0xffffffff,0x1,(signed char)(x==y)==0x1?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"==",0x0,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"==",0x1,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"==",0x2,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"==",0x7e,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"==",0x7f,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x==y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"==",0x0,0x1,(signed char)(x==y)==0x1?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"==",0x1,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"==",0x2,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"==",0x7e,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"==",0x7f,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x==y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"==",0x1,0x1,(signed char)(x==y)==0x1?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"==",0x2,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"==",0x7e,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"==",0x7f,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x==y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"==",0x2,0x1,(signed char)(x==y)==0x1?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"==",0x7e,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"==",0x7f,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x==y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"==",0x7e,0x1,(signed char)(x==y)==0x1?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x==y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"==",0x7f,0x0,(signed char)(x==y)==0x0?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x==y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"==",0x7f,0x1,(signed char)(x==y)==0x1?"PASS":"FAIL",(signed char)(x==y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x!=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"!=",0xffffff80,0x0,(signed char)(x!=y)==0x0?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"!=",0xffffff81,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"!=",0xfffffffe,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"!=",0xffffffff,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"!=",0x0,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"!=",0x1,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"!=",0x2,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"!=",0x7e,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"!=",0x7f,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x!=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"!=",0xffffff81,0x0,(signed char)(x!=y)==0x0?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"!=",0xfffffffe,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"!=",0xffffffff,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"!=",0x0,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"!=",0x1,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"!=",0x2,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"!=",0x7e,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"!=",0x7f,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x!=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"!=",0xfffffffe,0x0,(signed char)(x!=y)==0x0?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"!=",0xffffffff,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"!=",0x0,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"!=",0x1,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"!=",0x2,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"!=",0x7e,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"!=",0x7f,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x!=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"!=",0xffffffff,0x0,(signed char)(x!=y)==0x0?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"!=",0x0,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"!=",0x1,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"!=",0x2,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"!=",0x7e,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"!=",0x7f,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x!=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"!=",0x0,0x0,(signed char)(x!=y)==0x0?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"!=",0x1,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"!=",0x2,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"!=",0x7e,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"!=",0x7f,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x!=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"!=",0x1,0x0,(signed char)(x!=y)==0x0?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"!=",0x2,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"!=",0x7e,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"!=",0x7f,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x!=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"!=",0x2,0x0,(signed char)(x!=y)==0x0?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"!=",0x7e,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"!=",0x7f,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x!=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"!=",0x7e,0x0,(signed char)(x!=y)==0x0?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x!=y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"!=",0x7f,0x1,(signed char)(x!=y)==0x1?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x!=y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"!=",0x7f,0x0,(signed char)(x!=y)==0x0?"PASS":"FAIL",(signed char)(x!=y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"*",0xffffff80,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x*y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"*",0xffffff81,0xffffff80,(signed char)(x*y)==0xffffff80?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"*",0xfffffffe,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x*y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"*",0xffffffff,0xffffff80,(signed char)(x*y)==0xffffff80?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=0; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"*",0x0,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x*y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"*",0x1,0xffffff80,(signed char)(x*y)==0xffffff80?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"*",0x2,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"*",0x7e,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x*y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"*",0x7f,0xffffff80,(signed char)(x*y)==0xffffff80?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x*y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"*",0xffffff81,0x1,(signed char)(x*y)==0x1?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x*y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"*",0xfffffffe,0xfffffffe,(signed char)(x*y)==0xfffffffe?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x*y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"*",0xffffffff,0x7f,(signed char)(x*y)==0x7f?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=0; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"*",0x0,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x*y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"*",0x1,0xffffff81,(signed char)(x*y)==0xffffff81?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x*y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"*",0x2,0x2,(signed char)(x*y)==0x2?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x*y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"*",0x7e,0x7e,(signed char)(x*y)==0x7e?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x*y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"*",0x7f,0xffffffff,(signed char)(x*y)==0xffffffff?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x*y)!=(signed char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"*",0xfffffffe,0x4,(signed char)(x*y)==0x4?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x*y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"*",0xffffffff,0x2,(signed char)(x*y)==0x2?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=0; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"*",0x0,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x*y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"*",0x1,0xfffffffe,(signed char)(x*y)==0xfffffffe?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x*y)!=(signed char)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"*",0x2,0xfffffffc,(signed char)(x*y)==0xfffffffc?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x*y)!=(signed char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"*",0x7e,0x4,(signed char)(x*y)==0x4?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x*y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"*",0x7f,0x2,(signed char)(x*y)==0x2?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x*y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"*",0xffffffff,0x1,(signed char)(x*y)==0x1?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=0; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"*",0x0,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x*y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"*",0x1,0xffffffff,(signed char)(x*y)==0xffffffff?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x*y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"*",0x2,0xfffffffe,(signed char)(x*y)==0xfffffffe?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x*y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"*",0x7e,0xffffff82,(signed char)(x*y)==0xffffff82?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x*y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"*",0x7f,0xffffff81,(signed char)(x*y)==0xffffff81?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=0; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"*",0x0,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"*",0x1,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"*",0x2,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"*",0x7e,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x*y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"*",0x7f,0x0,(signed char)(x*y)==0x0?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x*y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"*",0x1,0x1,(signed char)(x*y)==0x1?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x*y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"*",0x2,0x2,(signed char)(x*y)==0x2?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x*y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"*",0x7e,0x7e,(signed char)(x*y)==0x7e?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x*y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"*",0x7f,0x7f,(signed char)(x*y)==0x7f?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x*y)!=(signed char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"*",0x2,0x4,(signed char)(x*y)==0x4?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x*y)!=(signed char)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"*",0x7e,0xfffffffc,(signed char)(x*y)==0xfffffffc?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x*y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"*",0x7f,0xfffffffe,(signed char)(x*y)==0xfffffffe?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x*y)!=(signed char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"*",0x7e,0x4,(signed char)(x*y)==0x4?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x*y)!=(signed char)-126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"*",0x7f,0xffffff82,(signed char)(x*y)==0xffffff82?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x*y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"*",0x7f,0x1,(signed char)(x*y)==0x1?"PASS":"FAIL",(signed char)(x*y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x/y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"/",0xffffff80,0x1,(signed char)(x/y)==0x1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x/y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"/",0xffffff81,0x1,(signed char)(x/y)==0x1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x/y)!=(signed char)64) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"/",0xfffffffe,0x40,(signed char)(x/y)==0x40?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x/y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"/",0xffffffff,0xffffff80,(signed char)(x/y)==0xffffff80?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x/y)!=(signed char)-128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"/",0x1,0xffffff80,(signed char)(x/y)==0xffffff80?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x/y)!=(signed char)-64) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"/",0x2,0xffffffc0,(signed char)(x/y)==0xffffffc0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x/y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"/",0x7e,0xffffffff,(signed char)(x/y)==0xffffffff?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x/y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"/",0x7f,0xffffffff,(signed char)(x/y)==0xffffffff?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x/y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"/",0xffffff81,0x1,(signed char)(x/y)==0x1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x/y)!=(signed char)63) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"/",0xfffffffe,0x3f,(signed char)(x/y)==0x3f?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x/y)!=(signed char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"/",0xffffffff,0x7f,(signed char)(x/y)==0x7f?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x/y)!=(signed char)-127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"/",0x1,0xffffff81,(signed char)(x/y)==0xffffff81?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x/y)!=(signed char)-63) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"/",0x2,0xffffffc1,(signed char)(x/y)==0xffffffc1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x/y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"/",0x7e,0xffffffff,(signed char)(x/y)==0xffffffff?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x/y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"/",0x7f,0xffffffff,(signed char)(x/y)==0xffffffff?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x/y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"/",0xfffffffe,0x1,(signed char)(x/y)==0x1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x/y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"/",0xffffffff,0x2,(signed char)(x/y)==0x2?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x/y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"/",0x1,0xfffffffe,(signed char)(x/y)==0xfffffffe?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x/y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"/",0x2,0xffffffff,(signed char)(x/y)==0xffffffff?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"/",0x7e,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"/",0x7f,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x/y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"/",0xffffffff,0x1,(signed char)(x/y)==0x1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x/y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"/",0x1,0xffffffff,(signed char)(x/y)==0xffffffff?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"/",0x2,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"/",0x7e,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"/",0x7f,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"/",0x1,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"/",0x2,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"/",0x7e,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"/",0x7f,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x/y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"/",0x1,0x1,(signed char)(x/y)==0x1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"/",0x2,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"/",0x7e,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"/",0x7f,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x/y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"/",0x2,0x1,(signed char)(x/y)==0x1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"/",0x7e,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"/",0x7f,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x/y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"/",0x7e,0x1,(signed char)(x/y)==0x1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x/y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"/",0x7f,0x0,(signed char)(x/y)==0x0?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x/y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"/",0x7f,0x1,(signed char)(x/y)==0x1?"PASS":"FAIL",(signed char)(x/y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-128; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"%",0xffffff80,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-127; + if ((signed char)(x%y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"%",0xffffff81,0xffffffff,(signed char)(x%y)==0xffffffff?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-2; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"%",0xfffffffe,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=-1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"%",0xffffffff,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"%",0x1,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=2; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"%",0x2,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=126; + if ((signed char)(x%y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"%",0x7e,0xfffffffe,(signed char)(x%y)==0xfffffffe?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-128; volatile signed char y=127; + if ((signed char)(x%y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff80,"%",0x7f,0xffffffff,(signed char)(x%y)==0xffffffff?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-127; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"%",0xffffff81,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-2; + if ((signed char)(x%y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"%",0xfffffffe,0xffffffff,(signed char)(x%y)==0xffffffff?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=-1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"%",0xffffffff,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"%",0x1,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=2; + if ((signed char)(x%y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"%",0x2,0xffffffff,(signed char)(x%y)==0xffffffff?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=126; + if ((signed char)(x%y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"%",0x7e,0xffffffff,(signed char)(x%y)==0xffffffff?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-127; volatile signed char y=127; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffff81,"%",0x7f,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-2; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"%",0xfffffffe,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=-1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"%",0xffffffff,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"%",0x1,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=2; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"%",0x2,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=126; + if ((signed char)(x%y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"%",0x7e,0xfffffffe,(signed char)(x%y)==0xfffffffe?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-2; volatile signed char y=127; + if ((signed char)(x%y)!=(signed char)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xfffffffe,"%",0x7f,0xfffffffe,(signed char)(x%y)==0xfffffffe?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=-1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"%",0xffffffff,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"%",0x1,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=2; + if ((signed char)(x%y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"%",0x2,0xffffffff,(signed char)(x%y)==0xffffffff?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=126; + if ((signed char)(x%y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"%",0x7e,0xffffffff,(signed char)(x%y)==0xffffffff?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=-1; volatile signed char y=127; + if ((signed char)(x%y)!=(signed char)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0xffffffff,"%",0x7f,0xffffffff,(signed char)(x%y)==0xffffffff?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"%",0x1,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=2; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"%",0x2,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=126; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"%",0x7e,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=0; volatile signed char y=127; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x0,"%",0x7f,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=1; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"%",0x1,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=2; + if ((signed char)(x%y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"%",0x2,0x1,(signed char)(x%y)==0x1?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=126; + if ((signed char)(x%y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"%",0x7e,0x1,(signed char)(x%y)==0x1?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=1; volatile signed char y=127; + if ((signed char)(x%y)!=(signed char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x1,"%",0x7f,0x1,(signed char)(x%y)==0x1?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=2; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"%",0x2,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=126; + if ((signed char)(x%y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"%",0x7e,0x2,(signed char)(x%y)==0x2?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=2; volatile signed char y=127; + if ((signed char)(x%y)!=(signed char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x2,"%",0x7f,0x2,(signed char)(x%y)==0x2?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=126; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"%",0x7e,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=126; volatile signed char y=127; + if ((signed char)(x%y)!=(signed char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7e,"%",0x7f,0x7e,(signed char)(x%y)==0x7e?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile signed char x=127; volatile signed char y=127; + if ((signed char)(x%y)!=(signed char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"signed char",0x7f,"%",0x7f,0x0,(signed char)(x%y)==0x0?"PASS":"FAIL",(signed char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x+y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"+",0x80000000,0x0,(unsigned int)(x+y)==0x0?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x+y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"+",0x80000001,0x1,(unsigned int)(x+y)==0x1?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x+y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"+",0xfffffffe,0x7ffffffe,(unsigned int)(x+y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x+y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"+",0xffffffff,0x7fffffff,(unsigned int)(x+y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x+y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"+",0x0,0x80000000,(unsigned int)(x+y)==0x80000000?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x+y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"+",0x1,0x80000001,(unsigned int)(x+y)==0x80000001?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x+y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"+",0x2,0x80000002,(unsigned int)(x+y)==0x80000002?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x+y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"+",0x7ffffffe,0xfffffffe,(unsigned int)(x+y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x+y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"+",0x7fffffff,0xffffffff,(unsigned int)(x+y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x+y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"+",0x80000001,0x2,(unsigned int)(x+y)==0x2?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x+y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"+",0xfffffffe,0x7fffffff,(unsigned int)(x+y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x+y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"+",0xffffffff,0x80000000,(unsigned int)(x+y)==0x80000000?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x+y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"+",0x0,0x80000001,(unsigned int)(x+y)==0x80000001?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x+y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"+",0x1,0x80000002,(unsigned int)(x+y)==0x80000002?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x+y)!=(unsigned int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"+",0x2,0x80000003,(unsigned int)(x+y)==0x80000003?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x+y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"+",0x7ffffffe,0xffffffff,(unsigned int)(x+y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x+y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"+",0x7fffffff,0x0,(unsigned int)(x+y)==0x0?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x+y)!=(unsigned int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"+",0xfffffffe,0xfffffffc,(unsigned int)(x+y)==0xfffffffc?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x+y)!=(unsigned int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"+",0xffffffff,0xfffffffd,(unsigned int)(x+y)==0xfffffffd?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x+y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"+",0x0,0xfffffffe,(unsigned int)(x+y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x+y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"+",0x1,0xffffffff,(unsigned int)(x+y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x+y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"+",0x2,0x0,(unsigned int)(x+y)==0x0?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x+y)!=(unsigned int)2147483644) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"+",0x7ffffffe,0x7ffffffc,(unsigned int)(x+y)==0x7ffffffc?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x+y)!=(unsigned int)2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"+",0x7fffffff,0x7ffffffd,(unsigned int)(x+y)==0x7ffffffd?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x+y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"+",0xffffffff,0xfffffffe,(unsigned int)(x+y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x+y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"+",0x0,0xffffffff,(unsigned int)(x+y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x+y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"+",0x1,0x0,(unsigned int)(x+y)==0x0?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x+y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"+",0x2,0x1,(unsigned int)(x+y)==0x1?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x+y)!=(unsigned int)2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"+",0x7ffffffe,0x7ffffffd,(unsigned int)(x+y)==0x7ffffffd?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x+y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"+",0x7fffffff,0x7ffffffe,(unsigned int)(x+y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x+y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"+",0x0,0x0,(unsigned int)(x+y)==0x0?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x+y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"+",0x1,0x1,(unsigned int)(x+y)==0x1?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x+y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"+",0x2,0x2,(unsigned int)(x+y)==0x2?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x+y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"+",0x7ffffffe,0x7ffffffe,(unsigned int)(x+y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x+y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"+",0x7fffffff,0x7fffffff,(unsigned int)(x+y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x+y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"+",0x1,0x2,(unsigned int)(x+y)==0x2?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x+y)!=(unsigned int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"+",0x2,0x3,(unsigned int)(x+y)==0x3?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x+y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"+",0x7ffffffe,0x7fffffff,(unsigned int)(x+y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x+y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"+",0x7fffffff,0x80000000,(unsigned int)(x+y)==0x80000000?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x+y)!=(unsigned int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"+",0x2,0x4,(unsigned int)(x+y)==0x4?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x+y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"+",0x7ffffffe,0x80000000,(unsigned int)(x+y)==0x80000000?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x+y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"+",0x7fffffff,0x80000001,(unsigned int)(x+y)==0x80000001?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x+y)!=(unsigned int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"+",0x7ffffffe,0xfffffffc,(unsigned int)(x+y)==0xfffffffc?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x+y)!=(unsigned int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"+",0x7fffffff,0xfffffffd,(unsigned int)(x+y)==0xfffffffd?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x+y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"+",0x7fffffff,0xfffffffe,(unsigned int)(x+y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x+y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x-y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"-",0x80000000,0x0,(unsigned int)(x-y)==0x0?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x-y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"-",0x80000001,0xffffffff,(unsigned int)(x-y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x-y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"-",0xfffffffe,0x80000002,(unsigned int)(x-y)==0x80000002?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x-y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"-",0xffffffff,0x80000001,(unsigned int)(x-y)==0x80000001?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x-y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"-",0x0,0x80000000,(unsigned int)(x-y)==0x80000000?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x-y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"-",0x1,0x7fffffff,(unsigned int)(x-y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x-y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"-",0x2,0x7ffffffe,(unsigned int)(x-y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x-y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"-",0x7ffffffe,0x2,(unsigned int)(x-y)==0x2?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x-y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"-",0x7fffffff,0x1,(unsigned int)(x-y)==0x1?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x-y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"-",0x80000001,0x0,(unsigned int)(x-y)==0x0?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x-y)!=(unsigned int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"-",0xfffffffe,0x80000003,(unsigned int)(x-y)==0x80000003?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x-y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"-",0xffffffff,0x80000002,(unsigned int)(x-y)==0x80000002?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x-y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"-",0x0,0x80000001,(unsigned int)(x-y)==0x80000001?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x-y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"-",0x1,0x80000000,(unsigned int)(x-y)==0x80000000?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x-y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"-",0x2,0x7fffffff,(unsigned int)(x-y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x-y)!=(unsigned int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"-",0x7ffffffe,0x3,(unsigned int)(x-y)==0x3?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x-y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"-",0x7fffffff,0x2,(unsigned int)(x-y)==0x2?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x-y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"-",0xfffffffe,0x0,(unsigned int)(x-y)==0x0?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x-y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"-",0xffffffff,0xffffffff,(unsigned int)(x-y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x-y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"-",0x0,0xfffffffe,(unsigned int)(x-y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x-y)!=(unsigned int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"-",0x1,0xfffffffd,(unsigned int)(x-y)==0xfffffffd?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x-y)!=(unsigned int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"-",0x2,0xfffffffc,(unsigned int)(x-y)==0xfffffffc?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x-y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"-",0x7ffffffe,0x80000000,(unsigned int)(x-y)==0x80000000?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x-y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"-",0x7fffffff,0x7fffffff,(unsigned int)(x-y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x-y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"-",0xffffffff,0x0,(unsigned int)(x-y)==0x0?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x-y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"-",0x0,0xffffffff,(unsigned int)(x-y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x-y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"-",0x1,0xfffffffe,(unsigned int)(x-y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x-y)!=(unsigned int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"-",0x2,0xfffffffd,(unsigned int)(x-y)==0xfffffffd?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x-y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"-",0x7ffffffe,0x80000001,(unsigned int)(x-y)==0x80000001?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x-y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"-",0x7fffffff,0x80000000,(unsigned int)(x-y)==0x80000000?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x-y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"-",0x0,0x0,(unsigned int)(x-y)==0x0?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x-y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"-",0x1,0xffffffff,(unsigned int)(x-y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x-y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"-",0x2,0xfffffffe,(unsigned int)(x-y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x-y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"-",0x7ffffffe,0x80000002,(unsigned int)(x-y)==0x80000002?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x-y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"-",0x7fffffff,0x80000001,(unsigned int)(x-y)==0x80000001?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x-y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"-",0x1,0x0,(unsigned int)(x-y)==0x0?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x-y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"-",0x2,0xffffffff,(unsigned int)(x-y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x-y)!=(unsigned int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"-",0x7ffffffe,0x80000003,(unsigned int)(x-y)==0x80000003?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x-y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"-",0x7fffffff,0x80000002,(unsigned int)(x-y)==0x80000002?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x-y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"-",0x2,0x0,(unsigned int)(x-y)==0x0?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x-y)!=(unsigned int)-2147483644) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"-",0x7ffffffe,0x80000004,(unsigned int)(x-y)==0x80000004?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x-y)!=(unsigned int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"-",0x7fffffff,0x80000003,(unsigned int)(x-y)==0x80000003?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x-y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"-",0x7ffffffe,0x0,(unsigned int)(x-y)==0x0?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x-y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"-",0x7fffffff,0xffffffff,(unsigned int)(x-y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x-y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"-",0x7fffffff,0x0,(unsigned int)(x-y)==0x0?"PASS":"FAIL",(unsigned int)(x-y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x^y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"^",0x80000000,0x0,(unsigned int)(x^y)==0x0?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x^y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"^",0x80000001,0x1,(unsigned int)(x^y)==0x1?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x^y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"^",0xfffffffe,0x7ffffffe,(unsigned int)(x^y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x^y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"^",0xffffffff,0x7fffffff,(unsigned int)(x^y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x^y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"^",0x0,0x80000000,(unsigned int)(x^y)==0x80000000?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x^y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"^",0x1,0x80000001,(unsigned int)(x^y)==0x80000001?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x^y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"^",0x2,0x80000002,(unsigned int)(x^y)==0x80000002?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x^y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"^",0x7ffffffe,0xfffffffe,(unsigned int)(x^y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x^y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"^",0x7fffffff,0xffffffff,(unsigned int)(x^y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x^y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"^",0x80000001,0x0,(unsigned int)(x^y)==0x0?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x^y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"^",0xfffffffe,0x7fffffff,(unsigned int)(x^y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x^y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"^",0xffffffff,0x7ffffffe,(unsigned int)(x^y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x^y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"^",0x0,0x80000001,(unsigned int)(x^y)==0x80000001?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x^y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"^",0x1,0x80000000,(unsigned int)(x^y)==0x80000000?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x^y)!=(unsigned int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"^",0x2,0x80000003,(unsigned int)(x^y)==0x80000003?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x^y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"^",0x7ffffffe,0xffffffff,(unsigned int)(x^y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x^y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"^",0x7fffffff,0xfffffffe,(unsigned int)(x^y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x^y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"^",0xfffffffe,0x0,(unsigned int)(x^y)==0x0?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x^y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"^",0xffffffff,0x1,(unsigned int)(x^y)==0x1?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x^y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"^",0x0,0xfffffffe,(unsigned int)(x^y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x^y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"^",0x1,0xffffffff,(unsigned int)(x^y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x^y)!=(unsigned int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"^",0x2,0xfffffffc,(unsigned int)(x^y)==0xfffffffc?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x^y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"^",0x7ffffffe,0x80000000,(unsigned int)(x^y)==0x80000000?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x^y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"^",0x7fffffff,0x80000001,(unsigned int)(x^y)==0x80000001?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x^y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"^",0xffffffff,0x0,(unsigned int)(x^y)==0x0?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x^y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"^",0x0,0xffffffff,(unsigned int)(x^y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x^y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"^",0x1,0xfffffffe,(unsigned int)(x^y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x^y)!=(unsigned int)-3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"^",0x2,0xfffffffd,(unsigned int)(x^y)==0xfffffffd?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x^y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"^",0x7ffffffe,0x80000001,(unsigned int)(x^y)==0x80000001?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x^y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"^",0x7fffffff,0x80000000,(unsigned int)(x^y)==0x80000000?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x^y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"^",0x0,0x0,(unsigned int)(x^y)==0x0?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x^y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"^",0x1,0x1,(unsigned int)(x^y)==0x1?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x^y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"^",0x2,0x2,(unsigned int)(x^y)==0x2?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x^y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"^",0x7ffffffe,0x7ffffffe,(unsigned int)(x^y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x^y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"^",0x7fffffff,0x7fffffff,(unsigned int)(x^y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x^y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"^",0x1,0x0,(unsigned int)(x^y)==0x0?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x^y)!=(unsigned int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"^",0x2,0x3,(unsigned int)(x^y)==0x3?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x^y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"^",0x7ffffffe,0x7fffffff,(unsigned int)(x^y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x^y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"^",0x7fffffff,0x7ffffffe,(unsigned int)(x^y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x^y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"^",0x2,0x0,(unsigned int)(x^y)==0x0?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x^y)!=(unsigned int)2147483644) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"^",0x7ffffffe,0x7ffffffc,(unsigned int)(x^y)==0x7ffffffc?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x^y)!=(unsigned int)2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"^",0x7fffffff,0x7ffffffd,(unsigned int)(x^y)==0x7ffffffd?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x^y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"^",0x7ffffffe,0x0,(unsigned int)(x^y)==0x0?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x^y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"^",0x7fffffff,0x1,(unsigned int)(x^y)==0x1?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x^y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"^",0x7fffffff,0x0,(unsigned int)(x^y)==0x0?"PASS":"FAIL",(unsigned int)(x^y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x&y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&",0x80000000,0x80000000,(unsigned int)(x&y)==0x80000000?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x&y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&",0x80000001,0x80000000,(unsigned int)(x&y)==0x80000000?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x&y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&",0xfffffffe,0x80000000,(unsigned int)(x&y)==0x80000000?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x&y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&",0xffffffff,0x80000000,(unsigned int)(x&y)==0x80000000?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&",0x0,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&",0x1,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&",0x2,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&",0x7ffffffe,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&",0x7fffffff,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x&y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&",0x80000001,0x80000001,(unsigned int)(x&y)==0x80000001?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x&y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&",0xfffffffe,0x80000000,(unsigned int)(x&y)==0x80000000?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x&y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&",0xffffffff,0x80000001,(unsigned int)(x&y)==0x80000001?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&",0x0,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&",0x1,0x1,(unsigned int)(x&y)==0x1?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&",0x2,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&",0x7ffffffe,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&",0x7fffffff,0x1,(unsigned int)(x&y)==0x1?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x&y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&",0xfffffffe,0xfffffffe,(unsigned int)(x&y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x&y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&",0xffffffff,0xfffffffe,(unsigned int)(x&y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&",0x0,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&",0x1,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x&y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&",0x2,0x2,(unsigned int)(x&y)==0x2?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x&y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&",0x7ffffffe,0x7ffffffe,(unsigned int)(x&y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x&y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&",0x7fffffff,0x7ffffffe,(unsigned int)(x&y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x&y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&",0xffffffff,0xffffffff,(unsigned int)(x&y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&",0x0,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&",0x1,0x1,(unsigned int)(x&y)==0x1?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x&y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&",0x2,0x2,(unsigned int)(x&y)==0x2?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x&y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&",0x7ffffffe,0x7ffffffe,(unsigned int)(x&y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x&y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&",0x7fffffff,0x7fffffff,(unsigned int)(x&y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&",0x0,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&",0x1,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&",0x2,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&",0x7ffffffe,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&",0x7fffffff,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"&",0x1,0x1,(unsigned int)(x&y)==0x1?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"&",0x2,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"&",0x7ffffffe,0x0,(unsigned int)(x&y)==0x0?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"&",0x7fffffff,0x1,(unsigned int)(x&y)==0x1?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x&y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"&",0x2,0x2,(unsigned int)(x&y)==0x2?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x&y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"&",0x7ffffffe,0x2,(unsigned int)(x&y)==0x2?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x&y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"&",0x7fffffff,0x2,(unsigned int)(x&y)==0x2?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x&y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"&",0x7ffffffe,0x7ffffffe,(unsigned int)(x&y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x&y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"&",0x7fffffff,0x7ffffffe,(unsigned int)(x&y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x&y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"&",0x7fffffff,0x7fffffff,(unsigned int)(x&y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x|y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"|",0x80000000,0x80000000,(unsigned int)(x|y)==0x80000000?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x|y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"|",0x80000001,0x80000001,(unsigned int)(x|y)==0x80000001?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x|y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"|",0xfffffffe,0xfffffffe,(unsigned int)(x|y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"|",0xffffffff,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x|y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"|",0x0,0x80000000,(unsigned int)(x|y)==0x80000000?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x|y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"|",0x1,0x80000001,(unsigned int)(x|y)==0x80000001?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x|y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"|",0x2,0x80000002,(unsigned int)(x|y)==0x80000002?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x|y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"|",0x7ffffffe,0xfffffffe,(unsigned int)(x|y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"|",0x7fffffff,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x|y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"|",0x80000001,0x80000001,(unsigned int)(x|y)==0x80000001?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"|",0xfffffffe,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"|",0xffffffff,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x|y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"|",0x0,0x80000001,(unsigned int)(x|y)==0x80000001?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x|y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"|",0x1,0x80000001,(unsigned int)(x|y)==0x80000001?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x|y)!=(unsigned int)-2147483645) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"|",0x2,0x80000003,(unsigned int)(x|y)==0x80000003?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"|",0x7ffffffe,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"|",0x7fffffff,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x|y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"|",0xfffffffe,0xfffffffe,(unsigned int)(x|y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"|",0xffffffff,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x|y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"|",0x0,0xfffffffe,(unsigned int)(x|y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"|",0x1,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x|y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"|",0x2,0xfffffffe,(unsigned int)(x|y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x|y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"|",0x7ffffffe,0xfffffffe,(unsigned int)(x|y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"|",0x7fffffff,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"|",0xffffffff,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"|",0x0,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"|",0x1,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"|",0x2,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"|",0x7ffffffe,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x|y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"|",0x7fffffff,0xffffffff,(unsigned int)(x|y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x|y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"|",0x0,0x0,(unsigned int)(x|y)==0x0?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x|y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"|",0x1,0x1,(unsigned int)(x|y)==0x1?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x|y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"|",0x2,0x2,(unsigned int)(x|y)==0x2?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x|y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"|",0x7ffffffe,0x7ffffffe,(unsigned int)(x|y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x|y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"|",0x7fffffff,0x7fffffff,(unsigned int)(x|y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x|y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"|",0x1,0x1,(unsigned int)(x|y)==0x1?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x|y)!=(unsigned int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"|",0x2,0x3,(unsigned int)(x|y)==0x3?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x|y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"|",0x7ffffffe,0x7fffffff,(unsigned int)(x|y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x|y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"|",0x7fffffff,0x7fffffff,(unsigned int)(x|y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x|y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"|",0x2,0x2,(unsigned int)(x|y)==0x2?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x|y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"|",0x7ffffffe,0x7ffffffe,(unsigned int)(x|y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x|y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"|",0x7fffffff,0x7fffffff,(unsigned int)(x|y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x|y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"|",0x7ffffffe,0x7ffffffe,(unsigned int)(x|y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x|y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"|",0x7fffffff,0x7fffffff,(unsigned int)(x|y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x|y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"|",0x7fffffff,0x7fffffff,(unsigned int)(x|y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x|y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<<",0x0,0x80000000,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<<",0x1,0x0,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<<",0x2,0x0,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<<",0x0,0x80000001,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<<",0x1,0x2,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<<",0x2,0x4,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<<",0x0,0xfffffffe,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<<",0x1,0xfffffffc,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<<",0x2,0xfffffff8,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<<",0x0,0xffffffff,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<<",0x1,0xfffffffe,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<<",0x2,0xfffffffc,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x0,"<<",0x0,0x0,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x0,"<<",0x1,0x0,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x0,"<<",0x2,0x0,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x1,"<<",0x1,0x2,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x1,"<<",0x2,0x4,(unsigned int)(x< %s (%d)\n",__LINE__,"unsigned int",0x2,"<<",0x2,0x8,(unsigned int)(x<>y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">>",0x0,0x80000000,(unsigned int)(x>>y)==0x80000000?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x>>y)!=(unsigned int)1073741824) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">>",0x1,0x40000000,(unsigned int)(x>>y)==0x40000000?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x>>y)!=(unsigned int)536870912) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">>",0x2,0x20000000,(unsigned int)(x>>y)==0x20000000?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x>>y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">>",0x0,0x80000001,(unsigned int)(x>>y)==0x80000001?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x>>y)!=(unsigned int)1073741824) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">>",0x1,0x40000000,(unsigned int)(x>>y)==0x40000000?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x>>y)!=(unsigned int)536870912) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">>",0x2,0x20000000,(unsigned int)(x>>y)==0x20000000?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x>>y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">>",0x0,0xfffffffe,(unsigned int)(x>>y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x>>y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">>",0x1,0x7fffffff,(unsigned int)(x>>y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x>>y)!=(unsigned int)1073741823) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">>",0x2,0x3fffffff,(unsigned int)(x>>y)==0x3fffffff?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x>>y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">>",0x0,0xffffffff,(unsigned int)(x>>y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x>>y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">>",0x1,0x7fffffff,(unsigned int)(x>>y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x>>y)!=(unsigned int)1073741823) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">>",0x2,0x3fffffff,(unsigned int)(x>>y)==0x3fffffff?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x>>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">>",0x0,0x0,(unsigned int)(x>>y)==0x0?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x>>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">>",0x1,0x0,(unsigned int)(x>>y)==0x0?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x>>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">>",0x2,0x0,(unsigned int)(x>>y)==0x0?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x>>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">>",0x1,0x0,(unsigned int)(x>>y)==0x0?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x>>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">>",0x2,0x0,(unsigned int)(x>>y)==0x0?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x>>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,">>",0x2,0x0,(unsigned int)(x>>y)==0x0?"PASS":"FAIL",(unsigned int)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&&",0x80000000,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&&",0x80000001,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&&",0xfffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&&",0xffffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x&&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&&",0x0,0x0,(unsigned int)(x&&y)==0x0?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&&",0x1,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&&",0x2,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&&",0x7ffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"&&",0x7fffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&&",0x80000001,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&&",0xfffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&&",0xffffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x&&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&&",0x0,0x0,(unsigned int)(x&&y)==0x0?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&&",0x1,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&&",0x2,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&&",0x7ffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"&&",0x7fffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&&",0xfffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&&",0xffffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x&&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&&",0x0,0x0,(unsigned int)(x&&y)==0x0?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&&",0x1,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&&",0x2,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&&",0x7ffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"&&",0x7fffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&&",0xffffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x&&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&&",0x0,0x0,(unsigned int)(x&&y)==0x0?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&&",0x1,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&&",0x2,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&&",0x7ffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"&&",0x7fffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x&&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&&",0x0,0x0,(unsigned int)(x&&y)==0x0?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x&&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&&",0x1,0x0,(unsigned int)(x&&y)==0x0?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x&&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&&",0x2,0x0,(unsigned int)(x&&y)==0x0?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x&&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&&",0x7ffffffe,0x0,(unsigned int)(x&&y)==0x0?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"&&",0x7fffffff,0x0,(unsigned int)(x&&y)==0x0?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"&&",0x1,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"&&",0x2,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"&&",0x7ffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"&&",0x7fffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"&&",0x2,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"&&",0x7ffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"&&",0x7fffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"&&",0x7ffffffe,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"&&",0x7fffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x&&y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"&&",0x7fffffff,0x1,(unsigned int)(x&&y)==0x1?"PASS":"FAIL",(unsigned int)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"||",0x80000000,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"||",0x80000001,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"||",0xfffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"||",0xffffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"||",0x0,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"||",0x1,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"||",0x2,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"||",0x7ffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"||",0x7fffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"||",0x80000001,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"||",0xfffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"||",0xffffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"||",0x0,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"||",0x1,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"||",0x2,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"||",0x7ffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"||",0x7fffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"||",0xfffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"||",0xffffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"||",0x0,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"||",0x1,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"||",0x2,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"||",0x7ffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"||",0x7fffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"||",0xffffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"||",0x0,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"||",0x1,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"||",0x2,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"||",0x7ffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"||",0x7fffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x||y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"||",0x0,0x0,(unsigned int)(x||y)==0x0?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"||",0x1,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"||",0x2,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"||",0x7ffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"||",0x7fffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"||",0x1,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"||",0x2,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"||",0x7ffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"||",0x7fffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"||",0x2,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"||",0x7ffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"||",0x7fffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"||",0x7ffffffe,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"||",0x7fffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x||y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"||",0x7fffffff,0x1,(unsigned int)(x||y)==0x1?"PASS":"FAIL",(unsigned int)(x||y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">",0x80000000,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">",0x80000001,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">",0xfffffffe,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">",0xffffffff,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">",0x0,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">",0x1,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">",0x2,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">",0x7ffffffe,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">",0x7fffffff,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">",0x80000001,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">",0xfffffffe,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">",0xffffffff,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">",0x0,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">",0x1,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">",0x2,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">",0x7ffffffe,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">",0x7fffffff,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">",0xfffffffe,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">",0xffffffff,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">",0x0,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">",0x1,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">",0x2,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">",0x7ffffffe,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">",0x7fffffff,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">",0xffffffff,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">",0x0,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">",0x1,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">",0x2,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">",0x7ffffffe,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x>y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">",0x7fffffff,0x1,(unsigned int)(x>y)==0x1?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">",0x0,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">",0x1,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">",0x2,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">",0x7ffffffe,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">",0x7fffffff,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">",0x1,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">",0x2,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">",0x7ffffffe,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">",0x7fffffff,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,">",0x2,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,">",0x7ffffffe,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,">",0x7fffffff,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,">",0x7ffffffe,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,">",0x7fffffff,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x>y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,">",0x7fffffff,0x0,(unsigned int)(x>y)==0x0?"PASS":"FAIL",(unsigned int)(x>y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<",0x80000000,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<",0x80000001,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<",0xfffffffe,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<",0xffffffff,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<",0x0,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<",0x1,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<",0x2,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<",0x7ffffffe,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<",0x7fffffff,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<",0x80000001,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<",0xfffffffe,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<",0xffffffff,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<",0x0,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<",0x1,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<",0x2,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<",0x7ffffffe,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<",0x7fffffff,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<",0xfffffffe,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<",0xffffffff,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<",0x0,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<",0x1,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<",0x2,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<",0x7ffffffe,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<",0x7fffffff,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<",0xffffffff,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<",0x0,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<",0x1,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<",0x2,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<",0x7ffffffe,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<",0x7fffffff,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x0,"<",0x0,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x0,"<",0x1,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x0,"<",0x2,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x0,"<",0x7ffffffe,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x0,"<",0x7fffffff,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x1,"<",0x1,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x1,"<",0x2,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x1,"<",0x7ffffffe,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x1,"<",0x7fffffff,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x2,"<",0x2,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x2,"<",0x7ffffffe,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x2,"<",0x7fffffff,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"<",0x7ffffffe,0x0,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"<",0x7fffffff,0x1,(unsigned int)(x %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"<",0x7fffffff,0x0,(unsigned int)(x=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">=",0x80000000,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">=",0x80000001,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">=",0xfffffffe,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">=",0xffffffff,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">=",0x0,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">=",0x1,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">=",0x2,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">=",0x7ffffffe,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,">=",0x7fffffff,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">=",0x80000001,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">=",0xfffffffe,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">=",0xffffffff,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">=",0x0,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">=",0x1,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">=",0x2,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">=",0x7ffffffe,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,">=",0x7fffffff,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">=",0xfffffffe,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">=",0xffffffff,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">=",0x0,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">=",0x1,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">=",0x2,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">=",0x7ffffffe,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,">=",0x7fffffff,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">=",0xffffffff,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">=",0x0,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">=",0x1,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">=",0x2,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">=",0x7ffffffe,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,">=",0x7fffffff,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">=",0x0,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">=",0x1,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">=",0x2,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">=",0x7ffffffe,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,">=",0x7fffffff,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">=",0x1,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">=",0x2,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">=",0x7ffffffe,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,">=",0x7fffffff,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,">=",0x2,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,">=",0x7ffffffe,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,">=",0x7fffffff,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,">=",0x7ffffffe,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,">=",0x7fffffff,0x0,(unsigned int)(x>=y)==0x0?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x>=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,">=",0x7fffffff,0x1,(unsigned int)(x>=y)==0x1?"PASS":"FAIL",(unsigned int)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<=",0x80000000,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<=",0x80000001,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<=",0xfffffffe,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<=",0xffffffff,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<=",0x0,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<=",0x1,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<=",0x2,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<=",0x7ffffffe,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"<=",0x7fffffff,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<=",0x80000001,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<=",0xfffffffe,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<=",0xffffffff,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<=",0x0,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<=",0x1,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<=",0x2,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<=",0x7ffffffe,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"<=",0x7fffffff,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<=",0xfffffffe,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<=",0xffffffff,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<=",0x0,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<=",0x1,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<=",0x2,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<=",0x7ffffffe,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"<=",0x7fffffff,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<=",0xffffffff,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<=",0x0,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<=",0x1,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<=",0x2,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<=",0x7ffffffe,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"<=",0x7fffffff,0x0,(unsigned int)(x<=y)==0x0?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"<=",0x0,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"<=",0x1,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"<=",0x2,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"<=",0x7ffffffe,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"<=",0x7fffffff,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"<=",0x1,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"<=",0x2,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"<=",0x7ffffffe,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"<=",0x7fffffff,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"<=",0x2,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"<=",0x7ffffffe,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"<=",0x7fffffff,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"<=",0x7ffffffe,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"<=",0x7fffffff,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x<=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"<=",0x7fffffff,0x1,(unsigned int)(x<=y)==0x1?"PASS":"FAIL",(unsigned int)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x==y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"==",0x80000000,0x1,(unsigned int)(x==y)==0x1?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"==",0x80000001,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"==",0xfffffffe,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"==",0xffffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"==",0x0,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"==",0x1,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"==",0x2,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"==",0x7ffffffe,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"==",0x7fffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x==y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"==",0x80000001,0x1,(unsigned int)(x==y)==0x1?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"==",0xfffffffe,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"==",0xffffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"==",0x0,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"==",0x1,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"==",0x2,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"==",0x7ffffffe,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"==",0x7fffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x==y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"==",0xfffffffe,0x1,(unsigned int)(x==y)==0x1?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"==",0xffffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"==",0x0,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"==",0x1,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"==",0x2,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"==",0x7ffffffe,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"==",0x7fffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x==y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"==",0xffffffff,0x1,(unsigned int)(x==y)==0x1?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"==",0x0,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"==",0x1,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"==",0x2,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"==",0x7ffffffe,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"==",0x7fffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x==y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"==",0x0,0x1,(unsigned int)(x==y)==0x1?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"==",0x1,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"==",0x2,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"==",0x7ffffffe,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"==",0x7fffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x==y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"==",0x1,0x1,(unsigned int)(x==y)==0x1?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"==",0x2,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"==",0x7ffffffe,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"==",0x7fffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x==y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"==",0x2,0x1,(unsigned int)(x==y)==0x1?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"==",0x7ffffffe,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"==",0x7fffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x==y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"==",0x7ffffffe,0x1,(unsigned int)(x==y)==0x1?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x==y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"==",0x7fffffff,0x0,(unsigned int)(x==y)==0x0?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x==y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"==",0x7fffffff,0x1,(unsigned int)(x==y)==0x1?"PASS":"FAIL",(unsigned int)(x==y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x!=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"!=",0x80000000,0x0,(unsigned int)(x!=y)==0x0?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"!=",0x80000001,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"!=",0xfffffffe,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"!=",0xffffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"!=",0x0,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"!=",0x1,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"!=",0x2,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"!=",0x7ffffffe,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"!=",0x7fffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"!=",0x80000001,0x0,(unsigned int)(x!=y)==0x0?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"!=",0xfffffffe,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"!=",0xffffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"!=",0x0,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"!=",0x1,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"!=",0x2,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"!=",0x7ffffffe,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"!=",0x7fffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x!=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"!=",0xfffffffe,0x0,(unsigned int)(x!=y)==0x0?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"!=",0xffffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"!=",0x0,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"!=",0x1,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"!=",0x2,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"!=",0x7ffffffe,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"!=",0x7fffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x!=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"!=",0xffffffff,0x0,(unsigned int)(x!=y)==0x0?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"!=",0x0,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"!=",0x1,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"!=",0x2,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"!=",0x7ffffffe,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"!=",0x7fffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x!=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"!=",0x0,0x0,(unsigned int)(x!=y)==0x0?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"!=",0x1,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"!=",0x2,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"!=",0x7ffffffe,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"!=",0x7fffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x!=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"!=",0x1,0x0,(unsigned int)(x!=y)==0x0?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"!=",0x2,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"!=",0x7ffffffe,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"!=",0x7fffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x!=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"!=",0x2,0x0,(unsigned int)(x!=y)==0x0?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"!=",0x7ffffffe,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"!=",0x7fffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x!=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"!=",0x7ffffffe,0x0,(unsigned int)(x!=y)==0x0?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"!=",0x7fffffff,0x1,(unsigned int)(x!=y)==0x1?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x!=y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"!=",0x7fffffff,0x0,(unsigned int)(x!=y)==0x0?"PASS":"FAIL",(unsigned int)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"*",0x80000000,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x*y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"*",0x80000001,0x80000000,(unsigned int)(x*y)==0x80000000?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"*",0xfffffffe,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-1; + if ((unsigned int)(x*y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"*",0xffffffff,0x80000000,(unsigned int)(x*y)==0x80000000?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=0; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"*",0x0,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x*y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"*",0x1,0x80000000,(unsigned int)(x*y)==0x80000000?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"*",0x2,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"*",0x7ffffffe,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x*y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"*",0x7fffffff,0x80000000,(unsigned int)(x*y)==0x80000000?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x*y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"*",0x80000001,0x1,(unsigned int)(x*y)==0x1?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x*y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"*",0xfffffffe,0xfffffffe,(unsigned int)(x*y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x*y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"*",0xffffffff,0x7fffffff,(unsigned int)(x*y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=0; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"*",0x0,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x*y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"*",0x1,0x80000001,(unsigned int)(x*y)==0x80000001?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x*y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"*",0x2,0x2,(unsigned int)(x*y)==0x2?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x*y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"*",0x7ffffffe,0x7ffffffe,(unsigned int)(x*y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x*y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"*",0x7fffffff,0xffffffff,(unsigned int)(x*y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x*y)!=(unsigned int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"*",0xfffffffe,0x4,(unsigned int)(x*y)==0x4?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x*y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"*",0xffffffff,0x2,(unsigned int)(x*y)==0x2?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=0; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"*",0x0,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x*y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"*",0x1,0xfffffffe,(unsigned int)(x*y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x*y)!=(unsigned int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"*",0x2,0xfffffffc,(unsigned int)(x*y)==0xfffffffc?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x*y)!=(unsigned int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"*",0x7ffffffe,0x4,(unsigned int)(x*y)==0x4?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x*y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"*",0x7fffffff,0x2,(unsigned int)(x*y)==0x2?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x*y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"*",0xffffffff,0x1,(unsigned int)(x*y)==0x1?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=0; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"*",0x0,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x*y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"*",0x1,0xffffffff,(unsigned int)(x*y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x*y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"*",0x2,0xfffffffe,(unsigned int)(x*y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x*y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"*",0x7ffffffe,0x80000002,(unsigned int)(x*y)==0x80000002?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x*y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"*",0x7fffffff,0x80000001,(unsigned int)(x*y)==0x80000001?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=0; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"*",0x0,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"*",0x1,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"*",0x2,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"*",0x7ffffffe,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x*y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"*",0x7fffffff,0x0,(unsigned int)(x*y)==0x0?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x*y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"*",0x1,0x1,(unsigned int)(x*y)==0x1?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x*y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"*",0x2,0x2,(unsigned int)(x*y)==0x2?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x*y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"*",0x7ffffffe,0x7ffffffe,(unsigned int)(x*y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x*y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"*",0x7fffffff,0x7fffffff,(unsigned int)(x*y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x*y)!=(unsigned int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"*",0x2,0x4,(unsigned int)(x*y)==0x4?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x*y)!=(unsigned int)-4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"*",0x7ffffffe,0xfffffffc,(unsigned int)(x*y)==0xfffffffc?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x*y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"*",0x7fffffff,0xfffffffe,(unsigned int)(x*y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x*y)!=(unsigned int)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"*",0x7ffffffe,0x4,(unsigned int)(x*y)==0x4?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x*y)!=(unsigned int)-2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"*",0x7fffffff,0x80000002,(unsigned int)(x*y)==0x80000002?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x*y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"*",0x7fffffff,0x1,(unsigned int)(x*y)==0x1?"PASS":"FAIL",(unsigned int)(x*y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"/",0x80000000,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"/",0x80000001,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"/",0xfffffffe,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x/y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"/",0x1,0x80000000,(unsigned int)(x/y)==0x80000000?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x/y)!=(unsigned int)1073741824) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"/",0x2,0x40000000,(unsigned int)(x/y)==0x40000000?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"/",0x7ffffffe,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"/",0x7fffffff,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"/",0x80000001,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"/",0xfffffffe,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"/",0xffffffff,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x/y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"/",0x1,0x80000001,(unsigned int)(x/y)==0x80000001?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x/y)!=(unsigned int)1073741824) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"/",0x2,0x40000000,(unsigned int)(x/y)==0x40000000?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"/",0x7ffffffe,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"/",0x7fffffff,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"/",0xfffffffe,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"/",0xffffffff,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x/y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"/",0x1,0xfffffffe,(unsigned int)(x/y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x/y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"/",0x2,0x7fffffff,(unsigned int)(x/y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x/y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"/",0x7ffffffe,0x2,(unsigned int)(x/y)==0x2?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x/y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"/",0x7fffffff,0x2,(unsigned int)(x/y)==0x2?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"/",0xffffffff,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x/y)!=(unsigned int)-1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"/",0x1,0xffffffff,(unsigned int)(x/y)==0xffffffff?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x/y)!=(unsigned int)2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"/",0x2,0x7fffffff,(unsigned int)(x/y)==0x7fffffff?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x/y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"/",0x7ffffffe,0x2,(unsigned int)(x/y)==0x2?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x/y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"/",0x7fffffff,0x2,(unsigned int)(x/y)==0x2?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"/",0x1,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"/",0x2,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"/",0x7ffffffe,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"/",0x7fffffff,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"/",0x1,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"/",0x2,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"/",0x7ffffffe,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"/",0x7fffffff,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"/",0x2,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"/",0x7ffffffe,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"/",0x7fffffff,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"/",0x7ffffffe,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x/y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"/",0x7fffffff,0x0,(unsigned int)(x/y)==0x0?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x/y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"/",0x7fffffff,0x1,(unsigned int)(x/y)==0x1?"PASS":"FAIL",(unsigned int)(x/y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483648; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"%",0x80000000,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2147483647; + if ((unsigned int)(x%y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"%",0x80000001,0x80000000,(unsigned int)(x%y)==0x80000000?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=-2; + if ((unsigned int)(x%y)!=(unsigned int)-2147483648) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"%",0xfffffffe,0x80000000,(unsigned int)(x%y)==0x80000000?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=1; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"%",0x1,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"%",0x2,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483646; + if ((unsigned int)(x%y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"%",0x7ffffffe,0x2,(unsigned int)(x%y)==0x2?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483648; volatile unsigned int y=2147483647; + if ((unsigned int)(x%y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000000,"%",0x7fffffff,0x1,(unsigned int)(x%y)==0x1?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2147483647; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"%",0x80000001,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-2; + if ((unsigned int)(x%y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"%",0xfffffffe,0x80000001,(unsigned int)(x%y)==0x80000001?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=-1; + if ((unsigned int)(x%y)!=(unsigned int)-2147483647) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"%",0xffffffff,0x80000001,(unsigned int)(x%y)==0x80000001?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=1; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"%",0x1,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2; + if ((unsigned int)(x%y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"%",0x2,0x1,(unsigned int)(x%y)==0x1?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483646; + if ((unsigned int)(x%y)!=(unsigned int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"%",0x7ffffffe,0x3,(unsigned int)(x%y)==0x3?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x%y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x80000001,"%",0x7fffffff,0x2,(unsigned int)(x%y)==0x2?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-2; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"%",0xfffffffe,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=-1; + if ((unsigned int)(x%y)!=(unsigned int)-2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"%",0xffffffff,0xfffffffe,(unsigned int)(x%y)==0xfffffffe?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=1; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"%",0x1,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"%",0x2,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483646; + if ((unsigned int)(x%y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"%",0x7ffffffe,0x2,(unsigned int)(x%y)==0x2?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-2; volatile unsigned int y=2147483647; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xfffffffe,"%",0x7fffffff,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=-1; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"%",0xffffffff,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=1; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"%",0x1,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2; + if ((unsigned int)(x%y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"%",0x2,0x1,(unsigned int)(x%y)==0x1?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483646; + if ((unsigned int)(x%y)!=(unsigned int)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"%",0x7ffffffe,0x3,(unsigned int)(x%y)==0x3?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=-1; volatile unsigned int y=2147483647; + if ((unsigned int)(x%y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0xffffffff,"%",0x7fffffff,0x1,(unsigned int)(x%y)==0x1?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=1; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"%",0x1,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"%",0x2,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483646; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"%",0x7ffffffe,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=0; volatile unsigned int y=2147483647; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x0,"%",0x7fffffff,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=1; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"%",0x1,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2; + if ((unsigned int)(x%y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"%",0x2,0x1,(unsigned int)(x%y)==0x1?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483646; + if ((unsigned int)(x%y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"%",0x7ffffffe,0x1,(unsigned int)(x%y)==0x1?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=1; volatile unsigned int y=2147483647; + if ((unsigned int)(x%y)!=(unsigned int)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x1,"%",0x7fffffff,0x1,(unsigned int)(x%y)==0x1?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"%",0x2,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483646; + if ((unsigned int)(x%y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"%",0x7ffffffe,0x2,(unsigned int)(x%y)==0x2?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=2; volatile unsigned int y=2147483647; + if ((unsigned int)(x%y)!=(unsigned int)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x2,"%",0x7fffffff,0x2,(unsigned int)(x%y)==0x2?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483646; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"%",0x7ffffffe,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483646; volatile unsigned int y=2147483647; + if ((unsigned int)(x%y)!=(unsigned int)2147483646) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7ffffffe,"%",0x7fffffff,0x7ffffffe,(unsigned int)(x%y)==0x7ffffffe?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned int x=2147483647; volatile unsigned int y=2147483647; + if ((unsigned int)(x%y)!=(unsigned int)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned int",0x7fffffff,"%",0x7fffffff,0x0,(unsigned int)(x%y)==0x0?"PASS":"FAIL",(unsigned int)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x+y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"+",0x8000,0x0,(unsigned short)(x+y)==0x0?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x+y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"+",0x8001,0x1,(unsigned short)(x+y)==0x1?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x+y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"+",0xfffe,0x7ffe,(unsigned short)(x+y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x+y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"+",0xffff,0x7fff,(unsigned short)(x+y)==0x7fff?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x+y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"+",0x0,0x8000,(unsigned short)(x+y)==0x8000?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x+y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"+",0x1,0x8001,(unsigned short)(x+y)==0x8001?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x+y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"+",0x2,0x8002,(unsigned short)(x+y)==0x8002?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x+y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"+",0x7ffe,0xfffe,(unsigned short)(x+y)==0xfffe?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x+y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"+",0x7fff,0xffff,(unsigned short)(x+y)==0xffff?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x+y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"+",0x8001,0x2,(unsigned short)(x+y)==0x2?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x+y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"+",0xfffe,0x7fff,(unsigned short)(x+y)==0x7fff?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x+y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"+",0xffff,0x8000,(unsigned short)(x+y)==0x8000?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x+y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"+",0x0,0x8001,(unsigned short)(x+y)==0x8001?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x+y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"+",0x1,0x8002,(unsigned short)(x+y)==0x8002?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x+y)!=(unsigned short)32771) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"+",0x2,0x8003,(unsigned short)(x+y)==0x8003?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x+y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"+",0x7ffe,0xffff,(unsigned short)(x+y)==0xffff?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x+y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"+",0x7fff,0x0,(unsigned short)(x+y)==0x0?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x+y)!=(unsigned short)65532) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"+",0xfffe,0xfffc,(unsigned short)(x+y)==0xfffc?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x+y)!=(unsigned short)65533) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"+",0xffff,0xfffd,(unsigned short)(x+y)==0xfffd?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x+y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"+",0x0,0xfffe,(unsigned short)(x+y)==0xfffe?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x+y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"+",0x1,0xffff,(unsigned short)(x+y)==0xffff?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x+y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"+",0x2,0x0,(unsigned short)(x+y)==0x0?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x+y)!=(unsigned short)32764) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"+",0x7ffe,0x7ffc,(unsigned short)(x+y)==0x7ffc?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x+y)!=(unsigned short)32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"+",0x7fff,0x7ffd,(unsigned short)(x+y)==0x7ffd?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x+y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"+",0xffff,0xfffe,(unsigned short)(x+y)==0xfffe?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x+y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"+",0x0,0xffff,(unsigned short)(x+y)==0xffff?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x+y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"+",0x1,0x0,(unsigned short)(x+y)==0x0?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x+y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"+",0x2,0x1,(unsigned short)(x+y)==0x1?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x+y)!=(unsigned short)32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"+",0x7ffe,0x7ffd,(unsigned short)(x+y)==0x7ffd?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x+y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"+",0x7fff,0x7ffe,(unsigned short)(x+y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x+y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"+",0x0,0x0,(unsigned short)(x+y)==0x0?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x+y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"+",0x1,0x1,(unsigned short)(x+y)==0x1?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x+y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"+",0x2,0x2,(unsigned short)(x+y)==0x2?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x+y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"+",0x7ffe,0x7ffe,(unsigned short)(x+y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x+y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"+",0x7fff,0x7fff,(unsigned short)(x+y)==0x7fff?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x+y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"+",0x1,0x2,(unsigned short)(x+y)==0x2?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x+y)!=(unsigned short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"+",0x2,0x3,(unsigned short)(x+y)==0x3?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x+y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"+",0x7ffe,0x7fff,(unsigned short)(x+y)==0x7fff?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x+y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"+",0x7fff,0x8000,(unsigned short)(x+y)==0x8000?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x+y)!=(unsigned short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"+",0x2,0x4,(unsigned short)(x+y)==0x4?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x+y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"+",0x7ffe,0x8000,(unsigned short)(x+y)==0x8000?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x+y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"+",0x7fff,0x8001,(unsigned short)(x+y)==0x8001?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x+y)!=(unsigned short)65532) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"+",0x7ffe,0xfffc,(unsigned short)(x+y)==0xfffc?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x+y)!=(unsigned short)65533) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"+",0x7fff,0xfffd,(unsigned short)(x+y)==0xfffd?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x+y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"+",0x7fff,0xfffe,(unsigned short)(x+y)==0xfffe?"PASS":"FAIL",(unsigned short)(x+y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x-y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"-",0x8000,0x0,(unsigned short)(x-y)==0x0?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x-y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"-",0x8001,0xffff,(unsigned short)(x-y)==0xffff?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x-y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"-",0xfffe,0x8002,(unsigned short)(x-y)==0x8002?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x-y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"-",0xffff,0x8001,(unsigned short)(x-y)==0x8001?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x-y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"-",0x0,0x8000,(unsigned short)(x-y)==0x8000?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x-y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"-",0x1,0x7fff,(unsigned short)(x-y)==0x7fff?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x-y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"-",0x2,0x7ffe,(unsigned short)(x-y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x-y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"-",0x7ffe,0x2,(unsigned short)(x-y)==0x2?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x-y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"-",0x7fff,0x1,(unsigned short)(x-y)==0x1?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x-y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"-",0x8001,0x0,(unsigned short)(x-y)==0x0?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x-y)!=(unsigned short)32771) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"-",0xfffe,0x8003,(unsigned short)(x-y)==0x8003?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x-y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"-",0xffff,0x8002,(unsigned short)(x-y)==0x8002?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x-y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"-",0x0,0x8001,(unsigned short)(x-y)==0x8001?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x-y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"-",0x1,0x8000,(unsigned short)(x-y)==0x8000?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x-y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"-",0x2,0x7fff,(unsigned short)(x-y)==0x7fff?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x-y)!=(unsigned short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"-",0x7ffe,0x3,(unsigned short)(x-y)==0x3?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x-y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"-",0x7fff,0x2,(unsigned short)(x-y)==0x2?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x-y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"-",0xfffe,0x0,(unsigned short)(x-y)==0x0?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x-y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"-",0xffff,0xffff,(unsigned short)(x-y)==0xffff?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x-y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"-",0x0,0xfffe,(unsigned short)(x-y)==0xfffe?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x-y)!=(unsigned short)65533) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"-",0x1,0xfffd,(unsigned short)(x-y)==0xfffd?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x-y)!=(unsigned short)65532) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"-",0x2,0xfffc,(unsigned short)(x-y)==0xfffc?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x-y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"-",0x7ffe,0x8000,(unsigned short)(x-y)==0x8000?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x-y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"-",0x7fff,0x7fff,(unsigned short)(x-y)==0x7fff?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x-y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"-",0xffff,0x0,(unsigned short)(x-y)==0x0?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x-y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"-",0x0,0xffff,(unsigned short)(x-y)==0xffff?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x-y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"-",0x1,0xfffe,(unsigned short)(x-y)==0xfffe?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x-y)!=(unsigned short)65533) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"-",0x2,0xfffd,(unsigned short)(x-y)==0xfffd?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x-y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"-",0x7ffe,0x8001,(unsigned short)(x-y)==0x8001?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x-y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"-",0x7fff,0x8000,(unsigned short)(x-y)==0x8000?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x-y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"-",0x0,0x0,(unsigned short)(x-y)==0x0?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x-y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"-",0x1,0xffff,(unsigned short)(x-y)==0xffff?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x-y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"-",0x2,0xfffe,(unsigned short)(x-y)==0xfffe?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x-y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"-",0x7ffe,0x8002,(unsigned short)(x-y)==0x8002?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x-y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"-",0x7fff,0x8001,(unsigned short)(x-y)==0x8001?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x-y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"-",0x1,0x0,(unsigned short)(x-y)==0x0?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x-y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"-",0x2,0xffff,(unsigned short)(x-y)==0xffff?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x-y)!=(unsigned short)32771) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"-",0x7ffe,0x8003,(unsigned short)(x-y)==0x8003?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x-y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"-",0x7fff,0x8002,(unsigned short)(x-y)==0x8002?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x-y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"-",0x2,0x0,(unsigned short)(x-y)==0x0?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x-y)!=(unsigned short)32772) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"-",0x7ffe,0x8004,(unsigned short)(x-y)==0x8004?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x-y)!=(unsigned short)32771) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"-",0x7fff,0x8003,(unsigned short)(x-y)==0x8003?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x-y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"-",0x7ffe,0x0,(unsigned short)(x-y)==0x0?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x-y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"-",0x7fff,0xffff,(unsigned short)(x-y)==0xffff?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x-y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"-",0x7fff,0x0,(unsigned short)(x-y)==0x0?"PASS":"FAIL",(unsigned short)(x-y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x^y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"^",0x8000,0x0,(unsigned short)(x^y)==0x0?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x^y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"^",0x8001,0x1,(unsigned short)(x^y)==0x1?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x^y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"^",0xfffe,0x7ffe,(unsigned short)(x^y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x^y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"^",0xffff,0x7fff,(unsigned short)(x^y)==0x7fff?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x^y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"^",0x0,0x8000,(unsigned short)(x^y)==0x8000?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x^y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"^",0x1,0x8001,(unsigned short)(x^y)==0x8001?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x^y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"^",0x2,0x8002,(unsigned short)(x^y)==0x8002?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x^y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"^",0x7ffe,0xfffe,(unsigned short)(x^y)==0xfffe?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x^y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"^",0x7fff,0xffff,(unsigned short)(x^y)==0xffff?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x^y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"^",0x8001,0x0,(unsigned short)(x^y)==0x0?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x^y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"^",0xfffe,0x7fff,(unsigned short)(x^y)==0x7fff?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x^y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"^",0xffff,0x7ffe,(unsigned short)(x^y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x^y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"^",0x0,0x8001,(unsigned short)(x^y)==0x8001?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x^y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"^",0x1,0x8000,(unsigned short)(x^y)==0x8000?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x^y)!=(unsigned short)32771) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"^",0x2,0x8003,(unsigned short)(x^y)==0x8003?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x^y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"^",0x7ffe,0xffff,(unsigned short)(x^y)==0xffff?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x^y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"^",0x7fff,0xfffe,(unsigned short)(x^y)==0xfffe?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x^y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"^",0xfffe,0x0,(unsigned short)(x^y)==0x0?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x^y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"^",0xffff,0x1,(unsigned short)(x^y)==0x1?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x^y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"^",0x0,0xfffe,(unsigned short)(x^y)==0xfffe?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x^y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"^",0x1,0xffff,(unsigned short)(x^y)==0xffff?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x^y)!=(unsigned short)65532) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"^",0x2,0xfffc,(unsigned short)(x^y)==0xfffc?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x^y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"^",0x7ffe,0x8000,(unsigned short)(x^y)==0x8000?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x^y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"^",0x7fff,0x8001,(unsigned short)(x^y)==0x8001?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x^y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"^",0xffff,0x0,(unsigned short)(x^y)==0x0?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x^y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"^",0x0,0xffff,(unsigned short)(x^y)==0xffff?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x^y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"^",0x1,0xfffe,(unsigned short)(x^y)==0xfffe?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x^y)!=(unsigned short)65533) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"^",0x2,0xfffd,(unsigned short)(x^y)==0xfffd?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x^y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"^",0x7ffe,0x8001,(unsigned short)(x^y)==0x8001?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x^y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"^",0x7fff,0x8000,(unsigned short)(x^y)==0x8000?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x^y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"^",0x0,0x0,(unsigned short)(x^y)==0x0?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x^y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"^",0x1,0x1,(unsigned short)(x^y)==0x1?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x^y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"^",0x2,0x2,(unsigned short)(x^y)==0x2?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x^y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"^",0x7ffe,0x7ffe,(unsigned short)(x^y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x^y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"^",0x7fff,0x7fff,(unsigned short)(x^y)==0x7fff?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x^y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"^",0x1,0x0,(unsigned short)(x^y)==0x0?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x^y)!=(unsigned short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"^",0x2,0x3,(unsigned short)(x^y)==0x3?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x^y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"^",0x7ffe,0x7fff,(unsigned short)(x^y)==0x7fff?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x^y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"^",0x7fff,0x7ffe,(unsigned short)(x^y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x^y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"^",0x2,0x0,(unsigned short)(x^y)==0x0?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x^y)!=(unsigned short)32764) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"^",0x7ffe,0x7ffc,(unsigned short)(x^y)==0x7ffc?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x^y)!=(unsigned short)32765) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"^",0x7fff,0x7ffd,(unsigned short)(x^y)==0x7ffd?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x^y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"^",0x7ffe,0x0,(unsigned short)(x^y)==0x0?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x^y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"^",0x7fff,0x1,(unsigned short)(x^y)==0x1?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x^y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"^",0x7fff,0x0,(unsigned short)(x^y)==0x0?"PASS":"FAIL",(unsigned short)(x^y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x&y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&",0x8000,0x8000,(unsigned short)(x&y)==0x8000?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x&y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&",0x8001,0x8000,(unsigned short)(x&y)==0x8000?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x&y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&",0xfffe,0x8000,(unsigned short)(x&y)==0x8000?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x&y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&",0xffff,0x8000,(unsigned short)(x&y)==0x8000?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&",0x0,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&",0x1,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&",0x2,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&",0x7ffe,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&",0x7fff,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x&y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&",0x8001,0x8001,(unsigned short)(x&y)==0x8001?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x&y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&",0xfffe,0x8000,(unsigned short)(x&y)==0x8000?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x&y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&",0xffff,0x8001,(unsigned short)(x&y)==0x8001?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&",0x0,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&",0x1,0x1,(unsigned short)(x&y)==0x1?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&",0x2,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&",0x7ffe,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&",0x7fff,0x1,(unsigned short)(x&y)==0x1?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x&y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&",0xfffe,0xfffe,(unsigned short)(x&y)==0xfffe?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x&y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&",0xffff,0xfffe,(unsigned short)(x&y)==0xfffe?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&",0x0,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&",0x1,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x&y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&",0x2,0x2,(unsigned short)(x&y)==0x2?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x&y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&",0x7ffe,0x7ffe,(unsigned short)(x&y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x&y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&",0x7fff,0x7ffe,(unsigned short)(x&y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x&y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&",0xffff,0xffff,(unsigned short)(x&y)==0xffff?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&",0x0,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&",0x1,0x1,(unsigned short)(x&y)==0x1?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x&y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&",0x2,0x2,(unsigned short)(x&y)==0x2?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x&y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&",0x7ffe,0x7ffe,(unsigned short)(x&y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x&y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&",0x7fff,0x7fff,(unsigned short)(x&y)==0x7fff?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&",0x0,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&",0x1,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&",0x2,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&",0x7ffe,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&",0x7fff,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"&",0x1,0x1,(unsigned short)(x&y)==0x1?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"&",0x2,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"&",0x7ffe,0x0,(unsigned short)(x&y)==0x0?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"&",0x7fff,0x1,(unsigned short)(x&y)==0x1?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x&y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"&",0x2,0x2,(unsigned short)(x&y)==0x2?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x&y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"&",0x7ffe,0x2,(unsigned short)(x&y)==0x2?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x&y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"&",0x7fff,0x2,(unsigned short)(x&y)==0x2?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x&y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"&",0x7ffe,0x7ffe,(unsigned short)(x&y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x&y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"&",0x7fff,0x7ffe,(unsigned short)(x&y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x&y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"&",0x7fff,0x7fff,(unsigned short)(x&y)==0x7fff?"PASS":"FAIL",(unsigned short)(x&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x|y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"|",0x8000,0x8000,(unsigned short)(x|y)==0x8000?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x|y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"|",0x8001,0x8001,(unsigned short)(x|y)==0x8001?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x|y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"|",0xfffe,0xfffe,(unsigned short)(x|y)==0xfffe?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"|",0xffff,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x|y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"|",0x0,0x8000,(unsigned short)(x|y)==0x8000?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x|y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"|",0x1,0x8001,(unsigned short)(x|y)==0x8001?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x|y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"|",0x2,0x8002,(unsigned short)(x|y)==0x8002?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x|y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"|",0x7ffe,0xfffe,(unsigned short)(x|y)==0xfffe?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"|",0x7fff,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x|y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"|",0x8001,0x8001,(unsigned short)(x|y)==0x8001?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"|",0xfffe,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"|",0xffff,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x|y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"|",0x0,0x8001,(unsigned short)(x|y)==0x8001?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x|y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"|",0x1,0x8001,(unsigned short)(x|y)==0x8001?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x|y)!=(unsigned short)32771) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"|",0x2,0x8003,(unsigned short)(x|y)==0x8003?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"|",0x7ffe,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"|",0x7fff,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x|y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"|",0xfffe,0xfffe,(unsigned short)(x|y)==0xfffe?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"|",0xffff,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x|y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"|",0x0,0xfffe,(unsigned short)(x|y)==0xfffe?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"|",0x1,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x|y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"|",0x2,0xfffe,(unsigned short)(x|y)==0xfffe?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x|y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"|",0x7ffe,0xfffe,(unsigned short)(x|y)==0xfffe?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"|",0x7fff,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"|",0xffff,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"|",0x0,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"|",0x1,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"|",0x2,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"|",0x7ffe,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x|y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"|",0x7fff,0xffff,(unsigned short)(x|y)==0xffff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x|y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"|",0x0,0x0,(unsigned short)(x|y)==0x0?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x|y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"|",0x1,0x1,(unsigned short)(x|y)==0x1?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x|y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"|",0x2,0x2,(unsigned short)(x|y)==0x2?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x|y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"|",0x7ffe,0x7ffe,(unsigned short)(x|y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x|y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"|",0x7fff,0x7fff,(unsigned short)(x|y)==0x7fff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x|y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"|",0x1,0x1,(unsigned short)(x|y)==0x1?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x|y)!=(unsigned short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"|",0x2,0x3,(unsigned short)(x|y)==0x3?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x|y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"|",0x7ffe,0x7fff,(unsigned short)(x|y)==0x7fff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x|y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"|",0x7fff,0x7fff,(unsigned short)(x|y)==0x7fff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x|y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"|",0x2,0x2,(unsigned short)(x|y)==0x2?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x|y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"|",0x7ffe,0x7ffe,(unsigned short)(x|y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x|y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"|",0x7fff,0x7fff,(unsigned short)(x|y)==0x7fff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x|y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"|",0x7ffe,0x7ffe,(unsigned short)(x|y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x|y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"|",0x7fff,0x7fff,(unsigned short)(x|y)==0x7fff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x|y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"|",0x7fff,0x7fff,(unsigned short)(x|y)==0x7fff?"PASS":"FAIL",(unsigned short)(x|y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x8000,"<<",0x0,0x8000,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x8000,"<<",0x1,0x0,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x8000,"<<",0x2,0x0,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x8001,"<<",0x0,0x8001,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x8001,"<<",0x1,0x2,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x8001,"<<",0x2,0x4,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<<",0x0,0xfffe,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<<",0x1,0xfffc,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<<",0x2,0xfff8,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0xffff,"<<",0x0,0xffff,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0xffff,"<<",0x1,0xfffe,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0xffff,"<<",0x2,0xfffc,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x0,"<<",0x0,0x0,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x0,"<<",0x1,0x0,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x0,"<<",0x2,0x0,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x1,"<<",0x1,0x2,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x1,"<<",0x2,0x4,(unsigned short)(x< %s (%d)\n",__LINE__,"unsigned short",0x2,"<<",0x2,0x8,(unsigned short)(x<>y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">>",0x0,0x8000,(unsigned short)(x>>y)==0x8000?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x>>y)!=(unsigned short)16384) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">>",0x1,0x4000,(unsigned short)(x>>y)==0x4000?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x>>y)!=(unsigned short)8192) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">>",0x2,0x2000,(unsigned short)(x>>y)==0x2000?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x>>y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">>",0x0,0x8001,(unsigned short)(x>>y)==0x8001?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x>>y)!=(unsigned short)16384) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">>",0x1,0x4000,(unsigned short)(x>>y)==0x4000?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x>>y)!=(unsigned short)8192) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">>",0x2,0x2000,(unsigned short)(x>>y)==0x2000?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x>>y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">>",0x0,0xfffe,(unsigned short)(x>>y)==0xfffe?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x>>y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">>",0x1,0x7fff,(unsigned short)(x>>y)==0x7fff?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x>>y)!=(unsigned short)16383) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">>",0x2,0x3fff,(unsigned short)(x>>y)==0x3fff?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x>>y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">>",0x0,0xffff,(unsigned short)(x>>y)==0xffff?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x>>y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">>",0x1,0x7fff,(unsigned short)(x>>y)==0x7fff?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x>>y)!=(unsigned short)16383) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">>",0x2,0x3fff,(unsigned short)(x>>y)==0x3fff?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x>>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">>",0x0,0x0,(unsigned short)(x>>y)==0x0?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x>>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">>",0x1,0x0,(unsigned short)(x>>y)==0x0?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x>>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">>",0x2,0x0,(unsigned short)(x>>y)==0x0?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x>>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">>",0x1,0x0,(unsigned short)(x>>y)==0x0?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x>>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">>",0x2,0x0,(unsigned short)(x>>y)==0x0?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x>>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,">>",0x2,0x0,(unsigned short)(x>>y)==0x0?"PASS":"FAIL",(unsigned short)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&&",0x8000,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&&",0x8001,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&&",0xfffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&&",0xffff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x&&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&&",0x0,0x0,(unsigned short)(x&&y)==0x0?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&&",0x1,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&&",0x2,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&&",0x7ffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"&&",0x7fff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&&",0x8001,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&&",0xfffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&&",0xffff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x&&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&&",0x0,0x0,(unsigned short)(x&&y)==0x0?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&&",0x1,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&&",0x2,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&&",0x7ffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"&&",0x7fff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&&",0xfffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&&",0xffff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x&&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&&",0x0,0x0,(unsigned short)(x&&y)==0x0?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&&",0x1,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&&",0x2,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&&",0x7ffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"&&",0x7fff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&&",0xffff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x&&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&&",0x0,0x0,(unsigned short)(x&&y)==0x0?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&&",0x1,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&&",0x2,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&&",0x7ffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"&&",0x7fff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x&&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&&",0x0,0x0,(unsigned short)(x&&y)==0x0?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x&&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&&",0x1,0x0,(unsigned short)(x&&y)==0x0?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x&&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&&",0x2,0x0,(unsigned short)(x&&y)==0x0?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x&&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&&",0x7ffe,0x0,(unsigned short)(x&&y)==0x0?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x&&y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"&&",0x7fff,0x0,(unsigned short)(x&&y)==0x0?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"&&",0x1,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"&&",0x2,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"&&",0x7ffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"&&",0x7fff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"&&",0x2,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"&&",0x7ffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"&&",0x7fff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"&&",0x7ffe,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"&&",0x7fff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x&&y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"&&",0x7fff,0x1,(unsigned short)(x&&y)==0x1?"PASS":"FAIL",(unsigned short)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"||",0x8000,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"||",0x8001,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"||",0xfffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"||",0xffff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"||",0x0,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"||",0x1,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"||",0x2,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"||",0x7ffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"||",0x7fff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"||",0x8001,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"||",0xfffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"||",0xffff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"||",0x0,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"||",0x1,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"||",0x2,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"||",0x7ffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"||",0x7fff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"||",0xfffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"||",0xffff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"||",0x0,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"||",0x1,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"||",0x2,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"||",0x7ffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"||",0x7fff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"||",0xffff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"||",0x0,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"||",0x1,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"||",0x2,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"||",0x7ffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"||",0x7fff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x||y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"||",0x0,0x0,(unsigned short)(x||y)==0x0?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"||",0x1,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"||",0x2,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"||",0x7ffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"||",0x7fff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"||",0x1,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"||",0x2,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"||",0x7ffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"||",0x7fff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"||",0x2,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"||",0x7ffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"||",0x7fff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"||",0x7ffe,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"||",0x7fff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x||y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"||",0x7fff,0x1,(unsigned short)(x||y)==0x1?"PASS":"FAIL",(unsigned short)(x||y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">",0x8000,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">",0x8001,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">",0xfffe,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">",0xffff,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">",0x0,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">",0x1,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">",0x2,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">",0x7ffe,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">",0x7fff,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">",0x8001,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">",0xfffe,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">",0xffff,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">",0x0,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">",0x1,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">",0x2,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">",0x7ffe,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">",0x7fff,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">",0xfffe,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">",0xffff,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">",0x0,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">",0x1,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">",0x2,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">",0x7ffe,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">",0x7fff,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">",0xffff,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">",0x0,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">",0x1,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">",0x2,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">",0x7ffe,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x>y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">",0x7fff,0x1,(unsigned short)(x>y)==0x1?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">",0x0,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">",0x1,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">",0x2,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">",0x7ffe,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">",0x7fff,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">",0x1,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">",0x2,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">",0x7ffe,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">",0x7fff,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,">",0x2,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,">",0x7ffe,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,">",0x7fff,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,">",0x7ffe,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,">",0x7fff,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x>y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,">",0x7fff,0x0,(unsigned short)(x>y)==0x0?"PASS":"FAIL",(unsigned short)(x>y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8000,"<",0x8000,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8000,"<",0x8001,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8000,"<",0xfffe,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8000,"<",0xffff,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8000,"<",0x0,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8000,"<",0x1,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8000,"<",0x2,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8000,"<",0x7ffe,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8000,"<",0x7fff,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8001,"<",0x8001,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8001,"<",0xfffe,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8001,"<",0xffff,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8001,"<",0x0,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8001,"<",0x1,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8001,"<",0x2,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8001,"<",0x7ffe,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x8001,"<",0x7fff,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<",0xfffe,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<",0xffff,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<",0x0,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<",0x1,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<",0x2,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<",0x7ffe,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<",0x7fff,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xffff,"<",0xffff,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xffff,"<",0x0,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xffff,"<",0x1,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xffff,"<",0x2,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xffff,"<",0x7ffe,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0xffff,"<",0x7fff,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x0,"<",0x0,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x0,"<",0x1,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x0,"<",0x2,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x0,"<",0x7ffe,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x0,"<",0x7fff,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x1,"<",0x1,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x1,"<",0x2,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x1,"<",0x7ffe,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x1,"<",0x7fff,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x2,"<",0x2,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x2,"<",0x7ffe,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x2,"<",0x7fff,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"<",0x7ffe,0x0,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"<",0x7fff,0x1,(unsigned short)(x %s (%d)\n",__LINE__,"unsigned short",0x7fff,"<",0x7fff,0x0,(unsigned short)(x=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">=",0x8000,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">=",0x8001,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">=",0xfffe,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">=",0xffff,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">=",0x0,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">=",0x1,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">=",0x2,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">=",0x7ffe,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,">=",0x7fff,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">=",0x8001,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">=",0xfffe,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">=",0xffff,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">=",0x0,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">=",0x1,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">=",0x2,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">=",0x7ffe,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,">=",0x7fff,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">=",0xfffe,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">=",0xffff,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">=",0x0,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">=",0x1,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">=",0x2,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">=",0x7ffe,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,">=",0x7fff,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">=",0xffff,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">=",0x0,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">=",0x1,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">=",0x2,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">=",0x7ffe,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,">=",0x7fff,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">=",0x0,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">=",0x1,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">=",0x2,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">=",0x7ffe,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,">=",0x7fff,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">=",0x1,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">=",0x2,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">=",0x7ffe,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,">=",0x7fff,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,">=",0x2,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,">=",0x7ffe,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,">=",0x7fff,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,">=",0x7ffe,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x>=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,">=",0x7fff,0x0,(unsigned short)(x>=y)==0x0?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x>=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,">=",0x7fff,0x1,(unsigned short)(x>=y)==0x1?"PASS":"FAIL",(unsigned short)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"<=",0x8000,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"<=",0x8001,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"<=",0xfffe,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"<=",0xffff,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"<=",0x0,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"<=",0x1,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"<=",0x2,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"<=",0x7ffe,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"<=",0x7fff,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"<=",0x8001,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"<=",0xfffe,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"<=",0xffff,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"<=",0x0,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"<=",0x1,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"<=",0x2,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"<=",0x7ffe,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"<=",0x7fff,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<=",0xfffe,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<=",0xffff,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<=",0x0,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<=",0x1,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<=",0x2,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<=",0x7ffe,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"<=",0x7fff,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"<=",0xffff,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"<=",0x0,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"<=",0x1,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"<=",0x2,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"<=",0x7ffe,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x<=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"<=",0x7fff,0x0,(unsigned short)(x<=y)==0x0?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"<=",0x0,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"<=",0x1,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"<=",0x2,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"<=",0x7ffe,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"<=",0x7fff,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"<=",0x1,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"<=",0x2,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"<=",0x7ffe,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"<=",0x7fff,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"<=",0x2,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"<=",0x7ffe,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"<=",0x7fff,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"<=",0x7ffe,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"<=",0x7fff,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x<=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"<=",0x7fff,0x1,(unsigned short)(x<=y)==0x1?"PASS":"FAIL",(unsigned short)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x==y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"==",0x8000,0x1,(unsigned short)(x==y)==0x1?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"==",0x8001,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"==",0xfffe,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"==",0xffff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"==",0x0,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"==",0x1,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"==",0x2,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"==",0x7ffe,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"==",0x7fff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x==y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"==",0x8001,0x1,(unsigned short)(x==y)==0x1?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"==",0xfffe,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"==",0xffff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"==",0x0,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"==",0x1,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"==",0x2,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"==",0x7ffe,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"==",0x7fff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x==y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"==",0xfffe,0x1,(unsigned short)(x==y)==0x1?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"==",0xffff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"==",0x0,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"==",0x1,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"==",0x2,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"==",0x7ffe,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"==",0x7fff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x==y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"==",0xffff,0x1,(unsigned short)(x==y)==0x1?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"==",0x0,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"==",0x1,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"==",0x2,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"==",0x7ffe,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"==",0x7fff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x==y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"==",0x0,0x1,(unsigned short)(x==y)==0x1?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"==",0x1,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"==",0x2,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"==",0x7ffe,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"==",0x7fff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x==y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"==",0x1,0x1,(unsigned short)(x==y)==0x1?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"==",0x2,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"==",0x7ffe,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"==",0x7fff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x==y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"==",0x2,0x1,(unsigned short)(x==y)==0x1?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"==",0x7ffe,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"==",0x7fff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x==y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"==",0x7ffe,0x1,(unsigned short)(x==y)==0x1?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x==y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"==",0x7fff,0x0,(unsigned short)(x==y)==0x0?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x==y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"==",0x7fff,0x1,(unsigned short)(x==y)==0x1?"PASS":"FAIL",(unsigned short)(x==y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x!=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"!=",0x8000,0x0,(unsigned short)(x!=y)==0x0?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"!=",0x8001,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"!=",0xfffe,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"!=",0xffff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"!=",0x0,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"!=",0x1,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"!=",0x2,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"!=",0x7ffe,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"!=",0x7fff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x!=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"!=",0x8001,0x0,(unsigned short)(x!=y)==0x0?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"!=",0xfffe,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"!=",0xffff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"!=",0x0,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"!=",0x1,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"!=",0x2,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"!=",0x7ffe,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"!=",0x7fff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x!=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"!=",0xfffe,0x0,(unsigned short)(x!=y)==0x0?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"!=",0xffff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"!=",0x0,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"!=",0x1,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"!=",0x2,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"!=",0x7ffe,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"!=",0x7fff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x!=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"!=",0xffff,0x0,(unsigned short)(x!=y)==0x0?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"!=",0x0,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"!=",0x1,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"!=",0x2,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"!=",0x7ffe,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"!=",0x7fff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x!=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"!=",0x0,0x0,(unsigned short)(x!=y)==0x0?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"!=",0x1,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"!=",0x2,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"!=",0x7ffe,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"!=",0x7fff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x!=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"!=",0x1,0x0,(unsigned short)(x!=y)==0x0?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"!=",0x2,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"!=",0x7ffe,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"!=",0x7fff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x!=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"!=",0x2,0x0,(unsigned short)(x!=y)==0x0?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"!=",0x7ffe,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"!=",0x7fff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x!=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"!=",0x7ffe,0x0,(unsigned short)(x!=y)==0x0?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x!=y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"!=",0x7fff,0x1,(unsigned short)(x!=y)==0x1?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x!=y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"!=",0x7fff,0x0,(unsigned short)(x!=y)==0x0?"PASS":"FAIL",(unsigned short)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"*",0x8000,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x*y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"*",0x8001,0x8000,(unsigned short)(x*y)==0x8000?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"*",0xfffe,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x*y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"*",0xffff,0x8000,(unsigned short)(x*y)==0x8000?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=0; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"*",0x0,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x*y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"*",0x1,0x8000,(unsigned short)(x*y)==0x8000?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"*",0x2,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"*",0x7ffe,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x*y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"*",0x7fff,0x8000,(unsigned short)(x*y)==0x8000?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x*y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"*",0x8001,0x1,(unsigned short)(x*y)==0x1?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x*y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"*",0xfffe,0xfffe,(unsigned short)(x*y)==0xfffe?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x*y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"*",0xffff,0x7fff,(unsigned short)(x*y)==0x7fff?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=0; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"*",0x0,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x*y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"*",0x1,0x8001,(unsigned short)(x*y)==0x8001?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x*y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"*",0x2,0x2,(unsigned short)(x*y)==0x2?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x*y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"*",0x7ffe,0x7ffe,(unsigned short)(x*y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x*y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"*",0x7fff,0xffff,(unsigned short)(x*y)==0xffff?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x*y)!=(unsigned short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"*",0xfffe,0x4,(unsigned short)(x*y)==0x4?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x*y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"*",0xffff,0x2,(unsigned short)(x*y)==0x2?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=0; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"*",0x0,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x*y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"*",0x1,0xfffe,(unsigned short)(x*y)==0xfffe?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x*y)!=(unsigned short)65532) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"*",0x2,0xfffc,(unsigned short)(x*y)==0xfffc?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x*y)!=(unsigned short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"*",0x7ffe,0x4,(unsigned short)(x*y)==0x4?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x*y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"*",0x7fff,0x2,(unsigned short)(x*y)==0x2?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x*y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"*",0xffff,0x1,(unsigned short)(x*y)==0x1?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=0; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"*",0x0,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x*y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"*",0x1,0xffff,(unsigned short)(x*y)==0xffff?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x*y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"*",0x2,0xfffe,(unsigned short)(x*y)==0xfffe?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x*y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"*",0x7ffe,0x8002,(unsigned short)(x*y)==0x8002?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x*y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"*",0x7fff,0x8001,(unsigned short)(x*y)==0x8001?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=0; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"*",0x0,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"*",0x1,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"*",0x2,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"*",0x7ffe,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x*y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"*",0x7fff,0x0,(unsigned short)(x*y)==0x0?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x*y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"*",0x1,0x1,(unsigned short)(x*y)==0x1?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x*y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"*",0x2,0x2,(unsigned short)(x*y)==0x2?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x*y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"*",0x7ffe,0x7ffe,(unsigned short)(x*y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x*y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"*",0x7fff,0x7fff,(unsigned short)(x*y)==0x7fff?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x*y)!=(unsigned short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"*",0x2,0x4,(unsigned short)(x*y)==0x4?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x*y)!=(unsigned short)65532) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"*",0x7ffe,0xfffc,(unsigned short)(x*y)==0xfffc?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x*y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"*",0x7fff,0xfffe,(unsigned short)(x*y)==0xfffe?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x*y)!=(unsigned short)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"*",0x7ffe,0x4,(unsigned short)(x*y)==0x4?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x*y)!=(unsigned short)32770) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"*",0x7fff,0x8002,(unsigned short)(x*y)==0x8002?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x*y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"*",0x7fff,0x1,(unsigned short)(x*y)==0x1?"PASS":"FAIL",(unsigned short)(x*y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"/",0x8000,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"/",0x8001,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"/",0xfffe,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"/",0xffff,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x/y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"/",0x1,0x8000,(unsigned short)(x/y)==0x8000?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x/y)!=(unsigned short)16384) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"/",0x2,0x4000,(unsigned short)(x/y)==0x4000?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"/",0x7ffe,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"/",0x7fff,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"/",0x8001,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"/",0xfffe,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"/",0xffff,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x/y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"/",0x1,0x8001,(unsigned short)(x/y)==0x8001?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x/y)!=(unsigned short)16384) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"/",0x2,0x4000,(unsigned short)(x/y)==0x4000?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"/",0x7ffe,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"/",0x7fff,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"/",0xfffe,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"/",0xffff,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x/y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"/",0x1,0xfffe,(unsigned short)(x/y)==0xfffe?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x/y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"/",0x2,0x7fff,(unsigned short)(x/y)==0x7fff?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x/y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"/",0x7ffe,0x2,(unsigned short)(x/y)==0x2?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x/y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"/",0x7fff,0x2,(unsigned short)(x/y)==0x2?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"/",0xffff,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x/y)!=(unsigned short)65535) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"/",0x1,0xffff,(unsigned short)(x/y)==0xffff?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x/y)!=(unsigned short)32767) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"/",0x2,0x7fff,(unsigned short)(x/y)==0x7fff?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x/y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"/",0x7ffe,0x2,(unsigned short)(x/y)==0x2?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x/y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"/",0x7fff,0x2,(unsigned short)(x/y)==0x2?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"/",0x1,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"/",0x2,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"/",0x7ffe,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"/",0x7fff,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"/",0x1,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"/",0x2,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"/",0x7ffe,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"/",0x7fff,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"/",0x2,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"/",0x7ffe,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"/",0x7fff,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"/",0x7ffe,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x/y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"/",0x7fff,0x0,(unsigned short)(x/y)==0x0?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x/y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"/",0x7fff,0x1,(unsigned short)(x/y)==0x1?"PASS":"FAIL",(unsigned short)(x/y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32768; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"%",0x8000,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32769; + if ((unsigned short)(x%y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"%",0x8001,0x8000,(unsigned short)(x%y)==0x8000?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65534; + if ((unsigned short)(x%y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"%",0xfffe,0x8000,(unsigned short)(x%y)==0x8000?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=65535; + if ((unsigned short)(x%y)!=(unsigned short)32768) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"%",0xffff,0x8000,(unsigned short)(x%y)==0x8000?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=1; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"%",0x1,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=2; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"%",0x2,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32766; + if ((unsigned short)(x%y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"%",0x7ffe,0x2,(unsigned short)(x%y)==0x2?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32768; volatile unsigned short y=32767; + if ((unsigned short)(x%y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8000,"%",0x7fff,0x1,(unsigned short)(x%y)==0x1?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32769; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"%",0x8001,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65534; + if ((unsigned short)(x%y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"%",0xfffe,0x8001,(unsigned short)(x%y)==0x8001?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=65535; + if ((unsigned short)(x%y)!=(unsigned short)32769) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"%",0xffff,0x8001,(unsigned short)(x%y)==0x8001?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=1; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"%",0x1,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=2; + if ((unsigned short)(x%y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"%",0x2,0x1,(unsigned short)(x%y)==0x1?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32766; + if ((unsigned short)(x%y)!=(unsigned short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"%",0x7ffe,0x3,(unsigned short)(x%y)==0x3?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32769; volatile unsigned short y=32767; + if ((unsigned short)(x%y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x8001,"%",0x7fff,0x2,(unsigned short)(x%y)==0x2?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65534; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"%",0xfffe,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=65535; + if ((unsigned short)(x%y)!=(unsigned short)65534) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"%",0xffff,0xfffe,(unsigned short)(x%y)==0xfffe?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=1; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"%",0x1,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=2; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"%",0x2,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32766; + if ((unsigned short)(x%y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"%",0x7ffe,0x2,(unsigned short)(x%y)==0x2?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65534; volatile unsigned short y=32767; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xfffe,"%",0x7fff,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=65535; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"%",0xffff,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=1; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"%",0x1,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=2; + if ((unsigned short)(x%y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"%",0x2,0x1,(unsigned short)(x%y)==0x1?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32766; + if ((unsigned short)(x%y)!=(unsigned short)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"%",0x7ffe,0x3,(unsigned short)(x%y)==0x3?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=65535; volatile unsigned short y=32767; + if ((unsigned short)(x%y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0xffff,"%",0x7fff,0x1,(unsigned short)(x%y)==0x1?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=1; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"%",0x1,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=2; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"%",0x2,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32766; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"%",0x7ffe,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=0; volatile unsigned short y=32767; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x0,"%",0x7fff,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=1; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"%",0x1,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=2; + if ((unsigned short)(x%y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"%",0x2,0x1,(unsigned short)(x%y)==0x1?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32766; + if ((unsigned short)(x%y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"%",0x7ffe,0x1,(unsigned short)(x%y)==0x1?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=1; volatile unsigned short y=32767; + if ((unsigned short)(x%y)!=(unsigned short)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x1,"%",0x7fff,0x1,(unsigned short)(x%y)==0x1?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=2; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"%",0x2,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32766; + if ((unsigned short)(x%y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"%",0x7ffe,0x2,(unsigned short)(x%y)==0x2?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=2; volatile unsigned short y=32767; + if ((unsigned short)(x%y)!=(unsigned short)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x2,"%",0x7fff,0x2,(unsigned short)(x%y)==0x2?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32766; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"%",0x7ffe,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32766; volatile unsigned short y=32767; + if ((unsigned short)(x%y)!=(unsigned short)32766) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7ffe,"%",0x7fff,0x7ffe,(unsigned short)(x%y)==0x7ffe?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned short x=32767; volatile unsigned short y=32767; + if ((unsigned short)(x%y)!=(unsigned short)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned short",0x7fff,"%",0x7fff,0x0,(unsigned short)(x%y)==0x0?"PASS":"FAIL",(unsigned short)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x+y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"+",0x80,0x0,(unsigned char)(x+y)==0x0?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x+y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"+",0x81,0x1,(unsigned char)(x+y)==0x1?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x+y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"+",0xfe,0x7e,(unsigned char)(x+y)==0x7e?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x+y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"+",0xff,0x7f,(unsigned char)(x+y)==0x7f?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x+y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"+",0x0,0x80,(unsigned char)(x+y)==0x80?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x+y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"+",0x1,0x81,(unsigned char)(x+y)==0x81?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x+y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"+",0x2,0x82,(unsigned char)(x+y)==0x82?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x+y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"+",0x7e,0xfe,(unsigned char)(x+y)==0xfe?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x+y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"+",0x7f,0xff,(unsigned char)(x+y)==0xff?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x+y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"+",0x81,0x2,(unsigned char)(x+y)==0x2?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x+y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"+",0xfe,0x7f,(unsigned char)(x+y)==0x7f?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x+y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"+",0xff,0x80,(unsigned char)(x+y)==0x80?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x+y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"+",0x0,0x81,(unsigned char)(x+y)==0x81?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x+y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"+",0x1,0x82,(unsigned char)(x+y)==0x82?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x+y)!=(unsigned char)131) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"+",0x2,0x83,(unsigned char)(x+y)==0x83?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x+y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"+",0x7e,0xff,(unsigned char)(x+y)==0xff?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x+y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"+",0x7f,0x0,(unsigned char)(x+y)==0x0?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x+y)!=(unsigned char)252) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"+",0xfe,0xfc,(unsigned char)(x+y)==0xfc?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x+y)!=(unsigned char)253) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"+",0xff,0xfd,(unsigned char)(x+y)==0xfd?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x+y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"+",0x0,0xfe,(unsigned char)(x+y)==0xfe?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x+y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"+",0x1,0xff,(unsigned char)(x+y)==0xff?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x+y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"+",0x2,0x0,(unsigned char)(x+y)==0x0?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x+y)!=(unsigned char)124) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"+",0x7e,0x7c,(unsigned char)(x+y)==0x7c?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x+y)!=(unsigned char)125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"+",0x7f,0x7d,(unsigned char)(x+y)==0x7d?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x+y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"+",0xff,0xfe,(unsigned char)(x+y)==0xfe?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x+y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"+",0x0,0xff,(unsigned char)(x+y)==0xff?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x+y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"+",0x1,0x0,(unsigned char)(x+y)==0x0?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x+y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"+",0x2,0x1,(unsigned char)(x+y)==0x1?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x+y)!=(unsigned char)125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"+",0x7e,0x7d,(unsigned char)(x+y)==0x7d?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x+y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"+",0x7f,0x7e,(unsigned char)(x+y)==0x7e?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x+y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"+",0x0,0x0,(unsigned char)(x+y)==0x0?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x+y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"+",0x1,0x1,(unsigned char)(x+y)==0x1?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x+y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"+",0x2,0x2,(unsigned char)(x+y)==0x2?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x+y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"+",0x7e,0x7e,(unsigned char)(x+y)==0x7e?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x+y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"+",0x7f,0x7f,(unsigned char)(x+y)==0x7f?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x+y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"+",0x1,0x2,(unsigned char)(x+y)==0x2?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x+y)!=(unsigned char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"+",0x2,0x3,(unsigned char)(x+y)==0x3?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x+y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"+",0x7e,0x7f,(unsigned char)(x+y)==0x7f?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x+y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"+",0x7f,0x80,(unsigned char)(x+y)==0x80?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x+y)!=(unsigned char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"+",0x2,0x4,(unsigned char)(x+y)==0x4?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x+y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"+",0x7e,0x80,(unsigned char)(x+y)==0x80?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x+y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"+",0x7f,0x81,(unsigned char)(x+y)==0x81?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x+y)!=(unsigned char)252) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"+",0x7e,0xfc,(unsigned char)(x+y)==0xfc?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x+y)!=(unsigned char)253) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"+",0x7f,0xfd,(unsigned char)(x+y)==0xfd?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x+y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"+",0x7f,0xfe,(unsigned char)(x+y)==0xfe?"PASS":"FAIL",(unsigned char)(x+y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x-y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"-",0x80,0x0,(unsigned char)(x-y)==0x0?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x-y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"-",0x81,0xff,(unsigned char)(x-y)==0xff?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x-y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"-",0xfe,0x82,(unsigned char)(x-y)==0x82?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x-y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"-",0xff,0x81,(unsigned char)(x-y)==0x81?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x-y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"-",0x0,0x80,(unsigned char)(x-y)==0x80?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x-y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"-",0x1,0x7f,(unsigned char)(x-y)==0x7f?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x-y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"-",0x2,0x7e,(unsigned char)(x-y)==0x7e?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x-y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"-",0x7e,0x2,(unsigned char)(x-y)==0x2?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x-y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"-",0x7f,0x1,(unsigned char)(x-y)==0x1?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x-y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"-",0x81,0x0,(unsigned char)(x-y)==0x0?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x-y)!=(unsigned char)131) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"-",0xfe,0x83,(unsigned char)(x-y)==0x83?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x-y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"-",0xff,0x82,(unsigned char)(x-y)==0x82?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x-y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"-",0x0,0x81,(unsigned char)(x-y)==0x81?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x-y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"-",0x1,0x80,(unsigned char)(x-y)==0x80?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x-y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"-",0x2,0x7f,(unsigned char)(x-y)==0x7f?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x-y)!=(unsigned char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"-",0x7e,0x3,(unsigned char)(x-y)==0x3?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x-y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"-",0x7f,0x2,(unsigned char)(x-y)==0x2?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x-y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"-",0xfe,0x0,(unsigned char)(x-y)==0x0?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x-y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"-",0xff,0xff,(unsigned char)(x-y)==0xff?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x-y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"-",0x0,0xfe,(unsigned char)(x-y)==0xfe?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x-y)!=(unsigned char)253) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"-",0x1,0xfd,(unsigned char)(x-y)==0xfd?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x-y)!=(unsigned char)252) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"-",0x2,0xfc,(unsigned char)(x-y)==0xfc?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x-y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"-",0x7e,0x80,(unsigned char)(x-y)==0x80?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x-y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"-",0x7f,0x7f,(unsigned char)(x-y)==0x7f?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x-y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"-",0xff,0x0,(unsigned char)(x-y)==0x0?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x-y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"-",0x0,0xff,(unsigned char)(x-y)==0xff?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x-y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"-",0x1,0xfe,(unsigned char)(x-y)==0xfe?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x-y)!=(unsigned char)253) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"-",0x2,0xfd,(unsigned char)(x-y)==0xfd?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x-y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"-",0x7e,0x81,(unsigned char)(x-y)==0x81?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x-y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"-",0x7f,0x80,(unsigned char)(x-y)==0x80?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x-y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"-",0x0,0x0,(unsigned char)(x-y)==0x0?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x-y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"-",0x1,0xff,(unsigned char)(x-y)==0xff?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x-y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"-",0x2,0xfe,(unsigned char)(x-y)==0xfe?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x-y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"-",0x7e,0x82,(unsigned char)(x-y)==0x82?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x-y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"-",0x7f,0x81,(unsigned char)(x-y)==0x81?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x-y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"-",0x1,0x0,(unsigned char)(x-y)==0x0?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x-y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"-",0x2,0xff,(unsigned char)(x-y)==0xff?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x-y)!=(unsigned char)131) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"-",0x7e,0x83,(unsigned char)(x-y)==0x83?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x-y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"-",0x7f,0x82,(unsigned char)(x-y)==0x82?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x-y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"-",0x2,0x0,(unsigned char)(x-y)==0x0?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x-y)!=(unsigned char)132) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"-",0x7e,0x84,(unsigned char)(x-y)==0x84?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x-y)!=(unsigned char)131) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"-",0x7f,0x83,(unsigned char)(x-y)==0x83?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x-y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"-",0x7e,0x0,(unsigned char)(x-y)==0x0?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x-y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"-",0x7f,0xff,(unsigned char)(x-y)==0xff?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x-y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"-",0x7f,0x0,(unsigned char)(x-y)==0x0?"PASS":"FAIL",(unsigned char)(x-y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x^y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"^",0x80,0x0,(unsigned char)(x^y)==0x0?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x^y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"^",0x81,0x1,(unsigned char)(x^y)==0x1?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x^y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"^",0xfe,0x7e,(unsigned char)(x^y)==0x7e?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x^y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"^",0xff,0x7f,(unsigned char)(x^y)==0x7f?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x^y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"^",0x0,0x80,(unsigned char)(x^y)==0x80?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x^y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"^",0x1,0x81,(unsigned char)(x^y)==0x81?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x^y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"^",0x2,0x82,(unsigned char)(x^y)==0x82?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x^y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"^",0x7e,0xfe,(unsigned char)(x^y)==0xfe?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x^y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"^",0x7f,0xff,(unsigned char)(x^y)==0xff?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x^y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"^",0x81,0x0,(unsigned char)(x^y)==0x0?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x^y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"^",0xfe,0x7f,(unsigned char)(x^y)==0x7f?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x^y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"^",0xff,0x7e,(unsigned char)(x^y)==0x7e?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x^y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"^",0x0,0x81,(unsigned char)(x^y)==0x81?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x^y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"^",0x1,0x80,(unsigned char)(x^y)==0x80?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x^y)!=(unsigned char)131) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"^",0x2,0x83,(unsigned char)(x^y)==0x83?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x^y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"^",0x7e,0xff,(unsigned char)(x^y)==0xff?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x^y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"^",0x7f,0xfe,(unsigned char)(x^y)==0xfe?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x^y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"^",0xfe,0x0,(unsigned char)(x^y)==0x0?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x^y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"^",0xff,0x1,(unsigned char)(x^y)==0x1?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x^y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"^",0x0,0xfe,(unsigned char)(x^y)==0xfe?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x^y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"^",0x1,0xff,(unsigned char)(x^y)==0xff?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x^y)!=(unsigned char)252) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"^",0x2,0xfc,(unsigned char)(x^y)==0xfc?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x^y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"^",0x7e,0x80,(unsigned char)(x^y)==0x80?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x^y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"^",0x7f,0x81,(unsigned char)(x^y)==0x81?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x^y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"^",0xff,0x0,(unsigned char)(x^y)==0x0?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x^y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"^",0x0,0xff,(unsigned char)(x^y)==0xff?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x^y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"^",0x1,0xfe,(unsigned char)(x^y)==0xfe?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x^y)!=(unsigned char)253) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"^",0x2,0xfd,(unsigned char)(x^y)==0xfd?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x^y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"^",0x7e,0x81,(unsigned char)(x^y)==0x81?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x^y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"^",0x7f,0x80,(unsigned char)(x^y)==0x80?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x^y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"^",0x0,0x0,(unsigned char)(x^y)==0x0?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x^y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"^",0x1,0x1,(unsigned char)(x^y)==0x1?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x^y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"^",0x2,0x2,(unsigned char)(x^y)==0x2?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x^y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"^",0x7e,0x7e,(unsigned char)(x^y)==0x7e?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x^y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"^",0x7f,0x7f,(unsigned char)(x^y)==0x7f?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x^y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"^",0x1,0x0,(unsigned char)(x^y)==0x0?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x^y)!=(unsigned char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"^",0x2,0x3,(unsigned char)(x^y)==0x3?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x^y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"^",0x7e,0x7f,(unsigned char)(x^y)==0x7f?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x^y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"^",0x7f,0x7e,(unsigned char)(x^y)==0x7e?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x^y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"^",0x2,0x0,(unsigned char)(x^y)==0x0?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x^y)!=(unsigned char)124) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"^",0x7e,0x7c,(unsigned char)(x^y)==0x7c?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x^y)!=(unsigned char)125) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"^",0x7f,0x7d,(unsigned char)(x^y)==0x7d?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x^y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"^",0x7e,0x0,(unsigned char)(x^y)==0x0?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x^y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"^",0x7f,0x1,(unsigned char)(x^y)==0x1?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x^y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"^",0x7f,0x0,(unsigned char)(x^y)==0x0?"PASS":"FAIL",(unsigned char)(x^y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x&y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&",0x80,0x80,(unsigned char)(x&y)==0x80?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x&y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&",0x81,0x80,(unsigned char)(x&y)==0x80?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x&y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&",0xfe,0x80,(unsigned char)(x&y)==0x80?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x&y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&",0xff,0x80,(unsigned char)(x&y)==0x80?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&",0x0,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&",0x1,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&",0x2,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&",0x7e,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&",0x7f,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x&y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&",0x81,0x81,(unsigned char)(x&y)==0x81?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x&y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&",0xfe,0x80,(unsigned char)(x&y)==0x80?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x&y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&",0xff,0x81,(unsigned char)(x&y)==0x81?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&",0x0,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&",0x1,0x1,(unsigned char)(x&y)==0x1?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&",0x2,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&",0x7e,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&",0x7f,0x1,(unsigned char)(x&y)==0x1?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x&y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&",0xfe,0xfe,(unsigned char)(x&y)==0xfe?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x&y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&",0xff,0xfe,(unsigned char)(x&y)==0xfe?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&",0x0,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&",0x1,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x&y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&",0x2,0x2,(unsigned char)(x&y)==0x2?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x&y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&",0x7e,0x7e,(unsigned char)(x&y)==0x7e?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x&y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&",0x7f,0x7e,(unsigned char)(x&y)==0x7e?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x&y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&",0xff,0xff,(unsigned char)(x&y)==0xff?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&",0x0,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&",0x1,0x1,(unsigned char)(x&y)==0x1?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x&y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&",0x2,0x2,(unsigned char)(x&y)==0x2?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x&y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&",0x7e,0x7e,(unsigned char)(x&y)==0x7e?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x&y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&",0x7f,0x7f,(unsigned char)(x&y)==0x7f?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&",0x0,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&",0x1,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&",0x2,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&",0x7e,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&",0x7f,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"&",0x1,0x1,(unsigned char)(x&y)==0x1?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"&",0x2,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"&",0x7e,0x0,(unsigned char)(x&y)==0x0?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"&",0x7f,0x1,(unsigned char)(x&y)==0x1?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x&y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"&",0x2,0x2,(unsigned char)(x&y)==0x2?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x&y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"&",0x7e,0x2,(unsigned char)(x&y)==0x2?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x&y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"&",0x7f,0x2,(unsigned char)(x&y)==0x2?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x&y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"&",0x7e,0x7e,(unsigned char)(x&y)==0x7e?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x&y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"&",0x7f,0x7e,(unsigned char)(x&y)==0x7e?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x&y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"&",0x7f,0x7f,(unsigned char)(x&y)==0x7f?"PASS":"FAIL",(unsigned char)(x&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x|y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"|",0x80,0x80,(unsigned char)(x|y)==0x80?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x|y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"|",0x81,0x81,(unsigned char)(x|y)==0x81?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x|y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"|",0xfe,0xfe,(unsigned char)(x|y)==0xfe?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"|",0xff,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x|y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"|",0x0,0x80,(unsigned char)(x|y)==0x80?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x|y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"|",0x1,0x81,(unsigned char)(x|y)==0x81?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x|y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"|",0x2,0x82,(unsigned char)(x|y)==0x82?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x|y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"|",0x7e,0xfe,(unsigned char)(x|y)==0xfe?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"|",0x7f,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x|y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"|",0x81,0x81,(unsigned char)(x|y)==0x81?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"|",0xfe,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"|",0xff,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x|y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"|",0x0,0x81,(unsigned char)(x|y)==0x81?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x|y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"|",0x1,0x81,(unsigned char)(x|y)==0x81?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x|y)!=(unsigned char)131) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"|",0x2,0x83,(unsigned char)(x|y)==0x83?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"|",0x7e,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"|",0x7f,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x|y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"|",0xfe,0xfe,(unsigned char)(x|y)==0xfe?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"|",0xff,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x|y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"|",0x0,0xfe,(unsigned char)(x|y)==0xfe?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"|",0x1,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x|y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"|",0x2,0xfe,(unsigned char)(x|y)==0xfe?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x|y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"|",0x7e,0xfe,(unsigned char)(x|y)==0xfe?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"|",0x7f,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"|",0xff,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"|",0x0,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"|",0x1,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"|",0x2,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"|",0x7e,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x|y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"|",0x7f,0xff,(unsigned char)(x|y)==0xff?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x|y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"|",0x0,0x0,(unsigned char)(x|y)==0x0?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x|y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"|",0x1,0x1,(unsigned char)(x|y)==0x1?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x|y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"|",0x2,0x2,(unsigned char)(x|y)==0x2?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x|y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"|",0x7e,0x7e,(unsigned char)(x|y)==0x7e?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x|y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"|",0x7f,0x7f,(unsigned char)(x|y)==0x7f?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x|y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"|",0x1,0x1,(unsigned char)(x|y)==0x1?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x|y)!=(unsigned char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"|",0x2,0x3,(unsigned char)(x|y)==0x3?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x|y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"|",0x7e,0x7f,(unsigned char)(x|y)==0x7f?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x|y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"|",0x7f,0x7f,(unsigned char)(x|y)==0x7f?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x|y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"|",0x2,0x2,(unsigned char)(x|y)==0x2?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x|y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"|",0x7e,0x7e,(unsigned char)(x|y)==0x7e?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x|y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"|",0x7f,0x7f,(unsigned char)(x|y)==0x7f?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x|y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"|",0x7e,0x7e,(unsigned char)(x|y)==0x7e?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x|y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"|",0x7f,0x7f,(unsigned char)(x|y)==0x7f?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x|y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"|",0x7f,0x7f,(unsigned char)(x|y)==0x7f?"PASS":"FAIL",(unsigned char)(x|y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x80,"<<",0x0,0x80,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x80,"<<",0x1,0x0,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x80,"<<",0x2,0x0,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x81,"<<",0x0,0x81,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x81,"<<",0x1,0x2,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x81,"<<",0x2,0x4,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0xfe,"<<",0x0,0xfe,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0xfe,"<<",0x1,0xfc,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0xfe,"<<",0x2,0xf8,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0xff,"<<",0x0,0xff,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0xff,"<<",0x1,0xfe,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0xff,"<<",0x2,0xfc,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x0,"<<",0x0,0x0,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x0,"<<",0x1,0x0,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x0,"<<",0x2,0x0,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x1,"<<",0x1,0x2,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x1,"<<",0x2,0x4,(unsigned char)(x< %s (%d)\n",__LINE__,"unsigned char",0x2,"<<",0x2,0x8,(unsigned char)(x<>y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">>",0x0,0x80,(unsigned char)(x>>y)==0x80?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x>>y)!=(unsigned char)64) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">>",0x1,0x40,(unsigned char)(x>>y)==0x40?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x>>y)!=(unsigned char)32) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">>",0x2,0x20,(unsigned char)(x>>y)==0x20?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x>>y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">>",0x0,0x81,(unsigned char)(x>>y)==0x81?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x>>y)!=(unsigned char)64) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">>",0x1,0x40,(unsigned char)(x>>y)==0x40?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x>>y)!=(unsigned char)32) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">>",0x2,0x20,(unsigned char)(x>>y)==0x20?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x>>y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">>",0x0,0xfe,(unsigned char)(x>>y)==0xfe?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x>>y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">>",0x1,0x7f,(unsigned char)(x>>y)==0x7f?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x>>y)!=(unsigned char)63) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">>",0x2,0x3f,(unsigned char)(x>>y)==0x3f?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x>>y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">>",0x0,0xff,(unsigned char)(x>>y)==0xff?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x>>y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">>",0x1,0x7f,(unsigned char)(x>>y)==0x7f?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x>>y)!=(unsigned char)63) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">>",0x2,0x3f,(unsigned char)(x>>y)==0x3f?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x>>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">>",0x0,0x0,(unsigned char)(x>>y)==0x0?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x>>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">>",0x1,0x0,(unsigned char)(x>>y)==0x0?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x>>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">>",0x2,0x0,(unsigned char)(x>>y)==0x0?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x>>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">>",0x1,0x0,(unsigned char)(x>>y)==0x0?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x>>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">>",0x2,0x0,(unsigned char)(x>>y)==0x0?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x>>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,">>",0x2,0x0,(unsigned char)(x>>y)==0x0?"PASS":"FAIL",(unsigned char)(x>>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&&",0x80,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&&",0x81,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&&",0xfe,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&&",0xff,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x&&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&&",0x0,0x0,(unsigned char)(x&&y)==0x0?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&&",0x1,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&&",0x2,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&&",0x7e,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"&&",0x7f,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&&",0x81,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&&",0xfe,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&&",0xff,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x&&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&&",0x0,0x0,(unsigned char)(x&&y)==0x0?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&&",0x1,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&&",0x2,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&&",0x7e,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"&&",0x7f,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&&",0xfe,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&&",0xff,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x&&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&&",0x0,0x0,(unsigned char)(x&&y)==0x0?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&&",0x1,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&&",0x2,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&&",0x7e,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"&&",0x7f,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&&",0xff,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x&&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&&",0x0,0x0,(unsigned char)(x&&y)==0x0?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&&",0x1,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&&",0x2,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&&",0x7e,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"&&",0x7f,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x&&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&&",0x0,0x0,(unsigned char)(x&&y)==0x0?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x&&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&&",0x1,0x0,(unsigned char)(x&&y)==0x0?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x&&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&&",0x2,0x0,(unsigned char)(x&&y)==0x0?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x&&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&&",0x7e,0x0,(unsigned char)(x&&y)==0x0?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x&&y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"&&",0x7f,0x0,(unsigned char)(x&&y)==0x0?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"&&",0x1,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"&&",0x2,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"&&",0x7e,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"&&",0x7f,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"&&",0x2,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"&&",0x7e,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"&&",0x7f,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"&&",0x7e,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"&&",0x7f,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x&&y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"&&",0x7f,0x1,(unsigned char)(x&&y)==0x1?"PASS":"FAIL",(unsigned char)(x&&y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"||",0x80,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"||",0x81,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"||",0xfe,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"||",0xff,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"||",0x0,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"||",0x1,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"||",0x2,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"||",0x7e,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"||",0x7f,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"||",0x81,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"||",0xfe,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"||",0xff,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"||",0x0,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"||",0x1,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"||",0x2,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"||",0x7e,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"||",0x7f,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"||",0xfe,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"||",0xff,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"||",0x0,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"||",0x1,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"||",0x2,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"||",0x7e,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"||",0x7f,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"||",0xff,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"||",0x0,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"||",0x1,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"||",0x2,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"||",0x7e,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"||",0x7f,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x||y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"||",0x0,0x0,(unsigned char)(x||y)==0x0?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"||",0x1,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"||",0x2,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"||",0x7e,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"||",0x7f,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"||",0x1,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"||",0x2,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"||",0x7e,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"||",0x7f,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"||",0x2,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"||",0x7e,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"||",0x7f,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"||",0x7e,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"||",0x7f,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x||y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"||",0x7f,0x1,(unsigned char)(x||y)==0x1?"PASS":"FAIL",(unsigned char)(x||y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">",0x80,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">",0x81,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">",0xfe,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">",0xff,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">",0x0,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">",0x1,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">",0x2,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">",0x7e,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">",0x7f,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">",0x81,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">",0xfe,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">",0xff,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">",0x0,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">",0x1,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">",0x2,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">",0x7e,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">",0x7f,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">",0xfe,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">",0xff,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">",0x0,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">",0x1,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">",0x2,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">",0x7e,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">",0x7f,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">",0xff,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">",0x0,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">",0x1,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">",0x2,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">",0x7e,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x>y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">",0x7f,0x1,(unsigned char)(x>y)==0x1?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">",0x0,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">",0x1,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">",0x2,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">",0x7e,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">",0x7f,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">",0x1,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">",0x2,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">",0x7e,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">",0x7f,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,">",0x2,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,">",0x7e,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,">",0x7f,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,">",0x7e,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,">",0x7f,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x>y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,">",0x7f,0x0,(unsigned char)(x>y)==0x0?"PASS":"FAIL",(unsigned char)(x>y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x80,"<",0x80,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x80,"<",0x81,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x80,"<",0xfe,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x80,"<",0xff,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x80,"<",0x0,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x80,"<",0x1,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x80,"<",0x2,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x80,"<",0x7e,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x80,"<",0x7f,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x81,"<",0x81,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x81,"<",0xfe,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x81,"<",0xff,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x81,"<",0x0,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x81,"<",0x1,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x81,"<",0x2,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x81,"<",0x7e,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x81,"<",0x7f,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xfe,"<",0xfe,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xfe,"<",0xff,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xfe,"<",0x0,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xfe,"<",0x1,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xfe,"<",0x2,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xfe,"<",0x7e,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xfe,"<",0x7f,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xff,"<",0xff,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xff,"<",0x0,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xff,"<",0x1,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xff,"<",0x2,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xff,"<",0x7e,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0xff,"<",0x7f,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x0,"<",0x0,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x0,"<",0x1,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x0,"<",0x2,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x0,"<",0x7e,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x0,"<",0x7f,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x1,"<",0x1,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x1,"<",0x2,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x1,"<",0x7e,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x1,"<",0x7f,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x2,"<",0x2,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x2,"<",0x7e,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x2,"<",0x7f,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x7e,"<",0x7e,0x0,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x7e,"<",0x7f,0x1,(unsigned char)(x %s (%d)\n",__LINE__,"unsigned char",0x7f,"<",0x7f,0x0,(unsigned char)(x=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">=",0x80,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">=",0x81,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">=",0xfe,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">=",0xff,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">=",0x0,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">=",0x1,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">=",0x2,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">=",0x7e,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,">=",0x7f,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">=",0x81,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">=",0xfe,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">=",0xff,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">=",0x0,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">=",0x1,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">=",0x2,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">=",0x7e,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,">=",0x7f,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">=",0xfe,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">=",0xff,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">=",0x0,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">=",0x1,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">=",0x2,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">=",0x7e,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,">=",0x7f,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">=",0xff,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">=",0x0,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">=",0x1,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">=",0x2,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">=",0x7e,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,">=",0x7f,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">=",0x0,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">=",0x1,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">=",0x2,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">=",0x7e,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,">=",0x7f,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">=",0x1,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">=",0x2,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">=",0x7e,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,">=",0x7f,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,">=",0x2,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,">=",0x7e,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,">=",0x7f,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,">=",0x7e,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x>=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,">=",0x7f,0x0,(unsigned char)(x>=y)==0x0?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x>=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,">=",0x7f,0x1,(unsigned char)(x>=y)==0x1?"PASS":"FAIL",(unsigned char)(x>=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"<=",0x80,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"<=",0x81,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"<=",0xfe,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"<=",0xff,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"<=",0x0,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"<=",0x1,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"<=",0x2,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"<=",0x7e,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"<=",0x7f,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"<=",0x81,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"<=",0xfe,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"<=",0xff,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"<=",0x0,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"<=",0x1,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"<=",0x2,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"<=",0x7e,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"<=",0x7f,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"<=",0xfe,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"<=",0xff,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"<=",0x0,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"<=",0x1,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"<=",0x2,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"<=",0x7e,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"<=",0x7f,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"<=",0xff,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"<=",0x0,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"<=",0x1,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"<=",0x2,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"<=",0x7e,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x<=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"<=",0x7f,0x0,(unsigned char)(x<=y)==0x0?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"<=",0x0,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"<=",0x1,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"<=",0x2,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"<=",0x7e,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"<=",0x7f,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"<=",0x1,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"<=",0x2,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"<=",0x7e,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"<=",0x7f,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"<=",0x2,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"<=",0x7e,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"<=",0x7f,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"<=",0x7e,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"<=",0x7f,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x<=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"<=",0x7f,0x1,(unsigned char)(x<=y)==0x1?"PASS":"FAIL",(unsigned char)(x<=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x==y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"==",0x80,0x1,(unsigned char)(x==y)==0x1?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"==",0x81,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"==",0xfe,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"==",0xff,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"==",0x0,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"==",0x1,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"==",0x2,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"==",0x7e,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"==",0x7f,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x==y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"==",0x81,0x1,(unsigned char)(x==y)==0x1?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"==",0xfe,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"==",0xff,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"==",0x0,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"==",0x1,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"==",0x2,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"==",0x7e,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"==",0x7f,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x==y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"==",0xfe,0x1,(unsigned char)(x==y)==0x1?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"==",0xff,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"==",0x0,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"==",0x1,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"==",0x2,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"==",0x7e,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"==",0x7f,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x==y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"==",0xff,0x1,(unsigned char)(x==y)==0x1?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"==",0x0,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"==",0x1,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"==",0x2,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"==",0x7e,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"==",0x7f,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x==y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"==",0x0,0x1,(unsigned char)(x==y)==0x1?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"==",0x1,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"==",0x2,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"==",0x7e,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"==",0x7f,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x==y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"==",0x1,0x1,(unsigned char)(x==y)==0x1?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"==",0x2,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"==",0x7e,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"==",0x7f,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x==y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"==",0x2,0x1,(unsigned char)(x==y)==0x1?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"==",0x7e,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"==",0x7f,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x==y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"==",0x7e,0x1,(unsigned char)(x==y)==0x1?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x==y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"==",0x7f,0x0,(unsigned char)(x==y)==0x0?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x==y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"==",0x7f,0x1,(unsigned char)(x==y)==0x1?"PASS":"FAIL",(unsigned char)(x==y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x!=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"!=",0x80,0x0,(unsigned char)(x!=y)==0x0?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"!=",0x81,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"!=",0xfe,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"!=",0xff,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"!=",0x0,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"!=",0x1,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"!=",0x2,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"!=",0x7e,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"!=",0x7f,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x!=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"!=",0x81,0x0,(unsigned char)(x!=y)==0x0?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"!=",0xfe,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"!=",0xff,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"!=",0x0,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"!=",0x1,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"!=",0x2,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"!=",0x7e,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"!=",0x7f,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x!=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"!=",0xfe,0x0,(unsigned char)(x!=y)==0x0?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"!=",0xff,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"!=",0x0,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"!=",0x1,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"!=",0x2,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"!=",0x7e,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"!=",0x7f,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x!=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"!=",0xff,0x0,(unsigned char)(x!=y)==0x0?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"!=",0x0,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"!=",0x1,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"!=",0x2,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"!=",0x7e,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"!=",0x7f,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x!=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"!=",0x0,0x0,(unsigned char)(x!=y)==0x0?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"!=",0x1,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"!=",0x2,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"!=",0x7e,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"!=",0x7f,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x!=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"!=",0x1,0x0,(unsigned char)(x!=y)==0x0?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"!=",0x2,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"!=",0x7e,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"!=",0x7f,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x!=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"!=",0x2,0x0,(unsigned char)(x!=y)==0x0?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"!=",0x7e,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"!=",0x7f,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x!=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"!=",0x7e,0x0,(unsigned char)(x!=y)==0x0?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x!=y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"!=",0x7f,0x1,(unsigned char)(x!=y)==0x1?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x!=y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"!=",0x7f,0x0,(unsigned char)(x!=y)==0x0?"PASS":"FAIL",(unsigned char)(x!=y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"*",0x80,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x*y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"*",0x81,0x80,(unsigned char)(x*y)==0x80?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"*",0xfe,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x*y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"*",0xff,0x80,(unsigned char)(x*y)==0x80?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=0; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"*",0x0,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x*y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"*",0x1,0x80,(unsigned char)(x*y)==0x80?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"*",0x2,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"*",0x7e,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x*y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"*",0x7f,0x80,(unsigned char)(x*y)==0x80?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x*y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"*",0x81,0x1,(unsigned char)(x*y)==0x1?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x*y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"*",0xfe,0xfe,(unsigned char)(x*y)==0xfe?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x*y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"*",0xff,0x7f,(unsigned char)(x*y)==0x7f?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=0; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"*",0x0,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x*y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"*",0x1,0x81,(unsigned char)(x*y)==0x81?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x*y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"*",0x2,0x2,(unsigned char)(x*y)==0x2?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x*y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"*",0x7e,0x7e,(unsigned char)(x*y)==0x7e?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x*y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"*",0x7f,0xff,(unsigned char)(x*y)==0xff?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x*y)!=(unsigned char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"*",0xfe,0x4,(unsigned char)(x*y)==0x4?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x*y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"*",0xff,0x2,(unsigned char)(x*y)==0x2?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=0; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"*",0x0,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x*y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"*",0x1,0xfe,(unsigned char)(x*y)==0xfe?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x*y)!=(unsigned char)252) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"*",0x2,0xfc,(unsigned char)(x*y)==0xfc?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x*y)!=(unsigned char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"*",0x7e,0x4,(unsigned char)(x*y)==0x4?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x*y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"*",0x7f,0x2,(unsigned char)(x*y)==0x2?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x*y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"*",0xff,0x1,(unsigned char)(x*y)==0x1?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=0; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"*",0x0,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x*y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"*",0x1,0xff,(unsigned char)(x*y)==0xff?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x*y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"*",0x2,0xfe,(unsigned char)(x*y)==0xfe?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x*y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"*",0x7e,0x82,(unsigned char)(x*y)==0x82?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x*y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"*",0x7f,0x81,(unsigned char)(x*y)==0x81?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=0; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"*",0x0,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"*",0x1,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"*",0x2,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"*",0x7e,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x*y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"*",0x7f,0x0,(unsigned char)(x*y)==0x0?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x*y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"*",0x1,0x1,(unsigned char)(x*y)==0x1?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x*y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"*",0x2,0x2,(unsigned char)(x*y)==0x2?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x*y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"*",0x7e,0x7e,(unsigned char)(x*y)==0x7e?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x*y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"*",0x7f,0x7f,(unsigned char)(x*y)==0x7f?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x*y)!=(unsigned char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"*",0x2,0x4,(unsigned char)(x*y)==0x4?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x*y)!=(unsigned char)252) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"*",0x7e,0xfc,(unsigned char)(x*y)==0xfc?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x*y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"*",0x7f,0xfe,(unsigned char)(x*y)==0xfe?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x*y)!=(unsigned char)4) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"*",0x7e,0x4,(unsigned char)(x*y)==0x4?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x*y)!=(unsigned char)130) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"*",0x7f,0x82,(unsigned char)(x*y)==0x82?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x*y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"*",0x7f,0x1,(unsigned char)(x*y)==0x1?"PASS":"FAIL",(unsigned char)(x*y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"/",0x80,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"/",0x81,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"/",0xfe,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"/",0xff,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x/y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"/",0x1,0x80,(unsigned char)(x/y)==0x80?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x/y)!=(unsigned char)64) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"/",0x2,0x40,(unsigned char)(x/y)==0x40?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"/",0x7e,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"/",0x7f,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"/",0x81,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"/",0xfe,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"/",0xff,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x/y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"/",0x1,0x81,(unsigned char)(x/y)==0x81?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x/y)!=(unsigned char)64) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"/",0x2,0x40,(unsigned char)(x/y)==0x40?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"/",0x7e,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"/",0x7f,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"/",0xfe,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"/",0xff,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x/y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"/",0x1,0xfe,(unsigned char)(x/y)==0xfe?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x/y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"/",0x2,0x7f,(unsigned char)(x/y)==0x7f?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x/y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"/",0x7e,0x2,(unsigned char)(x/y)==0x2?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x/y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"/",0x7f,0x2,(unsigned char)(x/y)==0x2?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"/",0xff,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x/y)!=(unsigned char)255) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"/",0x1,0xff,(unsigned char)(x/y)==0xff?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x/y)!=(unsigned char)127) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"/",0x2,0x7f,(unsigned char)(x/y)==0x7f?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x/y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"/",0x7e,0x2,(unsigned char)(x/y)==0x2?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x/y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"/",0x7f,0x2,(unsigned char)(x/y)==0x2?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"/",0x1,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"/",0x2,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"/",0x7e,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"/",0x7f,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"/",0x1,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"/",0x2,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"/",0x7e,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"/",0x7f,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"/",0x2,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"/",0x7e,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"/",0x7f,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"/",0x7e,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x/y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"/",0x7f,0x0,(unsigned char)(x/y)==0x0?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x/y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"/",0x7f,0x1,(unsigned char)(x/y)==0x1?"PASS":"FAIL",(unsigned char)(x/y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=128; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"%",0x80,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=129; + if ((unsigned char)(x%y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"%",0x81,0x80,(unsigned char)(x%y)==0x80?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=254; + if ((unsigned char)(x%y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"%",0xfe,0x80,(unsigned char)(x%y)==0x80?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=255; + if ((unsigned char)(x%y)!=(unsigned char)128) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"%",0xff,0x80,(unsigned char)(x%y)==0x80?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=1; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"%",0x1,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=2; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"%",0x2,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=126; + if ((unsigned char)(x%y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"%",0x7e,0x2,(unsigned char)(x%y)==0x2?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=128; volatile unsigned char y=127; + if ((unsigned char)(x%y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x80,"%",0x7f,0x1,(unsigned char)(x%y)==0x1?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=129; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"%",0x81,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=254; + if ((unsigned char)(x%y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"%",0xfe,0x81,(unsigned char)(x%y)==0x81?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=255; + if ((unsigned char)(x%y)!=(unsigned char)129) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"%",0xff,0x81,(unsigned char)(x%y)==0x81?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=1; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"%",0x1,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=2; + if ((unsigned char)(x%y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"%",0x2,0x1,(unsigned char)(x%y)==0x1?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=126; + if ((unsigned char)(x%y)!=(unsigned char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"%",0x7e,0x3,(unsigned char)(x%y)==0x3?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=129; volatile unsigned char y=127; + if ((unsigned char)(x%y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x81,"%",0x7f,0x2,(unsigned char)(x%y)==0x2?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=254; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"%",0xfe,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=255; + if ((unsigned char)(x%y)!=(unsigned char)254) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"%",0xff,0xfe,(unsigned char)(x%y)==0xfe?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=1; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"%",0x1,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=2; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"%",0x2,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=126; + if ((unsigned char)(x%y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"%",0x7e,0x2,(unsigned char)(x%y)==0x2?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=254; volatile unsigned char y=127; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xfe,"%",0x7f,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=255; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"%",0xff,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=1; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"%",0x1,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=2; + if ((unsigned char)(x%y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"%",0x2,0x1,(unsigned char)(x%y)==0x1?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=126; + if ((unsigned char)(x%y)!=(unsigned char)3) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"%",0x7e,0x3,(unsigned char)(x%y)==0x3?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=255; volatile unsigned char y=127; + if ((unsigned char)(x%y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0xff,"%",0x7f,0x1,(unsigned char)(x%y)==0x1?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=1; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"%",0x1,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=2; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"%",0x2,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=126; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"%",0x7e,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=0; volatile unsigned char y=127; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x0,"%",0x7f,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=1; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"%",0x1,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=2; + if ((unsigned char)(x%y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"%",0x2,0x1,(unsigned char)(x%y)==0x1?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=126; + if ((unsigned char)(x%y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"%",0x7e,0x1,(unsigned char)(x%y)==0x1?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=1; volatile unsigned char y=127; + if ((unsigned char)(x%y)!=(unsigned char)1) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x1,"%",0x7f,0x1,(unsigned char)(x%y)==0x1?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=2; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"%",0x2,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=126; + if ((unsigned char)(x%y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"%",0x7e,0x2,(unsigned char)(x%y)==0x2?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=2; volatile unsigned char y=127; + if ((unsigned char)(x%y)!=(unsigned char)2) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x2,"%",0x7f,0x2,(unsigned char)(x%y)==0x2?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=126; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"%",0x7e,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=126; volatile unsigned char y=127; + if ((unsigned char)(x%y)!=(unsigned char)126) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7e,"%",0x7f,0x7e,(unsigned char)(x%y)==0x7e?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} +{ + volatile unsigned char x=127; volatile unsigned char y=127; + if ((unsigned char)(x%y)!=(unsigned char)0) { + printf("line %d: %s: %d %s %d == %d => %s (%d)\n",__LINE__,"unsigned char",0x7f,"%",0x7f,0x0,(unsigned char)(x%y)==0x0?"PASS":"FAIL",(unsigned char)(x%y)); + exit_code = 1;}} + return exit_code; +} diff --git a/am-kernels/tests/alu-tests/build/gen_alu_test b/am-kernels/tests/alu-tests/build/gen_alu_test new file mode 100755 index 0000000..47b792e Binary files /dev/null and b/am-kernels/tests/alu-tests/build/gen_alu_test differ diff --git a/am-kernels/tests/alu-tests/gen_alu_test.c b/am-kernels/tests/alu-tests/gen_alu_test.c new file mode 100644 index 0000000..9ae5009 --- /dev/null +++ b/am-kernels/tests/alu-tests/gen_alu_test.c @@ -0,0 +1,135 @@ +/* this program generates an arithmetic test for the M/o/Vfuscator */ + +/* it should be compiled with gcc, and its output compiled with the + * M/o/Vfuscator, to verify the MOV ALU calculates the same results as those + * from a program compiled with gcc */ + +/* gcc gen_test.c && ./a.out > test.c && movcc test.c movfusator/lib/softfloat64.o && ./a.out | grep FAIL */ + +#include +#include + +//static const double vd[]={-2.0, -1.0, 0.0, 1.0, 2.0}; +//static const float vf[]={-2.0f, -1.0f, 0.0f, 1.0f, 2.0f}; + +static const signed int vsi[]={0x80000000, 0x80000001, -2, -1, 0, 1, 2, 0x7ffffffe, 0x7fffffff}; +static const signed short vss[]={0x8000, 0x8001, -2, -1, 0, 1, 2, 0x7ffe, 0x7fff}; +static const signed char vsc[]={0x80, 0x81, -2, -1, 0, 1, 2, 0x7e, 0x7f}; + +static const unsigned int vui[]={0x80000000, 0x80000001, -2, -1, 0, 1, 2, 0x7ffffffe, 0x7fffffff}; +static const unsigned short vus[]={0x8000, 0x8001, -2, -1, 0, 1, 2, 0x7ffe, 0x7fff}; +static const unsigned char vuc[]={0x80, 0x81, -2, -1, 0, 1, 2, 0x7e, 0x7f}; + +#define TEST_STRING " printf(\"line %%d: %%s: %%d %%s %%d == %%d => %%s (%%d)\\n\","\ + "__LINE__,\"%s\",0x%x,\"%s\",0x%x,0x%x,(%s)(x%sy)==0x%x?\"PASS\":\"FAIL\",(%s)(x%sy));\n" + +#define TEST_STRING_F " printf(\"%%20s: %%20f %%2s %%-20f == %%-20f => %%8s (%%f)\\n\","\ + "\"%s\",%f,\"%s\",%f,%f,(%s)(x%sy)==%f?\"PASS\":\"FAIL\",(%s)(x%sy));\n" + +#define TEST_PARMS(type,set,op) \ + #type,set[i],#op,set[j],(type)(set[i] op set[j]),#type,#op,(type)(set[i] op set[j]),#type,#op + +#define S_F "%f" +#define S_I "%d" + +#define FOR_SET(ss,tt,string,type,set,op) {\ + int i, j; \ + int c=sizeof((set))/sizeof(*(set)); \ + for (i=0; i>); \ + FOR_SET(S_I,I,TEST_STRING,type,set,&&); \ + FOR_SET(S_I,I,TEST_STRING,type,set,||); \ + FOR_SET(S_I,I,TEST_STRING,type,set,>) \ + FOR_SET(S_I,I,TEST_STRING,type,set,<) \ + FOR_SET(S_I,I,TEST_STRING,type,set,>=) \ + FOR_SET(S_I,I,TEST_STRING,type,set,<=) \ + FOR_SET(S_I,I,TEST_STRING,type,set,==) \ + FOR_SET(S_I,I,TEST_STRING,type,set,!=) \ + FOR_SET(S_I,I,TEST_STRING,type,set,*); \ + FOR_SET(S_I,I,TEST_STRING,type,set,/); \ + FOR_SET(S_I,I,TEST_STRING,type,set,%); \ +} + +#define FOR_SET_FLOAT(type,set) {\ + FOR_SET(S_F,F,TEST_STRING_F,type,set,+); \ + FOR_SET(S_F,F,TEST_STRING_F,type,set,-); \ + FOR_SET(S_F,F,TEST_STRING_F,type,set,*); \ + FOR_SET(S_F,F,TEST_STRING_F,type,set,/); \ + FOR_SET(S_F,F,TEST_STRING_F,type,set,>) \ + FOR_SET(S_F,F,TEST_STRING_F,type,set,<) \ + FOR_SET(S_F,F,TEST_STRING_F,type,set,>=) \ + FOR_SET(S_F,F,TEST_STRING_F,type,set,<=) \ + FOR_SET(S_F,F,TEST_STRING_F,type,set,==) \ + FOR_SET(S_F,F,TEST_STRING_F,type,set,!=) \ +} + +typedef enum { I, F } type; + +static int strsame(const char *s1, const char *s2) { + return strcmp(s1, s2) == 0; +} + +int exclude(type t, char* op, int x, int y) +{ + if (t==I) { + if (strsame(op, "/") || strsame(op, "%")) { + if (y==0 || (y==-1 && x==0x80000000)) { + return 1; + } + } + else if (strsame(op, ">>") || strsame(op, "<<")) { + if (y>31 || y<0) { + return 1; + } + } + } + else if (t==F) { + if (strsame(op, "/")) { + if (y==0) { + return 1; + } + } + } + return 0; +} + +int main(void) +{ + printf("#include \n"); + printf("int main(void) {\n"); + printf(" int exit_code = 0;\n"); + + FOR_SET_ALL(signed int, vsi); + FOR_SET_ALL(signed short, vss); + FOR_SET_ALL(signed char, vsc); + + FOR_SET_ALL(unsigned int, vui); + FOR_SET_ALL(unsigned short, vus); + FOR_SET_ALL(unsigned char, vuc); + + //FOR_SET_FLOAT(float, vf); + //FOR_SET_FLOAT(double, vf); + + printf(" return exit_code;\n"); + printf("}\n"); + + return 0; +} diff --git a/am-kernels/tests/am-tests/Makefile b/am-kernels/tests/am-tests/Makefile new file mode 100644 index 0000000..de6da42 --- /dev/null +++ b/am-kernels/tests/am-tests/Makefile @@ -0,0 +1,3 @@ +NAME = amtest +SRCS = $(shell find src/ -name "*.[cS]") +include $(AM_HOME)/Makefile diff --git a/am-kernels/tests/am-tests/include/amtest.h b/am-kernels/tests/am-tests/include/amtest.h new file mode 100644 index 0000000..de172ae --- /dev/null +++ b/am-kernels/tests/am-tests/include/amtest.h @@ -0,0 +1,24 @@ +#ifndef __AMUNIT_H__ +#define __AMUNIT_H__ + +#include +#include +#include + +#define IOE ({ ioe_init(); }) +#define CTE(h) ({ Context *h(Event, Context *); cte_init(h); }) +#define VME(f1, f2) ({ void *f1(int); void f2(void *); vme_init(f1, f2); }) +#define MPE ({ mpe_init(entry); }) + +extern void (*entry)(); + +#define CASE(id, entry_, ...) \ + case id: { \ + void entry_(); \ + entry = entry_; \ + __VA_ARGS__; \ + entry_(); \ + break; \ + } + +#endif diff --git a/am-kernels/tests/am-tests/src/main.c b/am-kernels/tests/am-tests/src/main.c new file mode 100644 index 0000000..cae9cd3 --- /dev/null +++ b/am-kernels/tests/am-tests/src/main.c @@ -0,0 +1,39 @@ +#include + +void (*entry)() = NULL; // mp entry + +static const char *tests[256] = { + ['h'] = "hello", + ['H'] = "display this help message", + ['i'] = "interrupt/yield test", + ['d'] = "scan devices", + ['m'] = "multiprocessor test", + ['t'] = "real-time clock test", + ['k'] = "readkey test", + ['v'] = "display test", + ['a'] = "audio test", + ['p'] = "x86 virtual memory test", +}; + +int main(const char *args) { + switch (args[0]) { + CASE('h', hello); + CASE('i', hello_intr, IOE, CTE(simple_trap)); + CASE('d', devscan, IOE); + CASE('m', mp_print, MPE); + CASE('t', rtc_test, IOE); + CASE('k', keyboard_test, IOE); + CASE('v', video_test, IOE); + CASE('a', audio_test, IOE); + CASE('p', vm_test, CTE(vm_handler), VME(simple_pgalloc, simple_pgfree)); + case 'H': + default: + printf("Usage: make run mainargs=*\n"); + for (int ch = 0; ch < 256; ch++) { + if (tests[ch]) { + printf(" %c: %s\n", ch, tests[ch]); + } + } + } + return 0; +} diff --git a/am-kernels/tests/am-tests/src/tests/audio.c b/am-kernels/tests/am-tests/src/tests/audio.c new file mode 100644 index 0000000..2170bf4 --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/audio.c @@ -0,0 +1,27 @@ +#include + +void audio_test() { + if (!io_read(AM_AUDIO_CONFIG).present) { + printf("WARNING: %s does not support audio\n", TOSTRING(__ARCH__)); + return; + } + + io_write(AM_AUDIO_CTRL, 8000, 1, 1024); + + extern uint8_t audio_payload, audio_payload_end; + uint32_t audio_len = &audio_payload_end - &audio_payload; + int nplay = 0; + Area sbuf; + sbuf.start = &audio_payload; + while (nplay < audio_len) { + int len = (audio_len - nplay > 4096 ? 4096 : audio_len - nplay); + sbuf.end = sbuf.start + len; + io_write(AM_AUDIO_PLAY, sbuf); + sbuf.start += len; + nplay += len; + printf("Already play %d/%d bytes of data\n", nplay, audio_len); + } + + // wait until the audio finishes + while (io_read(AM_AUDIO_STATUS).count > 0); +} diff --git a/am-kernels/tests/am-tests/src/tests/audio/.gitignore b/am-kernels/tests/am-tests/src/tests/audio/.gitignore new file mode 100644 index 0000000..129b00d --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/audio/.gitignore @@ -0,0 +1 @@ +!*.pcm diff --git a/am-kernels/tests/am-tests/src/tests/audio/audio-data.S b/am-kernels/tests/am-tests/src/tests/audio/audio-data.S new file mode 100644 index 0000000..f1fc11b --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/audio/audio-data.S @@ -0,0 +1,6 @@ +.section .data +.global audio_payload, audio_payload_end +.p2align 3 +audio_payload: +.incbin "src/tests/audio/little-star.pcm" +audio_payload_end: diff --git a/am-kernels/tests/am-tests/src/tests/audio/little-star.pcm b/am-kernels/tests/am-tests/src/tests/audio/little-star.pcm new file mode 100644 index 0000000..afb8880 Binary files /dev/null and b/am-kernels/tests/am-tests/src/tests/audio/little-star.pcm differ diff --git a/am-kernels/tests/am-tests/src/tests/devscan.c b/am-kernels/tests/am-tests/src/tests/devscan.c new file mode 100644 index 0000000..d2c1a54 --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/devscan.c @@ -0,0 +1,69 @@ +#include + +static void input_test() { + printf("Input device test skipped.\n"); +} + +static void timer_test() { + AM_TIMER_UPTIME_T uptime; + uint32_t t0, t1; + + uptime = io_read(AM_TIMER_UPTIME); + t0 = uptime.us / 1000; + + for (int volatile i = 0; i < 10000000; i ++) ; + + uptime = io_read(AM_TIMER_UPTIME); + t1 = uptime.us / 1000; + + printf("Loop 10^7 time elapse: %d ms\n", t1 - t0); +} + +static uint8_t vmem[512 << 10]; +static inline gpuptr_t to_guest(void *ptr) { return ptr ? (uint8_t *)ptr - vmem : AM_GPU_NULL; } + +static void video_test() { + AM_GPU_CONFIG_T info = io_read(AM_GPU_CONFIG); + int w = info.width, h = info.height; + printf("Screen size: %d x %d\n", w, h); + + struct gpu_canvas *cv = (void *)vmem; + + for (uint8_t *p = (void *)&cv[8]; p != vmem + sizeof(vmem); p++) + *p = rand() & 0xff; + + cv[0] = (struct gpu_canvas) { + .w = -1, .h = -1, .x1 = w / 4, .y1 = 0, .w1 = w / 2, .h1 = h - 100, + .type = AM_GPU_TEXTURE, + .texture = (struct gpu_texturedesc) { + .w = 37, .h = 10, + .pixels = to_guest(&cv[8]), + }, + .sibling = to_guest(NULL), + }; + + io_write(AM_GPU_MEMCPY, 0, vmem, sizeof(vmem)); + io_write(AM_GPU_RENDER, 0); +} + +static void storage_test() { + #define nbytes 512 + static char buf[nbytes]; + AM_DISK_CONFIG_T info = io_read(AM_DISK_CONFIG); + printf("Storage: %d blocks of %d size. Show first 512 bytes\n", info.blkcnt, info.blksz); + io_write(AM_DISK_BLKIO, false, buf, 0, nbytes / info.blksz); + for (uint32_t i = 0; i < nbytes; i += 2) { + printf("%02x%02x ", buf[i] & 0xff, buf[i+1] & 0xff); + if ((i+2) % 32 == 0) printf("\n"); + } +} + +void devscan() { + printf("heap = [%08x, %08x)\n", heap.start, heap.end); + input_test(); + timer_test(); + video_test(); + storage_test(); + printf("Test End!\n"); + while (1); +} diff --git a/am-kernels/tests/am-tests/src/tests/hello.c b/am-kernels/tests/am-tests/src/tests/hello.c new file mode 100644 index 0000000..7672018 --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/hello.c @@ -0,0 +1,7 @@ +#include + +void hello() { + for (int i = 0; i < 10; i ++) { + putstr("Hello, AM World @ " __ISA__ "\n"); + } +} diff --git a/am-kernels/tests/am-tests/src/tests/intr.c b/am-kernels/tests/am-tests/src/tests/intr.c new file mode 100644 index 0000000..855179d --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/intr.c @@ -0,0 +1,26 @@ +#include + +Context *simple_trap(Event ev, Context *ctx) { + switch(ev.event) { + case EVENT_IRQ_TIMER: + putch('t'); break; + case EVENT_IRQ_IODEV: + putch('d'); break; + case EVENT_YIELD: + putch('y'); break; + default: + panic("Unhandled event"); break; + } + return ctx; +} + +void hello_intr() { + printf("Hello, AM World @ " __ISA__ "\n"); + printf(" t = timer, d = device, y = yield\n"); + io_read(AM_INPUT_CONFIG); + iset(1); + while (1) { + for (volatile int i = 0; i < 10000000; i++) ; + yield(); + } +} diff --git a/am-kernels/tests/am-tests/src/tests/keyboard.c b/am-kernels/tests/am-tests/src/tests/keyboard.c new file mode 100644 index 0000000..f9a1c0c --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/keyboard.c @@ -0,0 +1,35 @@ +#include + +#define NAMEINIT(key) [ AM_KEY_##key ] = #key, +static const char *names[] = { + AM_KEYS(NAMEINIT) +}; + +static bool has_uart, has_kbd; + +static void drain_keys() { + if (has_uart) { + while (1) { + char ch = io_read(AM_UART_RX).data; + if (ch == (char)-1) break; + printf("Got (uart): %c (%d)\n", ch, ch & 0xff); + } + } + + if (has_kbd) { + while (1) { + AM_INPUT_KEYBRD_T ev = io_read(AM_INPUT_KEYBRD); + if (ev.keycode == AM_KEY_NONE) break; + printf("Got (kbd): %s (%d) %s\n", names[ev.keycode], ev.keycode, ev.keydown ? "DOWN" : "UP"); + } + } +} + +void keyboard_test() { + printf("Try to press any key (uart or keyboard)...\n"); + has_uart = io_read(AM_UART_CONFIG).present; + has_kbd = io_read(AM_INPUT_CONFIG).present; + while (1) { + drain_keys(); + } +} diff --git a/am-kernels/tests/am-tests/src/tests/mp.c b/am-kernels/tests/am-tests/src/tests/mp.c new file mode 100644 index 0000000..787de79 --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/mp.c @@ -0,0 +1,7 @@ +#include + +void mp_print() { + while (1) { + printf("%d", cpu_current()); + } +} diff --git a/am-kernels/tests/am-tests/src/tests/rtc.c b/am-kernels/tests/am-tests/src/tests/rtc.c new file mode 100644 index 0000000..5db6f74 --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/rtc.c @@ -0,0 +1,17 @@ +#include + +void rtc_test() { + AM_TIMER_RTC_T rtc; + int sec = 1; + while (1) { + while(io_read(AM_TIMER_UPTIME).us / 1000000 < sec) ; + rtc = io_read(AM_TIMER_RTC); + printf("%d-%d-%d %02d:%02d:%02d GMT (", rtc.year, rtc.month, rtc.day, rtc.hour, rtc.minute, rtc.second); + if (sec == 1) { + printf("%d second).\n", sec); + } else { + printf("%d seconds).\n", sec); + } + sec ++; + } +} diff --git a/am-kernels/tests/am-tests/src/tests/video.c b/am-kernels/tests/am-tests/src/tests/video.c new file mode 100644 index 0000000..21b4d72 --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/video.c @@ -0,0 +1,90 @@ +#include + +#define FPS 30 +#define N 32 + +static inline uint32_t pixel(uint8_t r, uint8_t g, uint8_t b) { + return (r << 16) | (g << 8) | b; +} +static inline uint8_t R(uint32_t p) { return p >> 16; } +static inline uint8_t G(uint32_t p) { return p >> 8; } +static inline uint8_t B(uint32_t p) { return p; } + +static uint32_t canvas[N][N]; +static int used[N][N]; + +static uint32_t color_buf[32 * 32]; + +void redraw() { + int w = io_read(AM_GPU_CONFIG).width / N; + int h = io_read(AM_GPU_CONFIG).height / N; + int block_size = w * h; + assert((uint32_t)block_size <= LENGTH(color_buf)); + + int x, y, k; + for (y = 0; y < N; y ++) { + for (x = 0; x < N; x ++) { + for (k = 0; k < block_size; k ++) { + color_buf[k] = canvas[y][x]; + } + io_write(AM_GPU_FBDRAW, x * w, y * h, color_buf, w, h, false); + } + } + io_write(AM_GPU_FBDRAW, 0, 0, NULL, 0, 0, true); +} + +static uint32_t p(int tsc) { + int b = tsc & 0xff; + return pixel(b * 6, b * 7, b); +} + +void update() { + static int tsc = 0; + static int dx[4] = {0, 1, 0, -1}; + static int dy[4] = {1, 0, -1, 0}; + + tsc ++; + + for (int i = 0; i < N; i ++) + for (int j = 0; j < N; j ++) { + used[i][j] = 0; + } + + int init = tsc * 1; + canvas[0][0] = p(init); used[0][0] = 1; + int x = 0, y = 0, d = 0; + for (int step = 1; step < N * N; step ++) { + for (int t = 0; t < 4; t ++) { + int x1 = x + dx[d], y1 = y + dy[d]; + if (x1 >= 0 && x1 < N && y1 >= 0 && y1 < N && !used[x1][y1]) { + x = x1; y = y1; + used[x][y] = 1; + canvas[x][y] = p(init + step / 2); + break; + } + d = (d + 1) % 4; + } + } +} + +void video_test() { + unsigned long last = 0; + unsigned long fps_last = 0; + int fps = 0; + + while (1) { + unsigned long upt = io_read(AM_TIMER_UPTIME).us / 1000; + if (upt - last > 1000 / FPS) { + update(); + redraw(); + last = upt; + fps ++; + } + if (upt - fps_last > 1000) { + // display fps every 1s + printf("%d: FPS = %d\n", upt, fps); + fps_last = upt; + fps = 0; + } + } +} diff --git a/am-kernels/tests/am-tests/src/tests/vm.c b/am-kernels/tests/am-tests/src/tests/vm.c new file mode 100644 index 0000000..c89079f --- /dev/null +++ b/am-kernels/tests/am-tests/src/tests/vm.c @@ -0,0 +1,90 @@ +#include + +static Context *uctx; +static AddrSpace prot; +static uintptr_t st = 0; +static int first_trap = 1; + +void *simple_pgalloc(int size) { + if (st == 0) { st = (uintptr_t)heap.start; } + while (st % size != 0) st++; + void *ret = (void *)st; + st += size; + return ret; +} + +void simple_pgfree(void *ptr) { +} + +Context* vm_handler(Event ev, Context *ctx) { + switch (ev.event) { + case EVENT_YIELD: + break; + case EVENT_IRQ_TIMER: + case EVENT_IRQ_IODEV: + printf("==== interrupt (%s) ====\n", ev.msg); + break; + case EVENT_PAGEFAULT: + printf("PF: %x %s%s%s\n", + ev.ref, + (ev.cause & MMAP_NONE) ? "[not present]" : "", + (ev.cause & MMAP_READ) ? "[read fail]" : "", + (ev.cause & MMAP_WRITE) ? "[write fail]" : ""); + break; + case EVENT_SYSCALL: + iset(1); + for (int volatile i = 0; i < 1000000; i++) ; + printf("%d ", ctx->GPRx); + break; + default: + assert(0); + } + if (first_trap) { + first_trap = 0; + return uctx; + } else { + return ctx; + } +} + +uint8_t code[] = { +#ifdef __ARCH_NATIVE + 0x31, 0xc0, // xor %eax, %eax + 0x83, 0xc0, 0x01, // add $1, %eax + 0xff, 0x14, 0x25, 0x00, 0x00, 0x10, 0x00, // call *0x100000 + 0xeb, 0xf4, // jmp 2 +#else + 0x31, 0xc0, // xor %eax, %eax + 0x8d, 0xb6, // lea 0(%esi), %esi + 0x00, 0x00, 0x00, 0x00, + 0x83, 0xc0, 0x01, // add $1, %eax + 0xcd, 0x80, // int $0x80 + 0xeb, 0xf9, // jmp 8 +#endif + +}; + +void vm_test() { + if (!strncmp(__ISA__, "x86", 3) == 0 && + !strcmp(__ISA__, "native") == 0) { + printf("Not supported architecture.\n"); + return; + } + protect(&prot); + printf("Protected address space: [%p, %p)\n", prot.area.start, prot.area.end); + + uint8_t *ptr = (void*)((uintptr_t)(prot.area.start) + + ((uintptr_t)(prot.area.end) - (uintptr_t)(prot.area.start)) / 2); + + void *pg = simple_pgalloc(prot.pgsize); + memcpy(pg, code, sizeof(code)); + + map(&prot, ptr, pg, MMAP_WRITE | MMAP_READ); + printf("Code copied to %p (physical %p) execute\n", ptr, pg); + + static uint8_t stack[4096]; + uctx = ucontext(&prot, RANGE(stack, stack + sizeof(stack)), ptr); + + iset(1); + yield(); +} diff --git a/am-kernels/tests/cpu-tests/.gitignore b/am-kernels/tests/cpu-tests/.gitignore new file mode 100644 index 0000000..9c45e66 --- /dev/null +++ b/am-kernels/tests/cpu-tests/.gitignore @@ -0,0 +1 @@ +/Makefile.* diff --git a/am-kernels/tests/cpu-tests/.result b/am-kernels/tests/cpu-tests/.result new file mode 100644 index 0000000..51d7fd1 --- /dev/null +++ b/am-kernels/tests/cpu-tests/.result @@ -0,0 +1,35 @@ +[ fact] PASS +[ select-sort] PASS +[ mul-longlong] PASS +[ to-lower-case] PASS +[ mersenne] PASS +[ fib] PASS +[ crc32] PASS +[ leap-year] PASS +[ mov-c] PASS +[ recursion] PASS +[ bubble-sort] PASS +[ add] PASS +[ add-longlong] PASS +[ shift] PASS +[ bit] PASS +[ min3] PASS +[ quick-sort] PASS +[ dummy] PASS +[ unalign] PASS +[ movsx] PASS +[ div] PASS +[ goldbach] PASS +[ prime] PASS +[ pascal] PASS +[ switch] PASS +[ max] PASS +[ sum] PASS +[ matrix-mul] PASS +[ hello-str] PASS +[ sub-longlong] PASS +[ shuixianhua] PASS +[ if-else] PASS +[ load-store] PASS +[ string] PASS +[ wanshu] PASS diff --git a/am-kernels/tests/cpu-tests/CMakeLists.txt b/am-kernels/tests/cpu-tests/CMakeLists.txt new file mode 100644 index 0000000..4504c42 --- /dev/null +++ b/am-kernels/tests/cpu-tests/CMakeLists.txt @@ -0,0 +1,3 @@ + +include_directories(include) +add_subdirectory(tests) diff --git a/am-kernels/tests/cpu-tests/Makefile b/am-kernels/tests/cpu-tests/Makefile new file mode 100644 index 0000000..7abb6b5 --- /dev/null +++ b/am-kernels/tests/cpu-tests/Makefile @@ -0,0 +1,35 @@ +.PHONY: all run gdb clean latest $(ALL) + +RESULT = .result +$(shell > $(RESULT)) + +COLOR_RED = \033[1;31m +COLOR_GREEN = \033[1;32m +COLOR_NONE = \033[0m + +ALL = $(basename $(notdir $(shell find tests/. -name "*.c"))) + +all: $(addprefix Makefile., $(ALL)) + @echo "test list [$(words $(ALL)) item(s)]:" $(ALL) + +$(ALL): %: Makefile.% + +Makefile.%: tests/%.c latest + @echo -e "NAME = $*\nSRCS = $<\ninclude $${AM_HOME}/Makefile" > $@ + @if make -s -f $@ ARCH=$(ARCH) $(MAKECMDGOALS); then \ + printf "[%14s] $(COLOR_GREEN)PASS$(COLOR_NONE)\n" $* >> $(RESULT); \ + else \ + printf "[%14s] $(COLOR_RED)***FAIL***$(COLOR_NONE)\n" $* >> $(RESULT); \ + fi + -@rm -f Makefile.$* + +run: all + @cat $(RESULT) + @rm $(RESULT) + +gdb: all + +clean: + rm -rf Makefile.* build/ + +latest: diff --git a/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.bin new file mode 100755 index 0000000..5ff73ca Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.elf new file mode 100755 index 0000000..3532d9e Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.txt new file mode 100644 index 0000000..323773a --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.txt @@ -0,0 +1,95 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/add-longlong-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 114000ef jal 80000120 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0f0000ef jal 80000114 + +80000028
: +80000028: fd010113 add sp,sp,-48 +8000002c: 01612823 sw s6,16(sp) +80000030: 00000b17 auipc s6,0x0 +80000034: 318b0b13 add s6,s6,792 # 80000348 +80000038: 03212023 sw s2,32(sp) +8000003c: 01312e23 sw s3,28(sp) +80000040: 01412c23 sw s4,24(sp) +80000044: 01512a23 sw s5,20(sp) +80000048: 01712623 sw s7,12(sp) +8000004c: 02112623 sw ra,44(sp) +80000050: 02812423 sw s0,40(sp) +80000054: 02912223 sw s1,36(sp) +80000058: 01812423 sw s8,8(sp) +8000005c: 01912223 sw s9,4(sp) +80000060: 00000a97 auipc s5,0x0 +80000064: 0e8a8a93 add s5,s5,232 # 80000148 +80000068: 000b0993 mv s3,s6 +8000006c: 00000a13 li s4,0 +80000070: 00000917 auipc s2,0x0 +80000074: 31890913 add s2,s2,792 # 80000388 <_bss_start> +80000078: 04000b93 li s7,64 +8000007c: 0009ac83 lw s9,0(s3) +80000080: 0049a483 lw s1,4(s3) +80000084: 000a8c13 mv s8,s5 +80000088: 000b0413 mv s0,s6 +8000008c: 00042783 lw a5,0(s0) +80000090: 00442603 lw a2,4(s0) +80000094: 004c2703 lw a4,4(s8) +80000098: 00fc87b3 add a5,s9,a5 +8000009c: 000c2503 lw a0,0(s8) +800000a0: 0197b6b3 sltu a3,a5,s9 +800000a4: 00c48633 add a2,s1,a2 +800000a8: 00c686b3 add a3,a3,a2 +800000ac: 00f54533 xor a0,a0,a5 +800000b0: 00d747b3 xor a5,a4,a3 +800000b4: 00f56533 or a0,a0,a5 +800000b8: 00153513 seqz a0,a0 +800000bc: 00840413 add s0,s0,8 +800000c0: f51ff0ef jal 80000010 +800000c4: 008c0c13 add s8,s8,8 +800000c8: fc8912e3 bne s2,s0,8000008c +800000cc: 008a0a13 add s4,s4,8 +800000d0: 00898993 add s3,s3,8 +800000d4: 040a8a93 add s5,s5,64 +800000d8: fb7a12e3 bne s4,s7,8000007c +800000dc: 02c12083 lw ra,44(sp) +800000e0: 02812403 lw s0,40(sp) +800000e4: 02412483 lw s1,36(sp) +800000e8: 02012903 lw s2,32(sp) +800000ec: 01c12983 lw s3,28(sp) +800000f0: 01812a03 lw s4,24(sp) +800000f4: 01412a83 lw s5,20(sp) +800000f8: 01012b03 lw s6,16(sp) +800000fc: 00c12b83 lw s7,12(sp) +80000100: 00812c03 lw s8,8(sp) +80000104: 00412c83 lw s9,4(sp) +80000108: 00000513 li a0,0 +8000010c: 03010113 add sp,sp,48 +80000110: 00008067 ret + +80000114 : +80000114: 00050513 mv a0,a0 +80000118: 00100073 ebreak +8000011c: 0000006f j 8000011c + +80000120 <_trm_init>: +80000120: ff010113 add sp,sp,-16 +80000124: 00000517 auipc a0,0x0 +80000128: 01c50513 add a0,a0,28 # 80000140 <_etext> +8000012c: 00112623 sw ra,12(sp) +80000130: ef9ff0ef jal 80000028
+80000134: 00050513 mv a0,a0 +80000138: 00100073 ebreak +8000013c: 0000006f j 8000013c <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.bin new file mode 100755 index 0000000..f584555 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.elf new file mode 100755 index 0000000..b8c0c52 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.txt new file mode 100644 index 0000000..f4dfcf7 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.txt @@ -0,0 +1,89 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/add-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0fc000ef jal 80000108 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0d8000ef jal 800000fc + +80000028
: +80000028: fd010113 add sp,sp,-48 +8000002c: 01712623 sw s7,12(sp) +80000030: 00000b97 auipc s7,0x0 +80000034: 1fcb8b93 add s7,s7,508 # 8000022c +80000038: 01312e23 sw s3,28(sp) +8000003c: 01412c23 sw s4,24(sp) +80000040: 01512a23 sw s5,20(sp) +80000044: 01612823 sw s6,16(sp) +80000048: 01812423 sw s8,8(sp) +8000004c: 02112623 sw ra,44(sp) +80000050: 02812423 sw s0,40(sp) +80000054: 02912223 sw s1,36(sp) +80000058: 03212023 sw s2,32(sp) +8000005c: 00000b17 auipc s6,0x0 +80000060: 0d0b0b13 add s6,s6,208 # 8000012c +80000064: 000b8a93 mv s5,s7 +80000068: 00000a13 li s4,0 +8000006c: 00000997 auipc s3,0x0 +80000070: 1e098993 add s3,s3,480 # 8000024c <_bss_start> +80000074: 04000c13 li s8,64 +80000078: 000aa903 lw s2,0(s5) +8000007c: 000b0493 mv s1,s6 +80000080: 000b8413 mv s0,s7 +80000084: 00042503 lw a0,0(s0) +80000088: 0004a783 lw a5,0(s1) +8000008c: 00440413 add s0,s0,4 +80000090: 00a90533 add a0,s2,a0 +80000094: 40f50533 sub a0,a0,a5 +80000098: 00153513 seqz a0,a0 +8000009c: f75ff0ef jal 80000010 +800000a0: 00448493 add s1,s1,4 +800000a4: fe8990e3 bne s3,s0,80000084 +800000a8: 00100513 li a0,1 +800000ac: 008a0a13 add s4,s4,8 +800000b0: f61ff0ef jal 80000010 +800000b4: 004a8a93 add s5,s5,4 +800000b8: 020b0b13 add s6,s6,32 +800000bc: fb8a1ee3 bne s4,s8,80000078 +800000c0: 00100513 li a0,1 +800000c4: f4dff0ef jal 80000010 +800000c8: 02c12083 lw ra,44(sp) +800000cc: 02812403 lw s0,40(sp) +800000d0: 02412483 lw s1,36(sp) +800000d4: 02012903 lw s2,32(sp) +800000d8: 01c12983 lw s3,28(sp) +800000dc: 01812a03 lw s4,24(sp) +800000e0: 01412a83 lw s5,20(sp) +800000e4: 01012b03 lw s6,16(sp) +800000e8: 00c12b83 lw s7,12(sp) +800000ec: 00812c03 lw s8,8(sp) +800000f0: 00000513 li a0,0 +800000f4: 03010113 add sp,sp,48 +800000f8: 00008067 ret + +800000fc : +800000fc: 00050513 mv a0,a0 +80000100: 00100073 ebreak +80000104: 0000006f j 80000104 + +80000108 <_trm_init>: +80000108: ff010113 add sp,sp,-16 +8000010c: 00000517 auipc a0,0x0 +80000110: 01c50513 add a0,a0,28 # 80000128 <_etext> +80000114: 00112623 sw ra,12(sp) +80000118: f11ff0ef jal 80000028
+8000011c: 00050513 mv a0,a0 +80000120: 00100073 ebreak +80000124: 0000006f j 80000124 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.bin new file mode 100755 index 0000000..d79c6de Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.elf new file mode 100755 index 0000000..52db85c Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.txt new file mode 100644 index 0000000..48cd02c --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.txt @@ -0,0 +1,156 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/bit-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 1f8000ef jal 80000204 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 1d4000ef jal 800001f8 + +80000028 : +80000028: 4035d793 sra a5,a1,0x3 +8000002c: 00f50533 add a0,a0,a5 +80000030: 00054503 lbu a0,0(a0) +80000034: 0075f593 and a1,a1,7 +80000038: 00100793 li a5,1 +8000003c: 00b797b3 sll a5,a5,a1 +80000040: 00f57533 and a0,a0,a5 +80000044: 00a03533 snez a0,a0 +80000048: 00008067 ret + +8000004c : +8000004c: 4035d793 sra a5,a1,0x3 +80000050: ff010113 add sp,sp,-16 +80000054: 00f50533 add a0,a0,a5 +80000058: 00a12623 sw a0,12(sp) +8000005c: 00c12783 lw a5,12(sp) +80000060: 0075f593 and a1,a1,7 +80000064: 00100713 li a4,1 +80000068: 00b71733 sll a4,a4,a1 +8000006c: 02061063 bnez a2,8000008c +80000070: 0007c783 lbu a5,0(a5) +80000074: fff74713 not a4,a4 +80000078: 00e7f7b3 and a5,a5,a4 +8000007c: 00c12703 lw a4,12(sp) +80000080: 00f70023 sb a5,0(a4) +80000084: 01010113 add sp,sp,16 +80000088: 00008067 ret +8000008c: 0007c783 lbu a5,0(a5) +80000090: 00e7e7b3 or a5,a5,a4 +80000094: 00c12703 lw a4,12(sp) +80000098: 0ff7f793 zext.b a5,a5 +8000009c: 00f70023 sb a5,0(a4) +800000a0: 01010113 add sp,sp,16 +800000a4: 00008067 ret + +800000a8
: +800000a8: fe010113 add sp,sp,-32 +800000ac: 0aa00793 li a5,170 +800000b0: 00000593 li a1,0 +800000b4: 00c10513 add a0,sp,12 +800000b8: 00112e23 sw ra,28(sp) +800000bc: 00f11623 sh a5,12(sp) +800000c0: f69ff0ef jal 80000028 +800000c4: 00154513 xor a0,a0,1 +800000c8: 0ff57513 zext.b a0,a0 +800000cc: f45ff0ef jal 80000010 +800000d0: 00100593 li a1,1 +800000d4: 00c10513 add a0,sp,12 +800000d8: f51ff0ef jal 80000028 +800000dc: f35ff0ef jal 80000010 +800000e0: 00200593 li a1,2 +800000e4: 00c10513 add a0,sp,12 +800000e8: f41ff0ef jal 80000028 +800000ec: 00154513 xor a0,a0,1 +800000f0: 0ff57513 zext.b a0,a0 +800000f4: f1dff0ef jal 80000010 +800000f8: 00300593 li a1,3 +800000fc: 00c10513 add a0,sp,12 +80000100: f29ff0ef jal 80000028 +80000104: f0dff0ef jal 80000010 +80000108: 00400593 li a1,4 +8000010c: 00c10513 add a0,sp,12 +80000110: f19ff0ef jal 80000028 +80000114: 00154513 xor a0,a0,1 +80000118: 0ff57513 zext.b a0,a0 +8000011c: ef5ff0ef jal 80000010 +80000120: 00500593 li a1,5 +80000124: 00c10513 add a0,sp,12 +80000128: f01ff0ef jal 80000028 +8000012c: ee5ff0ef jal 80000010 +80000130: 00600593 li a1,6 +80000134: 00c10513 add a0,sp,12 +80000138: ef1ff0ef jal 80000028 +8000013c: 00154513 xor a0,a0,1 +80000140: 0ff57513 zext.b a0,a0 +80000144: ecdff0ef jal 80000010 +80000148: 00700593 li a1,7 +8000014c: 00c10513 add a0,sp,12 +80000150: ed9ff0ef jal 80000028 +80000154: ebdff0ef jal 80000010 +80000158: 00c10513 add a0,sp,12 +8000015c: 00100613 li a2,1 +80000160: 00800593 li a1,8 +80000164: ee9ff0ef jal 8000004c +80000168: 00c10513 add a0,sp,12 +8000016c: 00000613 li a2,0 +80000170: 00900593 li a1,9 +80000174: ed9ff0ef jal 8000004c +80000178: 00c10513 add a0,sp,12 +8000017c: 00100613 li a2,1 +80000180: 00a00593 li a1,10 +80000184: ec9ff0ef jal 8000004c +80000188: 00c10513 add a0,sp,12 +8000018c: 00000613 li a2,0 +80000190: 00b00593 li a1,11 +80000194: eb9ff0ef jal 8000004c +80000198: 00c10513 add a0,sp,12 +8000019c: 00100613 li a2,1 +800001a0: 00c00593 li a1,12 +800001a4: ea9ff0ef jal 8000004c +800001a8: 00c10513 add a0,sp,12 +800001ac: 00000613 li a2,0 +800001b0: 00d00593 li a1,13 +800001b4: e99ff0ef jal 8000004c +800001b8: 00c10513 add a0,sp,12 +800001bc: 00100613 li a2,1 +800001c0: 00e00593 li a1,14 +800001c4: e89ff0ef jal 8000004c +800001c8: 00c10513 add a0,sp,12 +800001cc: 00000613 li a2,0 +800001d0: 00f00593 li a1,15 +800001d4: e79ff0ef jal 8000004c +800001d8: 00d14503 lbu a0,13(sp) +800001dc: fab50513 add a0,a0,-85 +800001e0: 00153513 seqz a0,a0 +800001e4: e2dff0ef jal 80000010 +800001e8: 01c12083 lw ra,28(sp) +800001ec: 00000513 li a0,0 +800001f0: 02010113 add sp,sp,32 +800001f4: 00008067 ret + +800001f8 : +800001f8: 00050513 mv a0,a0 +800001fc: 00100073 ebreak +80000200: 0000006f j 80000200 + +80000204 <_trm_init>: +80000204: ff010113 add sp,sp,-16 +80000208: 00000517 auipc a0,0x0 +8000020c: 01c50513 add a0,a0,28 # 80000224 <_etext> +80000210: 00112623 sw ra,12(sp) +80000214: e95ff0ef jal 800000a8
+80000218: 00050513 mv a0,a0 +8000021c: 00100073 ebreak +80000220: 0000006f j 80000220 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.bin new file mode 100755 index 0000000..7be5836 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.elf new file mode 100755 index 0000000..8c239db Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.txt new file mode 100644 index 0000000..50f811b --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.txt @@ -0,0 +1,94 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/bubble-sort-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 108000ef jal 80000114 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0e4000ef jal 80000108 + +80000028 : +80000028: 01300593 li a1,19 +8000002c: 00000797 auipc a5,0x0 +80000030: 10c78793 add a5,a5,268 # 80000138 +80000034: 00000713 li a4,0 +80000038: 0007a683 lw a3,0(a5) +8000003c: 0047a603 lw a2,4(a5) +80000040: 00170713 add a4,a4,1 +80000044: 00d65663 bge a2,a3,80000050 +80000048: 00c7a023 sw a2,0(a5) +8000004c: 00d7a223 sw a3,4(a5) +80000050: 00478793 add a5,a5,4 +80000054: feb742e3 blt a4,a1,80000038 +80000058: fff58593 add a1,a1,-1 +8000005c: fc0598e3 bnez a1,8000002c +80000060: 00008067 ret + +80000064
: +80000064: fe010113 add sp,sp,-32 +80000068: 00912a23 sw s1,20(sp) +8000006c: 00000497 auipc s1,0x0 +80000070: 0cc48493 add s1,s1,204 # 80000138 +80000074: 00812c23 sw s0,24(sp) +80000078: 01212823 sw s2,16(sp) +8000007c: 01312623 sw s3,12(sp) +80000080: 00112e23 sw ra,28(sp) +80000084: 00048913 mv s2,s1 +80000088: fa1ff0ef jal 80000028 +8000008c: 00000413 li s0,0 +80000090: 01400993 li s3,20 +80000094: 00092503 lw a0,0(s2) +80000098: 00490913 add s2,s2,4 +8000009c: 40850533 sub a0,a0,s0 +800000a0: 00153513 seqz a0,a0 +800000a4: 00140413 add s0,s0,1 +800000a8: f69ff0ef jal 80000010 +800000ac: ff3414e3 bne s0,s3,80000094 +800000b0: 00100513 li a0,1 +800000b4: f5dff0ef jal 80000010 +800000b8: 00000413 li s0,0 +800000bc: f6dff0ef jal 80000028 +800000c0: 01400913 li s2,20 +800000c4: 0004a503 lw a0,0(s1) +800000c8: 00448493 add s1,s1,4 +800000cc: 40850533 sub a0,a0,s0 +800000d0: 00153513 seqz a0,a0 +800000d4: 00140413 add s0,s0,1 +800000d8: f39ff0ef jal 80000010 +800000dc: ff2414e3 bne s0,s2,800000c4 +800000e0: 00100513 li a0,1 +800000e4: f2dff0ef jal 80000010 +800000e8: 01c12083 lw ra,28(sp) +800000ec: 01812403 lw s0,24(sp) +800000f0: 01412483 lw s1,20(sp) +800000f4: 01012903 lw s2,16(sp) +800000f8: 00c12983 lw s3,12(sp) +800000fc: 00000513 li a0,0 +80000100: 02010113 add sp,sp,32 +80000104: 00008067 ret + +80000108 : +80000108: 00050513 mv a0,a0 +8000010c: 00100073 ebreak +80000110: 0000006f j 80000110 + +80000114 <_trm_init>: +80000114: ff010113 add sp,sp,-16 +80000118: 00000517 auipc a0,0x0 +8000011c: 01c50513 add a0,a0,28 # 80000134 <_etext> +80000120: 00112623 sw ra,12(sp) +80000124: f41ff0ef jal 80000064
+80000128: 00050513 mv a0,a0 +8000012c: 00100073 ebreak +80000130: 0000006f j 80000130 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.bin new file mode 100755 index 0000000..6e2eecc Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.elf new file mode 100755 index 0000000..0073f8f Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.txt new file mode 100644 index 0000000..dad30d5 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.txt @@ -0,0 +1,95 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/crc32-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 10c000ef jal 80000118 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0e8000ef jal 8000010c + +80000028 : +80000028: 00000e97 auipc t4,0x0 +8000002c: 540e8e93 add t4,t4,1344 # 80000568 +80000030: 000ea883 lw a7,0(t4) +80000034: 04089a63 bnez a7,80000088 +80000038: edb88837 lui a6,0xedb88 +8000003c: 00000317 auipc t1,0x0 +80000040: 12c30313 add t1,t1,300 # 80000168 +80000044: 32080813 add a6,a6,800 # edb88320 <_end+0x6db7f320> +80000048: 10000e13 li t3,256 +8000004c: 00088713 mv a4,a7 +80000050: 00800693 li a3,8 +80000054: 00177793 and a5,a4,1 +80000058: 40f007b3 neg a5,a5 +8000005c: 0107f7b3 and a5,a5,a6 +80000060: 00175713 srl a4,a4,0x1 +80000064: fff68693 add a3,a3,-1 +80000068: 00e7c733 xor a4,a5,a4 +8000006c: fe0694e3 bnez a3,80000054 +80000070: 00e32023 sw a4,0(t1) +80000074: 00188893 add a7,a7,1 +80000078: 00430313 add t1,t1,4 +8000007c: fdc898e3 bne a7,t3,8000004c +80000080: 00100793 li a5,1 +80000084: 00fea023 sw a5,0(t4) +80000088: 00c58633 add a2,a1,a2 +8000008c: fff54713 not a4,a0 +80000090: 02c5fc63 bgeu a1,a2,800000c8 +80000094: 00000517 auipc a0,0x0 +80000098: 0d450513 add a0,a0,212 # 80000168 +8000009c: 0005c683 lbu a3,0(a1) +800000a0: 0ff77793 zext.b a5,a4 +800000a4: 00158593 add a1,a1,1 +800000a8: 00d7c7b3 xor a5,a5,a3 +800000ac: 00279793 sll a5,a5,0x2 +800000b0: 00f507b3 add a5,a0,a5 +800000b4: 0007a783 lw a5,0(a5) +800000b8: 00875713 srl a4,a4,0x8 +800000bc: 00f74733 xor a4,a4,a5 +800000c0: fcb61ee3 bne a2,a1,8000009c +800000c4: fff74513 not a0,a4 +800000c8: 00008067 ret + +800000cc
: +800000cc: ff010113 add sp,sp,-16 +800000d0: 02b00613 li a2,43 +800000d4: 00000597 auipc a1,0x0 +800000d8: 06458593 add a1,a1,100 # 80000138 <_etext> +800000dc: 00000513 li a0,0 +800000e0: 00112623 sw ra,12(sp) +800000e4: f45ff0ef jal 80000028 +800000e8: beb067b7 lui a5,0xbeb06 +800000ec: cc778793 add a5,a5,-825 # beb05cc7 <_end+0x3eafccc7> +800000f0: 00f50533 add a0,a0,a5 +800000f4: 00153513 seqz a0,a0 +800000f8: f19ff0ef jal 80000010 +800000fc: 00c12083 lw ra,12(sp) +80000100: 00000513 li a0,0 +80000104: 01010113 add sp,sp,16 +80000108: 00008067 ret + +8000010c : +8000010c: 00050513 mv a0,a0 +80000110: 00100073 ebreak +80000114: 0000006f j 80000114 + +80000118 <_trm_init>: +80000118: ff010113 add sp,sp,-16 +8000011c: 00000517 auipc a0,0x0 +80000120: 04850513 add a0,a0,72 # 80000164 +80000124: 00112623 sw ra,12(sp) +80000128: fa5ff0ef jal 800000cc
+8000012c: 00050513 mv a0,a0 +80000130: 00100073 ebreak +80000134: 0000006f j 80000134 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.bin new file mode 100755 index 0000000..145825d Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.elf new file mode 100755 index 0000000..af7ffca Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.txt new file mode 100644 index 0000000..69e671b --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.txt @@ -0,0 +1,90 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/div-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 100000ef jal 8000010c <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0dc000ef jal 80000100 + +80000028
: +80000028: ff010113 add sp,sp,-16 +8000002c: 00912223 sw s1,4(sp) +80000030: 00000497 auipc s1,0x0 +80000034: 10048493 add s1,s1,256 # 80000130 +80000038: 00112623 sw ra,12(sp) +8000003c: 00812423 sw s0,8(sp) +80000040: 01212023 sw s2,0(sp) +80000044: 00048713 mv a4,s1 +80000048: 00000793 li a5,0 +8000004c: 00a00693 li a3,10 +80000050: 00f72023 sw a5,0(a4) +80000054: 00178793 add a5,a5,1 +80000058: 00470713 add a4,a4,4 +8000005c: fed79ae3 bne a5,a3,80000050 +80000060: 00000597 auipc a1,0x0 +80000064: 0f858593 add a1,a1,248 # 80000158 +80000068: 00000617 auipc a2,0x0 +8000006c: 0c860613 add a2,a2,200 # 80000130 +80000070: 00b00693 li a3,11 +80000074: 00062703 lw a4,0(a2) +80000078: 00100793 li a5,1 +8000007c: 02f70733 mul a4,a4,a5 +80000080: 00178793 add a5,a5,1 +80000084: fed79ce3 bne a5,a3,8000007c +80000088: 00e62023 sw a4,0(a2) +8000008c: 00460613 add a2,a2,4 +80000090: feb612e3 bne a2,a1,80000074 +80000094: 00000617 auipc a2,0x0 +80000098: 09c60613 add a2,a2,156 # 80000130 +8000009c: 00b00693 li a3,11 +800000a0: 00062703 lw a4,0(a2) +800000a4: 00100793 li a5,1 +800000a8: 02f74733 div a4,a4,a5 +800000ac: 00178793 add a5,a5,1 +800000b0: fed79ce3 bne a5,a3,800000a8 +800000b4: 00e62023 sw a4,0(a2) +800000b8: 00460613 add a2,a2,4 +800000bc: feb612e3 bne a2,a1,800000a0 +800000c0: 00000413 li s0,0 +800000c4: 00a00913 li s2,10 +800000c8: 0004a503 lw a0,0(s1) +800000cc: 00448493 add s1,s1,4 +800000d0: 40850533 sub a0,a0,s0 +800000d4: 00153513 seqz a0,a0 +800000d8: 00140413 add s0,s0,1 +800000dc: f35ff0ef jal 80000010 +800000e0: ff2414e3 bne s0,s2,800000c8 +800000e4: 00c12083 lw ra,12(sp) +800000e8: 00812403 lw s0,8(sp) +800000ec: 00412483 lw s1,4(sp) +800000f0: 00012903 lw s2,0(sp) +800000f4: 00000513 li a0,0 +800000f8: 01010113 add sp,sp,16 +800000fc: 00008067 ret + +80000100 : +80000100: 00050513 mv a0,a0 +80000104: 00100073 ebreak +80000108: 0000006f j 80000108 + +8000010c <_trm_init>: +8000010c: ff010113 add sp,sp,-16 +80000110: 00000517 auipc a0,0x0 +80000114: 01c50513 add a0,a0,28 # 8000012c <_etext> +80000118: 00112623 sw ra,12(sp) +8000011c: f0dff0ef jal 80000028
+80000120: 00050513 mv a0,a0 +80000124: 00100073 ebreak +80000128: 0000006f j 80000128 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.bin new file mode 100755 index 0000000..7696449 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.elf new file mode 100755 index 0000000..2a3c2c9 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.txt new file mode 100644 index 0000000..f31ee00 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.txt @@ -0,0 +1,25 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/dummy-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 00c000ef jal 80000018 <_trm_init> + +80000010
: +80000010: 00000513 li a0,0 +80000014: 00008067 ret + +80000018 <_trm_init>: +80000018: ff010113 add sp,sp,-16 +8000001c: 00000517 auipc a0,0x0 +80000020: 01c50513 add a0,a0,28 # 80000038 <_etext> +80000024: 00112623 sw ra,12(sp) +80000028: fe9ff0ef jal 80000010
+8000002c: 00050513 mv a0,a0 +80000030: 00100073 ebreak +80000034: 0000006f j 80000034 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.bin b/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.bin new file mode 100755 index 0000000..016f29c Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.elf b/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.elf new file mode 100755 index 0000000..f91d77d Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.txt b/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.txt new file mode 100644 index 0000000..a5b2cf1 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.txt @@ -0,0 +1,25 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/dummy-riscv32e-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 00c000ef jal 80000018 <_trm_init> + +80000010
: +80000010: 00000513 li a0,0 +80000014: 00008067 ret + +80000018 <_trm_init>: +80000018: ff410113 add sp,sp,-12 +8000001c: 00000517 auipc a0,0x0 +80000020: 01c50513 add a0,a0,28 # 80000038 <_etext> +80000024: 00112423 sw ra,8(sp) +80000028: fe9ff0ef jal 80000010
+8000002c: 00050513 mv a0,a0 +80000030: 00100073 ebreak +80000034: 0000006f j 80000034 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.bin new file mode 100755 index 0000000..11ce6b5 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.elf new file mode 100755 index 0000000..0547792 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.txt new file mode 100644 index 0000000..ee4e40a --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.txt @@ -0,0 +1,84 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/fact-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0e8000ef jal 800000f4 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0c4000ef jal 800000e8 + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00812c23 sw s0,24(sp) +80000030: 00912a23 sw s1,20(sp) +80000034: 01212823 sw s2,16(sp) +80000038: 01312623 sw s3,12(sp) +8000003c: 01412423 sw s4,8(sp) +80000040: 00112e23 sw ra,28(sp) +80000044: 00000997 auipc s3,0x0 +80000048: 10898993 add s3,s3,264 # 8000014c +8000004c: 00000917 auipc s2,0x0 +80000050: 0cc90913 add s2,s2,204 # 80000118 +80000054: 00000493 li s1,0 +80000058: 00100413 li s0,1 +8000005c: 00d00a13 li s4,13 +80000060: 06945263 bge s0,s1,800000c4 +80000064: 00048793 mv a5,s1 +80000068: 00100713 li a4,1 +8000006c: 00078693 mv a3,a5 +80000070: fff78793 add a5,a5,-1 +80000074: 02d70733 mul a4,a4,a3 +80000078: fe879ae3 bne a5,s0,8000006c +8000007c: 00092503 lw a0,0(s2) +80000080: 00e9a023 sw a4,0(s3) +80000084: 00148493 add s1,s1,1 +80000088: 40e50533 sub a0,a0,a4 +8000008c: 00153513 seqz a0,a0 +80000090: f81ff0ef jal 80000010 +80000094: 00498993 add s3,s3,4 +80000098: 00490913 add s2,s2,4 +8000009c: fd4492e3 bne s1,s4,80000060 +800000a0: 01c12083 lw ra,28(sp) +800000a4: 01812403 lw s0,24(sp) +800000a8: 01412483 lw s1,20(sp) +800000ac: 01012903 lw s2,16(sp) +800000b0: 00c12983 lw s3,12(sp) +800000b4: 00812a03 lw s4,8(sp) +800000b8: 00000513 li a0,0 +800000bc: 02010113 add sp,sp,32 +800000c0: 00008067 ret +800000c4: 00092503 lw a0,0(s2) +800000c8: 0089a023 sw s0,0(s3) +800000cc: 00148493 add s1,s1,1 +800000d0: fff50513 add a0,a0,-1 +800000d4: 00153513 seqz a0,a0 +800000d8: f39ff0ef jal 80000010 +800000dc: 00498993 add s3,s3,4 +800000e0: 00490913 add s2,s2,4 +800000e4: f7dff06f j 80000060 + +800000e8 : +800000e8: 00050513 mv a0,a0 +800000ec: 00100073 ebreak +800000f0: 0000006f j 800000f0 + +800000f4 <_trm_init>: +800000f4: ff010113 add sp,sp,-16 +800000f8: 00000517 auipc a0,0x0 +800000fc: 01c50513 add a0,a0,28 # 80000114 <_etext> +80000100: 00112623 sw ra,12(sp) +80000104: f25ff0ef jal 80000028
+80000108: 00050513 mv a0,a0 +8000010c: 00100073 ebreak +80000110: 0000006f j 80000110 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.bin new file mode 100755 index 0000000..0c4cf17 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.elf new file mode 100755 index 0000000..fb9c152 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.txt new file mode 100644 index 0000000..0921c8b --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.txt @@ -0,0 +1,67 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/fib-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0a4000ef jal 800000b0 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 080000ef jal 800000a4 + +80000028
: +80000028: ff010113 add sp,sp,-16 +8000002c: 00812423 sw s0,8(sp) +80000030: 00912223 sw s1,4(sp) +80000034: 01212023 sw s2,0(sp) +80000038: 00112623 sw ra,12(sp) +8000003c: 00000417 auipc s0,0x0 +80000040: 13840413 add s0,s0,312 # 80000174 +80000044: 00000497 auipc s1,0x0 +80000048: 09848493 add s1,s1,152 # 800000dc +8000004c: 00000917 auipc s2,0x0 +80000050: 1c090913 add s2,s2,448 # 8000020c +80000054: 00042703 lw a4,0(s0) +80000058: 00442783 lw a5,4(s0) +8000005c: 0004a503 lw a0,0(s1) +80000060: 00440413 add s0,s0,4 +80000064: 00e787b3 add a5,a5,a4 +80000068: 40f50533 sub a0,a0,a5 +8000006c: 00f42223 sw a5,4(s0) +80000070: 00153513 seqz a0,a0 +80000074: f9dff0ef jal 80000010 +80000078: 00448493 add s1,s1,4 +8000007c: fd241ce3 bne s0,s2,80000054 +80000080: 00100513 li a0,1 +80000084: f8dff0ef jal 80000010 +80000088: 00c12083 lw ra,12(sp) +8000008c: 00812403 lw s0,8(sp) +80000090: 00412483 lw s1,4(sp) +80000094: 00012903 lw s2,0(sp) +80000098: 00000513 li a0,0 +8000009c: 01010113 add sp,sp,16 +800000a0: 00008067 ret + +800000a4 : +800000a4: 00050513 mv a0,a0 +800000a8: 00100073 ebreak +800000ac: 0000006f j 800000ac + +800000b0 <_trm_init>: +800000b0: ff010113 add sp,sp,-16 +800000b4: 00000517 auipc a0,0x0 +800000b8: 01c50513 add a0,a0,28 # 800000d0 <_etext> +800000bc: 00112623 sw ra,12(sp) +800000c0: f69ff0ef jal 80000028
+800000c4: 00050513 mv a0,a0 +800000c8: 00100073 ebreak +800000cc: 0000006f j 800000cc <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.bin new file mode 100755 index 0000000..e3f319b Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.elf new file mode 100755 index 0000000..13f22ed Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.txt new file mode 100644 index 0000000..5d908b1 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.txt @@ -0,0 +1,99 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/goldbach-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 11c000ef jal 80000128 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0f8000ef jal 8000011c + +80000028 : +80000028: 00200793 li a5,2 +8000002c: 00050813 mv a6,a0 +80000030: 08a7d863 bge a5,a0,800000c0 +80000034: ffe50713 add a4,a0,-2 +80000038: 00100793 li a5,1 +8000003c: 00000513 li a0,0 +80000040: 06f70e63 beq a4,a5,800000bc +80000044: 00070593 mv a1,a4 +80000048: 00200693 li a3,2 +8000004c: 00200313 li t1,2 +80000050: 00100893 li a7,1 +80000054: 06670a63 beq a4,t1,800000c8 +80000058: 00177513 and a0,a4,1 +8000005c: 00200793 li a5,2 +80000060: 00051863 bnez a0,80000070 +80000064: 0200006f j 80000084 +80000068: 02f76633 rem a2,a4,a5 +8000006c: 00060c63 beqz a2,80000084 +80000070: 00178793 add a5,a5,1 +80000074: fee79ae3 bne a5,a4,80000068 +80000078: 00008067 ret +8000007c: 00058713 mv a4,a1 +80000080: fcb8cae3 blt a7,a1,80000054 +80000084: 00068613 mv a2,a3 +80000088: 00168693 add a3,a3,1 +8000008c: fff58593 add a1,a1,-1 +80000090: 02d80863 beq a6,a3,800000c0 +80000094: 0016f793 and a5,a3,1 +80000098: fe0786e3 beqz a5,80000084 +8000009c: 00200793 li a5,2 +800000a0: 00c0006f j 800000ac +800000a4: 02f6e733 rem a4,a3,a5 +800000a8: fc070ee3 beqz a4,80000084 +800000ac: 00078713 mv a4,a5 +800000b0: 00178793 add a5,a5,1 +800000b4: fec718e3 bne a4,a2,800000a4 +800000b8: fc5ff06f j 8000007c +800000bc: 00008067 ret +800000c0: 00000513 li a0,0 +800000c4: 00008067 ret +800000c8: 00100513 li a0,1 +800000cc: 00008067 ret + +800000d0
: +800000d0: ff010113 add sp,sp,-16 +800000d4: 00812423 sw s0,8(sp) +800000d8: 00912223 sw s1,4(sp) +800000dc: 00112623 sw ra,12(sp) +800000e0: 00400413 li s0,4 +800000e4: 02000493 li s1,32 +800000e8: 00040513 mv a0,s0 +800000ec: f3dff0ef jal 80000028 +800000f0: fff50513 add a0,a0,-1 +800000f4: 00153513 seqz a0,a0 +800000f8: 00240413 add s0,s0,2 +800000fc: f15ff0ef jal 80000010 +80000100: fe9414e3 bne s0,s1,800000e8 +80000104: 00c12083 lw ra,12(sp) +80000108: 00812403 lw s0,8(sp) +8000010c: 00412483 lw s1,4(sp) +80000110: 00000513 li a0,0 +80000114: 01010113 add sp,sp,16 +80000118: 00008067 ret + +8000011c : +8000011c: 00050513 mv a0,a0 +80000120: 00100073 ebreak +80000124: 0000006f j 80000124 + +80000128 <_trm_init>: +80000128: ff010113 add sp,sp,-16 +8000012c: 00000517 auipc a0,0x0 +80000130: 01c50513 add a0,a0,28 # 80000148 <_etext> +80000134: 00112623 sw ra,12(sp) +80000138: f99ff0ef jal 800000d0
+8000013c: 00050513 mv a0,a0 +80000140: 00100073 ebreak +80000144: 0000006f j 80000144 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.bin new file mode 100755 index 0000000..99a59f6 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.elf new file mode 100755 index 0000000..83b6cc8 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.txt new file mode 100644 index 0000000..453d6c6 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.txt @@ -0,0 +1,153 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/hello-str-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0fc000ef jal 80000108 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0d8000ef jal 800000fc + +80000028
: +80000028: ff010113 add sp,sp,-16 +8000002c: 00000617 auipc a2,0x0 +80000030: 1e460613 add a2,a2,484 # 80000210 <_etext> +80000034: 00000597 auipc a1,0x0 +80000038: 1ec58593 add a1,a1,492 # 80000220 <_etext+0x10> +8000003c: 00000517 auipc a0,0x0 +80000040: 36050513 add a0,a0,864 # 8000039c +80000044: 00112623 sw ra,12(sp) +80000048: 0e0000ef jal 80000128 +8000004c: 00000597 auipc a1,0x0 +80000050: 1c458593 add a1,a1,452 # 80000210 <_etext> +80000054: 00000517 auipc a0,0x0 +80000058: 34850513 add a0,a0,840 # 8000039c +8000005c: 14c000ef jal 800001a8 +80000060: 00153513 seqz a0,a0 +80000064: fadff0ef jal 80000010 +80000068: 00200713 li a4,2 +8000006c: 00100693 li a3,1 +80000070: 00100613 li a2,1 +80000074: 00000597 auipc a1,0x0 +80000078: 1b058593 add a1,a1,432 # 80000224 <_etext+0x14> +8000007c: 00000517 auipc a0,0x0 +80000080: 32050513 add a0,a0,800 # 8000039c +80000084: 0a4000ef jal 80000128 +80000088: 00000597 auipc a1,0x0 +8000008c: 1ac58593 add a1,a1,428 # 80000234 <_etext+0x24> +80000090: 00000517 auipc a0,0x0 +80000094: 30c50513 add a0,a0,780 # 8000039c +80000098: 110000ef jal 800001a8 +8000009c: 00153513 seqz a0,a0 +800000a0: f71ff0ef jal 80000010 +800000a4: 00c00713 li a4,12 +800000a8: 00a00693 li a3,10 +800000ac: 00200613 li a2,2 +800000b0: 00000597 auipc a1,0x0 +800000b4: 17458593 add a1,a1,372 # 80000224 <_etext+0x14> +800000b8: 00000517 auipc a0,0x0 +800000bc: 2e450513 add a0,a0,740 # 8000039c +800000c0: 068000ef jal 80000128 +800000c4: 00000597 auipc a1,0x0 +800000c8: 17c58593 add a1,a1,380 # 80000240 <_etext+0x30> +800000cc: 00000517 auipc a0,0x0 +800000d0: 2d050513 add a0,a0,720 # 8000039c +800000d4: 0d4000ef jal 800001a8 +800000d8: 00153513 seqz a0,a0 +800000dc: f35ff0ef jal 80000010 +800000e0: 00c12083 lw ra,12(sp) +800000e4: 00000513 li a0,0 +800000e8: 01010113 add sp,sp,16 +800000ec: 00008067 ret + +800000f0 : +800000f0: a00007b7 lui a5,0xa0000 +800000f4: 3ea78c23 sb a0,1016(a5) # a00003f8 <_end+0x1fff73f8> +800000f8: 00008067 ret + +800000fc : +800000fc: 00050513 mv a0,a0 +80000100: 00100073 ebreak +80000104: 0000006f j 80000104 + +80000108 <_trm_init>: +80000108: ff010113 add sp,sp,-16 +8000010c: 00000517 auipc a0,0x0 +80000110: 28c50513 add a0,a0,652 # 80000398 +80000114: 00112623 sw ra,12(sp) +80000118: f11ff0ef jal 80000028
+8000011c: 00050513 mv a0,a0 +80000120: 00100073 ebreak +80000124: 0000006f j 80000124 <_trm_init+0x1c> + +80000128 : +80000128: fd010113 add sp,sp,-48 +8000012c: 00812423 sw s0,8(sp) +80000130: 00112623 sw ra,12(sp) +80000134: 00c12c23 sw a2,24(sp) +80000138: 00d12e23 sw a3,28(sp) +8000013c: 02e12023 sw a4,32(sp) +80000140: 02f12223 sw a5,36(sp) +80000144: 03012423 sw a6,40(sp) +80000148: 03112623 sw a7,44(sp) +8000014c: 00000417 auipc s0,0x0 +80000150: 10440413 add s0,s0,260 # 80000250 <_etext+0x40> +80000154: 04100513 li a0,65 +80000158: f99ff0ef jal 800000f0 +8000015c: 00144503 lbu a0,1(s0) +80000160: 00140413 add s0,s0,1 +80000164: fe051ae3 bnez a0,80000158 +80000168: 00000417 auipc s0,0x0 +8000016c: 0f440413 add s0,s0,244 # 8000025c <_etext+0x4c> +80000170: 04e00513 li a0,78 +80000174: f7dff0ef jal 800000f0 +80000178: 00144503 lbu a0,1(s0) +8000017c: 00140413 add s0,s0,1 +80000180: fe051ae3 bnez a0,80000174 +80000184: 00000417 auipc s0,0x0 +80000188: 13040413 add s0,s0,304 # 800002b4 <_etext+0xa4> +8000018c: 02000513 li a0,32 +80000190: f61ff0ef jal 800000f0 +80000194: 00144503 lbu a0,1(s0) +80000198: 00140413 add s0,s0,1 +8000019c: fe051ae3 bnez a0,80000190 +800001a0: 00100513 li a0,1 +800001a4: f59ff0ef jal 800000fc + +800001a8 : +800001a8: ff010113 add sp,sp,-16 +800001ac: 00812423 sw s0,8(sp) +800001b0: 00112623 sw ra,12(sp) +800001b4: 00000417 auipc s0,0x0 +800001b8: 09c40413 add s0,s0,156 # 80000250 <_etext+0x40> +800001bc: 04100513 li a0,65 +800001c0: f31ff0ef jal 800000f0 +800001c4: 00144503 lbu a0,1(s0) +800001c8: 00140413 add s0,s0,1 +800001cc: fe051ae3 bnez a0,800001c0 +800001d0: 00000417 auipc s0,0x0 +800001d4: 08c40413 add s0,s0,140 # 8000025c <_etext+0x4c> +800001d8: 04e00513 li a0,78 +800001dc: f15ff0ef jal 800000f0 +800001e0: 00144503 lbu a0,1(s0) +800001e4: 00140413 add s0,s0,1 +800001e8: fe051ae3 bnez a0,800001dc +800001ec: 00000417 auipc s0,0x0 +800001f0: 16040413 add s0,s0,352 # 8000034c <_etext+0x13c> +800001f4: 02000513 li a0,32 +800001f8: ef9ff0ef jal 800000f0 +800001fc: 00144503 lbu a0,1(s0) +80000200: 00140413 add s0,s0,1 +80000204: fe051ae3 bnez a0,800001f8 +80000208: 00100513 li a0,1 +8000020c: ef1ff0ef jal 800000fc diff --git a/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.bin new file mode 100755 index 0000000..7ef2b45 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.elf new file mode 100755 index 0000000..6fcb3c8 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.txt new file mode 100644 index 0000000..5725954 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.txt @@ -0,0 +1,85 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/if-else-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0ec000ef jal 800000f8 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0c8000ef jal 800000ec + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00812c23 sw s0,24(sp) +80000030: 00912a23 sw s1,20(sp) +80000034: 01212823 sw s2,16(sp) +80000038: 01312623 sw s3,12(sp) +8000003c: 01412423 sw s4,8(sp) +80000040: 01512223 sw s5,4(sp) +80000044: 01612023 sw s6,0(sp) +80000048: 00112e23 sw ra,28(sp) +8000004c: 00000417 auipc s0,0x0 +80000050: 10840413 add s0,s0,264 # 80000154 +80000054: 00000497 auipc s1,0x0 +80000058: 0c848493 add s1,s1,200 # 8000011c +8000005c: 00000997 auipc s3,0x0 +80000060: 13098993 add s3,s3,304 # 8000018c <_bss_start> +80000064: 1f400913 li s2,500 +80000068: 12c00a13 li s4,300 +8000006c: 06400a93 li s5,100 +80000070: 03200b13 li s6,50 +80000074: 00042703 lw a4,0(s0) +80000078: 09600793 li a5,150 +8000007c: 02e94063 blt s2,a4,8000009c +80000080: 06400793 li a5,100 +80000084: 00ea4c63 blt s4,a4,8000009c +80000088: 04b00793 li a5,75 +8000008c: 00eac863 blt s5,a4,8000009c +80000090: 00000793 li a5,0 +80000094: 00eb5463 bge s6,a4,8000009c +80000098: 03200793 li a5,50 +8000009c: 0004a503 lw a0,0(s1) +800000a0: 00440413 add s0,s0,4 +800000a4: 00448493 add s1,s1,4 +800000a8: 40f50533 sub a0,a0,a5 +800000ac: 00153513 seqz a0,a0 +800000b0: f61ff0ef jal 80000010 +800000b4: fd3410e3 bne s0,s3,80000074 +800000b8: 00100513 li a0,1 +800000bc: f55ff0ef jal 80000010 +800000c0: 01c12083 lw ra,28(sp) +800000c4: 01812403 lw s0,24(sp) +800000c8: 01412483 lw s1,20(sp) +800000cc: 01012903 lw s2,16(sp) +800000d0: 00c12983 lw s3,12(sp) +800000d4: 00812a03 lw s4,8(sp) +800000d8: 00412a83 lw s5,4(sp) +800000dc: 00012b03 lw s6,0(sp) +800000e0: 00000513 li a0,0 +800000e4: 02010113 add sp,sp,32 +800000e8: 00008067 ret + +800000ec : +800000ec: 00050513 mv a0,a0 +800000f0: 00100073 ebreak +800000f4: 0000006f j 800000f4 + +800000f8 <_trm_init>: +800000f8: ff010113 add sp,sp,-16 +800000fc: 00000517 auipc a0,0x0 +80000100: 01c50513 add a0,a0,28 # 80000118 <_etext> +80000104: 00112623 sw ra,12(sp) +80000108: f21ff0ef jal 80000028
+8000010c: 00050513 mv a0,a0 +80000110: 00100073 ebreak +80000114: 0000006f j 80000114 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.bin new file mode 100755 index 0000000..c6e7572 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.elf new file mode 100755 index 0000000..a25b7ad Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.txt new file mode 100644 index 0000000..d2ba299 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.txt @@ -0,0 +1,72 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/leap-year-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0b8000ef jal 800000c4 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 094000ef jal 800000b8 + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00812c23 sw s0,24(sp) +80000030: 00912a23 sw s1,20(sp) +80000034: 01212823 sw s2,16(sp) +80000038: 01312623 sw s3,12(sp) +8000003c: 01412423 sw s4,8(sp) +80000040: 00112e23 sw ra,28(sp) +80000044: 00000497 auipc s1,0x0 +80000048: 0a448493 add s1,s1,164 # 800000e8 +8000004c: 76200413 li s0,1890 +80000050: 19000993 li s3,400 +80000054: 06400a13 li s4,100 +80000058: 7df00913 li s2,2015 +8000005c: 00347793 and a5,s0,3 +80000060: 00079863 bnez a5,80000070 +80000064: 03446733 rem a4,s0,s4 +80000068: 00100793 li a5,1 +8000006c: 00071663 bnez a4,80000078 +80000070: 033467b3 rem a5,s0,s3 +80000074: 0017b793 seqz a5,a5 +80000078: 0004a503 lw a0,0(s1) +8000007c: 00140413 add s0,s0,1 +80000080: 00448493 add s1,s1,4 +80000084: 40f50533 sub a0,a0,a5 +80000088: 00153513 seqz a0,a0 +8000008c: f85ff0ef jal 80000010 +80000090: fd2416e3 bne s0,s2,8000005c +80000094: 01c12083 lw ra,28(sp) +80000098: 01812403 lw s0,24(sp) +8000009c: 01412483 lw s1,20(sp) +800000a0: 01012903 lw s2,16(sp) +800000a4: 00c12983 lw s3,12(sp) +800000a8: 00812a03 lw s4,8(sp) +800000ac: 00000513 li a0,0 +800000b0: 02010113 add sp,sp,32 +800000b4: 00008067 ret + +800000b8 : +800000b8: 00050513 mv a0,a0 +800000bc: 00100073 ebreak +800000c0: 0000006f j 800000c0 + +800000c4 <_trm_init>: +800000c4: ff010113 add sp,sp,-16 +800000c8: 00000517 auipc a0,0x0 +800000cc: 01c50513 add a0,a0,28 # 800000e4 <_etext> +800000d0: 00112623 sw ra,12(sp) +800000d4: f55ff0ef jal 80000028
+800000d8: 00050513 mv a0,a0 +800000dc: 00100073 ebreak +800000e0: 0000006f j 800000e0 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.bin new file mode 100755 index 0000000..37acde6 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.elf new file mode 100755 index 0000000..7c8715f Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.txt new file mode 100644 index 0000000..bf6859b --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.txt @@ -0,0 +1,140 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/load-store-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 1c8000ef jal 800001d4 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 1a4000ef jal 800001c8 + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00812c23 sw s0,24(sp) +80000030: 00000417 auipc s0,0x0 +80000034: 23840413 add s0,s0,568 # 80000268 +80000038: 00912a23 sw s1,20(sp) +8000003c: 01212823 sw s2,16(sp) +80000040: 01312623 sw s3,12(sp) +80000044: 01412423 sw s4,8(sp) +80000048: 00112e23 sw ra,28(sp) +8000004c: 00000997 auipc s3,0x0 +80000050: 1fc98993 add s3,s3,508 # 80000248 +80000054: 00000a17 auipc s4,0x0 +80000058: 224a0a13 add s4,s4,548 # 80000278 <_bss_start> +8000005c: 00040913 mv s2,s0 +80000060: 00040493 mv s1,s0 +80000064: 0009a783 lw a5,0(s3) +80000068: 00049503 lh a0,0(s1) +8000006c: 00248493 add s1,s1,2 +80000070: 00498993 add s3,s3,4 +80000074: 40f50533 sub a0,a0,a5 +80000078: 00153513 seqz a0,a0 +8000007c: f95ff0ef jal 80000010 +80000080: ff4492e3 bne s1,s4,80000064 +80000084: 00000497 auipc s1,0x0 +80000088: 1a448493 add s1,s1,420 # 80000228 +8000008c: 0004a783 lw a5,0(s1) +80000090: 00045503 lhu a0,0(s0) +80000094: 00240413 add s0,s0,2 +80000098: 00448493 add s1,s1,4 +8000009c: 40f50533 sub a0,a0,a5 +800000a0: 00153513 seqz a0,a0 +800000a4: f6dff0ef jal 80000010 +800000a8: ff4412e3 bne s0,s4,8000008c +800000ac: 00294683 lbu a3,2(s2) +800000b0: 00194603 lbu a2,1(s2) +800000b4: 00394703 lbu a4,3(s2) +800000b8: 00494783 lbu a5,4(s2) +800000bc: 00000417 auipc s0,0x0 +800000c0: 13c40413 add s0,s0,316 # 800001f8 +800000c4: 00869693 sll a3,a3,0x8 +800000c8: 00c6e6b3 or a3,a3,a2 +800000cc: 00042503 lw a0,0(s0) +800000d0: 01071713 sll a4,a4,0x10 +800000d4: 00d76733 or a4,a4,a3 +800000d8: 01879793 sll a5,a5,0x18 +800000dc: 00e7e7b3 or a5,a5,a4 +800000e0: 40f50533 sub a0,a0,a5 +800000e4: 00153513 seqz a0,a0 +800000e8: f29ff0ef jal 80000010 +800000ec: 00694683 lbu a3,6(s2) +800000f0: 00594603 lbu a2,5(s2) +800000f4: 00794703 lbu a4,7(s2) +800000f8: 00894783 lbu a5,8(s2) +800000fc: 00869693 sll a3,a3,0x8 +80000100: 00c6e6b3 or a3,a3,a2 +80000104: 00442503 lw a0,4(s0) +80000108: 01071713 sll a4,a4,0x10 +8000010c: 00d76733 or a4,a4,a3 +80000110: 01879793 sll a5,a5,0x18 +80000114: 00e7e7b3 or a5,a5,a4 +80000118: 40f50533 sub a0,a0,a5 +8000011c: 00153513 seqz a0,a0 +80000120: ef1ff0ef jal 80000010 +80000124: 00a94683 lbu a3,10(s2) +80000128: 00994603 lbu a2,9(s2) +8000012c: 00b94703 lbu a4,11(s2) +80000130: 00c94783 lbu a5,12(s2) +80000134: 00869693 sll a3,a3,0x8 +80000138: 00842503 lw a0,8(s0) +8000013c: 00c6e6b3 or a3,a3,a2 +80000140: 01071713 sll a4,a4,0x10 +80000144: 00d76733 or a4,a4,a3 +80000148: 01879793 sll a5,a5,0x18 +8000014c: 00e7e7b3 or a5,a5,a4 +80000150: 40f50533 sub a0,a0,a5 +80000154: 00153513 seqz a0,a0 +80000158: eb9ff0ef jal 80000010 +8000015c: 00000497 auipc s1,0x0 +80000160: 0ac48493 add s1,s1,172 # 80000208 +80000164: 00100413 li s0,1 +80000168: 00100a13 li s4,1 +8000016c: 01100993 li s3,17 +80000170: 008a17b3 sll a5,s4,s0 +80000174: 0004a503 lw a0,0(s1) +80000178: fff7c793 not a5,a5 +8000017c: 01079793 sll a5,a5,0x10 +80000180: 0107d793 srl a5,a5,0x10 +80000184: 00890733 add a4,s2,s0 +80000188: 40f50533 sub a0,a0,a5 +8000018c: 00153513 seqz a0,a0 +80000190: fef71fa3 sh a5,-1(a4) +80000194: 00240413 add s0,s0,2 +80000198: e79ff0ef jal 80000010 +8000019c: 00448493 add s1,s1,4 +800001a0: fd3418e3 bne s0,s3,80000170 +800001a4: 01c12083 lw ra,28(sp) +800001a8: 01812403 lw s0,24(sp) +800001ac: 01412483 lw s1,20(sp) +800001b0: 01012903 lw s2,16(sp) +800001b4: 00c12983 lw s3,12(sp) +800001b8: 00812a03 lw s4,8(sp) +800001bc: 00000513 li a0,0 +800001c0: 02010113 add sp,sp,32 +800001c4: 00008067 ret + +800001c8 : +800001c8: 00050513 mv a0,a0 +800001cc: 00100073 ebreak +800001d0: 0000006f j 800001d0 + +800001d4 <_trm_init>: +800001d4: ff010113 add sp,sp,-16 +800001d8: 00000517 auipc a0,0x0 +800001dc: 01c50513 add a0,a0,28 # 800001f4 <_etext> +800001e0: 00112623 sw ra,12(sp) +800001e4: e45ff0ef jal 80000028
+800001e8: 00050513 mv a0,a0 +800001ec: 00100073 ebreak +800001f0: 0000006f j 800001f0 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.bin new file mode 100755 index 0000000..abfff49 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.elf new file mode 100755 index 0000000..eb967e3 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.txt new file mode 100644 index 0000000..7fbe4da --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.txt @@ -0,0 +1,104 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/matrix-mul-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 138000ef jal 80000144 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 114000ef jal 80000138 + +80000028
: +80000028: fd010113 add sp,sp,-48 +8000002c: 02912223 sw s1,36(sp) +80000030: 03212023 sw s2,32(sp) +80000034: 01312e23 sw s3,28(sp) +80000038: 01412c23 sw s4,24(sp) +8000003c: 01512a23 sw s5,20(sp) +80000040: 01612823 sw s6,16(sp) +80000044: 02112623 sw ra,44(sp) +80000048: 02812423 sw s0,40(sp) +8000004c: 01712623 sw s7,12(sp) +80000050: 01812423 sw s8,8(sp) +80000054: 00000497 auipc s1,0x0 +80000058: 43448493 add s1,s1,1076 # 80000488 +8000005c: 00000a17 auipc s4,0x0 +80000060: 5bca0a13 add s4,s4,1468 # 80000618 +80000064: 00000997 auipc s3,0x0 +80000068: 10498993 add s3,s3,260 # 80000168 +8000006c: 00000b17 auipc s6,0x0 +80000070: 5acb0b13 add s6,s6,1452 # 80000618 +80000074: 00000917 auipc s2,0x0 +80000078: 43c90913 add s2,s2,1084 # 800004b0 +8000007c: 00000a97 auipc s5,0x0 +80000080: 40ca8a93 add s5,s5,1036 # 80000488 +80000084: 000a8593 mv a1,s5 +80000088: 00098c13 mv s8,s3 +8000008c: 000a0b93 mv s7,s4 +80000090: e7058413 add s0,a1,-400 +80000094: 00048713 mv a4,s1 +80000098: 00000693 li a3,0 +8000009c: 00072783 lw a5,0(a4) +800000a0: 00042603 lw a2,0(s0) +800000a4: 02840413 add s0,s0,40 +800000a8: 00470713 add a4,a4,4 +800000ac: 02c787b3 mul a5,a5,a2 +800000b0: 00f686b3 add a3,a3,a5 +800000b4: feb414e3 bne s0,a1,8000009c +800000b8: 000c2503 lw a0,0(s8) +800000bc: 00dba023 sw a3,0(s7) +800000c0: 004c0c13 add s8,s8,4 +800000c4: 40d50533 sub a0,a0,a3 +800000c8: 00153513 seqz a0,a0 +800000cc: f45ff0ef jal 80000010 +800000d0: 00100513 li a0,1 +800000d4: f3dff0ef jal 80000010 +800000d8: 00440593 add a1,s0,4 +800000dc: 004b8b93 add s7,s7,4 +800000e0: fab918e3 bne s2,a1,80000090 +800000e4: 00100513 li a0,1 +800000e8: 02848493 add s1,s1,40 +800000ec: f25ff0ef jal 80000010 +800000f0: 028a0a13 add s4,s4,40 +800000f4: 02898993 add s3,s3,40 +800000f8: f96496e3 bne s1,s6,80000084 +800000fc: 00100513 li a0,1 +80000100: f11ff0ef jal 80000010 +80000104: 02c12083 lw ra,44(sp) +80000108: 02812403 lw s0,40(sp) +8000010c: 02412483 lw s1,36(sp) +80000110: 02012903 lw s2,32(sp) +80000114: 01c12983 lw s3,28(sp) +80000118: 01812a03 lw s4,24(sp) +8000011c: 01412a83 lw s5,20(sp) +80000120: 01012b03 lw s6,16(sp) +80000124: 00c12b83 lw s7,12(sp) +80000128: 00812c03 lw s8,8(sp) +8000012c: 00000513 li a0,0 +80000130: 03010113 add sp,sp,48 +80000134: 00008067 ret + +80000138 : +80000138: 00050513 mv a0,a0 +8000013c: 00100073 ebreak +80000140: 0000006f j 80000140 + +80000144 <_trm_init>: +80000144: ff010113 add sp,sp,-16 +80000148: 00000517 auipc a0,0x0 +8000014c: 01c50513 add a0,a0,28 # 80000164 <_etext> +80000150: 00112623 sw ra,12(sp) +80000154: ed5ff0ef jal 80000028
+80000158: 00050513 mv a0,a0 +8000015c: 00100073 ebreak +80000160: 0000006f j 80000160 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.bin new file mode 100755 index 0000000..221ac12 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.elf new file mode 100755 index 0000000..b5ec5d4 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.txt new file mode 100644 index 0000000..8a42717 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.txt @@ -0,0 +1,90 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/max-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 100000ef jal 8000010c <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0dc000ef jal 80000100 + +80000028
: +80000028: fd010113 add sp,sp,-48 +8000002c: 01712623 sw s7,12(sp) +80000030: 00000b97 auipc s7,0x0 +80000034: 200b8b93 add s7,s7,512 # 80000230 +80000038: 01312e23 sw s3,28(sp) +8000003c: 01412c23 sw s4,24(sp) +80000040: 01512a23 sw s5,20(sp) +80000044: 01612823 sw s6,16(sp) +80000048: 01812423 sw s8,8(sp) +8000004c: 02112623 sw ra,44(sp) +80000050: 02812423 sw s0,40(sp) +80000054: 02912223 sw s1,36(sp) +80000058: 03212023 sw s2,32(sp) +8000005c: 00000b17 auipc s6,0x0 +80000060: 0d4b0b13 add s6,s6,212 # 80000130 +80000064: 000b8a93 mv s5,s7 +80000068: 00000a13 li s4,0 +8000006c: 00000997 auipc s3,0x0 +80000070: 1e498993 add s3,s3,484 # 80000250 <_bss_start> +80000074: 04000c13 li s8,64 +80000078: 000aa903 lw s2,0(s5) +8000007c: 000b0493 mv s1,s6 +80000080: 000b8413 mv s0,s7 +80000084: 00042503 lw a0,0(s0) +80000088: 01255463 bge a0,s2,80000090 +8000008c: 00090513 mv a0,s2 +80000090: 0004a783 lw a5,0(s1) +80000094: 00440413 add s0,s0,4 +80000098: 00448493 add s1,s1,4 +8000009c: 40f50533 sub a0,a0,a5 +800000a0: 00153513 seqz a0,a0 +800000a4: f6dff0ef jal 80000010 +800000a8: fc899ee3 bne s3,s0,80000084 +800000ac: 00100513 li a0,1 +800000b0: 008a0a13 add s4,s4,8 +800000b4: f5dff0ef jal 80000010 +800000b8: 004a8a93 add s5,s5,4 +800000bc: 020b0b13 add s6,s6,32 +800000c0: fb8a1ce3 bne s4,s8,80000078 +800000c4: 00100513 li a0,1 +800000c8: f49ff0ef jal 80000010 +800000cc: 02c12083 lw ra,44(sp) +800000d0: 02812403 lw s0,40(sp) +800000d4: 02412483 lw s1,36(sp) +800000d8: 02012903 lw s2,32(sp) +800000dc: 01c12983 lw s3,28(sp) +800000e0: 01812a03 lw s4,24(sp) +800000e4: 01412a83 lw s5,20(sp) +800000e8: 01012b03 lw s6,16(sp) +800000ec: 00c12b83 lw s7,12(sp) +800000f0: 00812c03 lw s8,8(sp) +800000f4: 00000513 li a0,0 +800000f8: 03010113 add sp,sp,48 +800000fc: 00008067 ret + +80000100 : +80000100: 00050513 mv a0,a0 +80000104: 00100073 ebreak +80000108: 0000006f j 80000108 + +8000010c <_trm_init>: +8000010c: ff010113 add sp,sp,-16 +80000110: 00000517 auipc a0,0x0 +80000114: 01c50513 add a0,a0,28 # 8000012c <_etext> +80000118: 00112623 sw ra,12(sp) +8000011c: f0dff0ef jal 80000028
+80000120: 00050513 mv a0,a0 +80000124: 00100073 ebreak +80000128: 0000006f j 80000128 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.bin new file mode 100755 index 0000000..232f850 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.elf new file mode 100755 index 0000000..ee47480 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.txt new file mode 100644 index 0000000..7b598c8 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.txt @@ -0,0 +1,426 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/mersenne-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 134000ef jal 80000140 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 110000ef jal 80000134 + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00112e23 sw ra,28(sp) +80000030: 00812c23 sw s0,24(sp) +80000034: 00500793 li a5,5 +80000038: 3a100693 li a3,929 +8000003c: 00878713 add a4,a5,8 +80000040: 00678793 add a5,a5,6 +80000044: 02f78633 mul a2,a5,a5 +80000048: 02c6c463 blt a3,a2,80000070 +8000004c: 00d78663 beq a5,a3,80000058 +80000050: 02e6e733 rem a4,a3,a4 +80000054: fe0714e3 bnez a4,8000003c +80000058: 00100413 li s0,1 +8000005c: 01c12083 lw ra,28(sp) +80000060: 00040513 mv a0,s0 +80000064: 01812403 lw s0,24(sp) +80000068: 02010113 add sp,sp,32 +8000006c: 00008067 ret +80000070: 01312623 sw s3,12(sp) +80000074: 00912a23 sw s1,20(sp) +80000078: 01212823 sw s2,16(sp) +8000007c: 01412423 sw s4,8(sp) +80000080: 01600793 li a5,22 +80000084: 3a100993 li s3,929 +80000088: fff78793 add a5,a5,-1 +8000008c: 00199993 sll s3,s3,0x1 +80000090: fe079ce3 bnez a5,80000088 +80000094: 74300493 li s1,1859 +80000098: 00100a13 li s4,1 +8000009c: 41f4d913 sra s2,s1,0x1f +800000a0: 00098413 mv s0,s3 +800000a4: 00100793 li a5,1 +800000a8: 02f795b3 mulh a1,a5,a5 +800000ac: 00048613 mv a2,s1 +800000b0: 00090693 mv a3,s2 +800000b4: 02f78533 mul a0,a5,a5 +800000b8: 410000ef jal 800004c8 <__moddi3> +800000bc: 00050793 mv a5,a0 +800000c0: 02044663 bltz s0,800000ec +800000c4: 00a4d463 bge s1,a0,800000cc +800000c8: 409507b3 sub a5,a0,s1 +800000cc: 02f795b3 mulh a1,a5,a5 +800000d0: 00048613 mv a2,s1 +800000d4: 00090693 mv a3,s2 +800000d8: 00141413 sll s0,s0,0x1 +800000dc: 02f78533 mul a0,a5,a5 +800000e0: 3e8000ef jal 800004c8 <__moddi3> +800000e4: 00050793 mv a5,a0 +800000e8: fc045ee3 bgez s0,800000c4 +800000ec: 00151793 sll a5,a0,0x1 +800000f0: 00141413 sll s0,s0,0x1 +800000f4: 00f4d463 bge s1,a5,800000fc +800000f8: 409787b3 sub a5,a5,s1 +800000fc: fa0416e3 bnez s0,800000a8 +80000100: 01478663 beq a5,s4,8000010c +80000104: 74248493 add s1,s1,1858 +80000108: f95ff06f j 8000009c +8000010c: ffffd7b7 lui a5,0xffffd +80000110: d3178793 add a5,a5,-719 # ffffcd31 <_end+0x7fff3d31> +80000114: 00f48533 add a0,s1,a5 +80000118: 00153513 seqz a0,a0 +8000011c: ef5ff0ef jal 80000010 +80000120: 01412483 lw s1,20(sp) +80000124: 01012903 lw s2,16(sp) +80000128: 00c12983 lw s3,12(sp) +8000012c: 00812a03 lw s4,8(sp) +80000130: f2dff06f j 8000005c + +80000134 : +80000134: 00050513 mv a0,a0 +80000138: 00100073 ebreak +8000013c: 0000006f j 8000013c + +80000140 <_trm_init>: +80000140: ff010113 add sp,sp,-16 +80000144: 00000517 auipc a0,0x0 +80000148: 50850513 add a0,a0,1288 # 8000064c <_etext> +8000014c: 00112623 sw ra,12(sp) +80000150: ed9ff0ef jal 80000028
+80000154: 00050513 mv a0,a0 +80000158: 00100073 ebreak +8000015c: 0000006f j 8000015c <_trm_init+0x1c> + +80000160 <__udivmoddi4>: +80000160: fd010113 add sp,sp,-48 +80000164: 01312e23 sw s3,28(sp) +80000168: 01412c23 sw s4,24(sp) +8000016c: 01612823 sw s6,16(sp) +80000170: 01712623 sw s7,12(sp) +80000174: 02112623 sw ra,44(sp) +80000178: 00068b13 mv s6,a3 +8000017c: 00050993 mv s3,a0 +80000180: 00060a13 mv s4,a2 +80000184: 00070b93 mv s7,a4 +80000188: 02059e63 bnez a1,800001c4 <__udivmoddi4+0x64> +8000018c: 1a069263 bnez a3,80000330 <__udivmoddi4+0x1d0> +80000190: 00070863 beqz a4,800001a0 <__udivmoddi4+0x40> +80000194: 02c577b3 remu a5,a0,a2 +80000198: 00072223 sw zero,4(a4) +8000019c: 00f72023 sw a5,0(a4) +800001a0: 0349d533 divu a0,s3,s4 +800001a4: 00000593 li a1,0 +800001a8: 02c12083 lw ra,44(sp) +800001ac: 01c12983 lw s3,28(sp) +800001b0: 01812a03 lw s4,24(sp) +800001b4: 01012b03 lw s6,16(sp) +800001b8: 00c12b83 lw s7,12(sp) +800001bc: 03010113 add sp,sp,48 +800001c0: 00008067 ret +800001c4: 02912223 sw s1,36(sp) +800001c8: 03212023 sw s2,32(sp) +800001cc: 01512a23 sw s5,20(sp) +800001d0: 02812423 sw s0,40(sp) +800001d4: 00058913 mv s2,a1 +800001d8: 00058493 mv s1,a1 +800001dc: 00060a93 mv s5,a2 +800001e0: 0e061e63 bnez a2,800002dc <__udivmoddi4+0x17c> +800001e4: 1c068063 beqz a3,800003a4 <__udivmoddi4+0x244> +800001e8: 22050a63 beqz a0,8000041c <__udivmoddi4+0x2bc> +800001ec: fff68793 add a5,a3,-1 +800001f0: 00d7f733 and a4,a5,a3 +800001f4: 28070263 beqz a4,80000478 <__udivmoddi4+0x318> +800001f8: 00068513 mv a0,a3 +800001fc: 348000ef jal 80000544 <__clzsi2> +80000200: 00050413 mv s0,a0 +80000204: 00090513 mv a0,s2 +80000208: 33c000ef jal 80000544 <__clzsi2> +8000020c: 40a406b3 sub a3,s0,a0 +80000210: 01e00793 li a5,30 +80000214: 18d7ea63 bltu a5,a3,800003a8 <__udivmoddi4+0x248> +80000218: 00168693 add a3,a3,1 +8000021c: 02000793 li a5,32 +80000220: 40d787b3 sub a5,a5,a3 +80000224: 00f91633 sll a2,s2,a5 +80000228: 00d9d733 srl a4,s3,a3 +8000022c: 00d95433 srl s0,s2,a3 +80000230: 00f99833 sll a6,s3,a5 +80000234: 00e664b3 or s1,a2,a4 +80000238: 00000713 li a4,0 +8000023c: 01f85793 srl a5,a6,0x1f +80000240: 00149593 sll a1,s1,0x1 +80000244: 00f5e5b3 or a1,a1,a5 +80000248: 01f4d493 srl s1,s1,0x1f +8000024c: 00141793 sll a5,s0,0x1 +80000250: 0097e7b3 or a5,a5,s1 +80000254: 40ba0333 sub t1,s4,a1 +80000258: 006a3633 sltu a2,s4,t1 +8000025c: 40fb08b3 sub a7,s6,a5 +80000260: 40c888b3 sub a7,a7,a2 +80000264: 00133313 seqz t1,t1 +80000268: 406888b3 sub a7,a7,t1 +8000026c: 41f8d313 sra t1,a7,0x1f +80000270: 014374b3 and s1,t1,s4 +80000274: 409584b3 sub s1,a1,s1 +80000278: 01637333 and t1,t1,s6 +8000027c: 01fad613 srl a2,s5,0x1f +80000280: 00181813 sll a6,a6,0x1 +80000284: 001a9a93 sll s5,s5,0x1 +80000288: 0095b5b3 sltu a1,a1,s1 +8000028c: 406787b3 sub a5,a5,t1 +80000290: fff68693 add a3,a3,-1 +80000294: 00eaeab3 or s5,s5,a4 +80000298: 00c86833 or a6,a6,a2 +8000029c: 01f8d713 srl a4,a7,0x1f +800002a0: 40b78433 sub s0,a5,a1 +800002a4: f8069ce3 bnez a3,8000023c <__udivmoddi4+0xdc> +800002a8: 000b8663 beqz s7,800002b4 <__udivmoddi4+0x154> +800002ac: 009ba023 sw s1,0(s7) +800002b0: 008ba223 sw s0,4(s7) +800002b4: 01fad913 srl s2,s5,0x1f +800002b8: 001a9993 sll s3,s5,0x1 +800002bc: 00181793 sll a5,a6,0x1 +800002c0: 00f965b3 or a1,s2,a5 +800002c4: 02812403 lw s0,40(sp) +800002c8: 02412483 lw s1,36(sp) +800002cc: 02012903 lw s2,32(sp) +800002d0: 01412a83 lw s5,20(sp) +800002d4: 00e9e533 or a0,s3,a4 +800002d8: ed1ff06f j 800001a8 <__udivmoddi4+0x48> +800002dc: 06068663 beqz a3,80000348 <__udivmoddi4+0x1e8> +800002e0: 00068513 mv a0,a3 +800002e4: 260000ef jal 80000544 <__clzsi2> +800002e8: 00050413 mv s0,a0 +800002ec: 00090513 mv a0,s2 +800002f0: 254000ef jal 80000544 <__clzsi2> +800002f4: 40a406b3 sub a3,s0,a0 +800002f8: 01f00793 li a5,31 +800002fc: 0ad7e663 bltu a5,a3,800003a8 <__udivmoddi4+0x248> +80000300: 00168693 add a3,a3,1 +80000304: 02000793 li a5,32 +80000308: 00098813 mv a6,s3 +8000030c: 18f68663 beq a3,a5,80000498 <__udivmoddi4+0x338> +80000310: 40d787b3 sub a5,a5,a3 +80000314: 00d9d733 srl a4,s3,a3 +80000318: 00f91633 sll a2,s2,a5 +8000031c: 00d95433 srl s0,s2,a3 +80000320: 00f99833 sll a6,s3,a5 +80000324: 00e664b3 or s1,a2,a4 +80000328: 00000a93 li s5,0 +8000032c: f0dff06f j 80000238 <__udivmoddi4+0xd8> +80000330: 00070663 beqz a4,8000033c <__udivmoddi4+0x1dc> +80000334: 00aba023 sw a0,0(s7) +80000338: 00072223 sw zero,4(a4) +8000033c: 00000513 li a0,0 +80000340: 00000593 li a1,0 +80000344: e65ff06f j 800001a8 <__udivmoddi4+0x48> +80000348: fff60793 add a5,a2,-1 +8000034c: 00c7f733 and a4,a5,a2 +80000350: 06071c63 bnez a4,800003c8 <__udivmoddi4+0x268> +80000354: 000b8863 beqz s7,80000364 <__udivmoddi4+0x204> +80000358: 00a7f7b3 and a5,a5,a0 +8000035c: 00fba023 sw a5,0(s7) +80000360: 000ba223 sw zero,4(s7) +80000364: 00100793 li a5,1 +80000368: 0efa0063 beq s4,a5,80000448 <__udivmoddi4+0x2e8> +8000036c: 000a0513 mv a0,s4 +80000370: 264000ef jal 800005d4 <__ctzsi2> +80000374: 02000713 li a4,32 +80000378: 40a70733 sub a4,a4,a0 +8000037c: 00050793 mv a5,a0 +80000380: 00e91733 sll a4,s2,a4 +80000384: 00a9d833 srl a6,s3,a0 +80000388: 00f955b3 srl a1,s2,a5 +8000038c: 02812403 lw s0,40(sp) +80000390: 02412483 lw s1,36(sp) +80000394: 02012903 lw s2,32(sp) +80000398: 01412a83 lw s5,20(sp) +8000039c: 01076533 or a0,a4,a6 +800003a0: e09ff06f j 800001a8 <__udivmoddi4+0x48> +800003a4: 00100073 ebreak +800003a8: 0a0b8e63 beqz s7,80000464 <__udivmoddi4+0x304> +800003ac: 012ba223 sw s2,4(s7) +800003b0: 02812403 lw s0,40(sp) +800003b4: 02412483 lw s1,36(sp) +800003b8: 02012903 lw s2,32(sp) +800003bc: 01412a83 lw s5,20(sp) +800003c0: 013ba023 sw s3,0(s7) +800003c4: f79ff06f j 8000033c <__udivmoddi4+0x1dc> +800003c8: 00060513 mv a0,a2 +800003cc: 00068413 mv s0,a3 +800003d0: 174000ef jal 80000544 <__clzsi2> +800003d4: 00050913 mv s2,a0 +800003d8: 00048513 mv a0,s1 +800003dc: 168000ef jal 80000544 <__clzsi2> +800003e0: 40a90533 sub a0,s2,a0 +800003e4: 02150693 add a3,a0,33 +800003e8: 02000793 li a5,32 +800003ec: 00098813 mv a6,s3 +800003f0: 00000a93 li s5,0 +800003f4: e4f682e3 beq a3,a5,80000238 <__udivmoddi4+0xd8> +800003f8: 01f00713 li a4,31 +800003fc: 0ad76463 bltu a4,a3,800004a4 <__udivmoddi4+0x344> +80000400: 40d78733 sub a4,a5,a3 +80000404: 00d4d433 srl s0,s1,a3 +80000408: 00d9d7b3 srl a5,s3,a3 +8000040c: 00e494b3 sll s1,s1,a4 +80000410: 00f4e4b3 or s1,s1,a5 +80000414: 00e99833 sll a6,s3,a4 +80000418: e21ff06f j 80000238 <__udivmoddi4+0xd8> +8000041c: 00070863 beqz a4,8000042c <__udivmoddi4+0x2cc> +80000420: 02d5f7b3 remu a5,a1,a3 +80000424: 00072023 sw zero,0(a4) +80000428: 00f72223 sw a5,4(a4) +8000042c: 03695533 divu a0,s2,s6 +80000430: 02812403 lw s0,40(sp) +80000434: 02412483 lw s1,36(sp) +80000438: 02012903 lw s2,32(sp) +8000043c: 01412a83 lw s5,20(sp) +80000440: 00000593 li a1,0 +80000444: d65ff06f j 800001a8 <__udivmoddi4+0x48> +80000448: 00090593 mv a1,s2 +8000044c: 02812403 lw s0,40(sp) +80000450: 02412483 lw s1,36(sp) +80000454: 02012903 lw s2,32(sp) +80000458: 01412a83 lw s5,20(sp) +8000045c: 00098513 mv a0,s3 +80000460: d49ff06f j 800001a8 <__udivmoddi4+0x48> +80000464: 02812403 lw s0,40(sp) +80000468: 02412483 lw s1,36(sp) +8000046c: 02012903 lw s2,32(sp) +80000470: 01412a83 lw s5,20(sp) +80000474: ec9ff06f j 8000033c <__udivmoddi4+0x1dc> +80000478: 000b8863 beqz s7,80000488 <__udivmoddi4+0x328> +8000047c: 00b7f7b3 and a5,a5,a1 +80000480: 00aba023 sw a0,0(s7) +80000484: 00fba223 sw a5,4(s7) +80000488: 000b0513 mv a0,s6 +8000048c: 148000ef jal 800005d4 <__ctzsi2> +80000490: 00a95533 srl a0,s2,a0 +80000494: f9dff06f j 80000430 <__udivmoddi4+0x2d0> +80000498: 00000413 li s0,0 +8000049c: 00000a93 li s5,0 +800004a0: d99ff06f j 80000238 <__udivmoddi4+0xd8> +800004a4: 04000a93 li s5,64 +800004a8: 40da8ab3 sub s5,s5,a3 +800004ac: 00150513 add a0,a0,1 +800004b0: 01549733 sll a4,s1,s5 +800004b4: 00a9d7b3 srl a5,s3,a0 +800004b8: 01599ab3 sll s5,s3,s5 +800004bc: 00a4d4b3 srl s1,s1,a0 +800004c0: 00f76833 or a6,a4,a5 +800004c4: d75ff06f j 80000238 <__udivmoddi4+0xd8> + +800004c8 <__moddi3>: +800004c8: fe010113 add sp,sp,-32 +800004cc: 00812c23 sw s0,24(sp) +800004d0: 41f6d893 sra a7,a3,0x1f +800004d4: 41f5d413 sra s0,a1,0x1f +800004d8: 01164733 xor a4,a2,a7 +800004dc: 008547b3 xor a5,a0,s0 +800004e0: 41170633 sub a2,a4,a7 +800004e4: 40878533 sub a0,a5,s0 +800004e8: 0116c6b3 xor a3,a3,a7 +800004ec: 0085c5b3 xor a1,a1,s0 +800004f0: 00c73833 sltu a6,a4,a2 +800004f4: 00a7b7b3 sltu a5,a5,a0 +800004f8: 411686b3 sub a3,a3,a7 +800004fc: 408585b3 sub a1,a1,s0 +80000500: 00810713 add a4,sp,8 +80000504: 40f585b3 sub a1,a1,a5 +80000508: 410686b3 sub a3,a3,a6 +8000050c: 00112e23 sw ra,28(sp) +80000510: c51ff0ef jal 80000160 <__udivmoddi4> +80000514: 00812783 lw a5,8(sp) +80000518: 00c12583 lw a1,12(sp) +8000051c: 01c12083 lw ra,28(sp) +80000520: 0087c7b3 xor a5,a5,s0 +80000524: 0085c5b3 xor a1,a1,s0 +80000528: 40878533 sub a0,a5,s0 +8000052c: 408585b3 sub a1,a1,s0 +80000530: 01812403 lw s0,24(sp) +80000534: 00a7b7b3 sltu a5,a5,a0 +80000538: 40f585b3 sub a1,a1,a5 +8000053c: 02010113 add sp,sp,32 +80000540: 00008067 ret + +80000544 <__clzsi2>: +80000544: 000105b7 lui a1,0x10 +80000548: 00b535b3 sltu a1,a0,a1 +8000054c: 00459593 sll a1,a1,0x4 +80000550: 01000793 li a5,16 +80000554: 40b787b3 sub a5,a5,a1 +80000558: 00010737 lui a4,0x10 +8000055c: 00f557b3 srl a5,a0,a5 +80000560: f0070713 add a4,a4,-256 # ff00 <_entry_offset+0xff00> +80000564: 00e7f733 and a4,a5,a4 +80000568: 00173713 seqz a4,a4 +8000056c: 00371713 sll a4,a4,0x3 +80000570: 00800693 li a3,8 +80000574: 40e686b3 sub a3,a3,a4 +80000578: 00d7d7b3 srl a5,a5,a3 +8000057c: 0f07f613 and a2,a5,240 +80000580: 00163613 seqz a2,a2 +80000584: 00261613 sll a2,a2,0x2 +80000588: 00400693 li a3,4 +8000058c: 40c686b3 sub a3,a3,a2 +80000590: 00d7d7b3 srl a5,a5,a3 +80000594: 00c7f693 and a3,a5,12 +80000598: 0016b693 seqz a3,a3 +8000059c: 00200513 li a0,2 +800005a0: 00169693 sll a3,a3,0x1 +800005a4: 40d50833 sub a6,a0,a3 +800005a8: 0107d7b3 srl a5,a5,a6 +800005ac: 0017d813 srl a6,a5,0x1 +800005b0: 00b70733 add a4,a4,a1 +800005b4: 00187593 and a1,a6,1 +800005b8: 00e60633 add a2,a2,a4 +800005bc: 40f50533 sub a0,a0,a5 +800005c0: 00058463 beqz a1,800005c8 <__clzsi2+0x84> +800005c4: 00000513 li a0,0 +800005c8: 00c686b3 add a3,a3,a2 +800005cc: 00d50533 add a0,a0,a3 +800005d0: 00008067 ret + +800005d4 <__ctzsi2>: +800005d4: 01051593 sll a1,a0,0x10 +800005d8: 0105d593 srl a1,a1,0x10 +800005dc: 0015b593 seqz a1,a1 +800005e0: 00459593 sll a1,a1,0x4 +800005e4: 00b557b3 srl a5,a0,a1 +800005e8: 0ff7f613 zext.b a2,a5 +800005ec: 00163613 seqz a2,a2 +800005f0: 00361613 sll a2,a2,0x3 +800005f4: 00c7d7b3 srl a5,a5,a2 +800005f8: 00f7f693 and a3,a5,15 +800005fc: 0016b693 seqz a3,a3 +80000600: 00269693 sll a3,a3,0x2 +80000604: 00d7d7b3 srl a5,a5,a3 +80000608: 0037f713 and a4,a5,3 +8000060c: 00173713 seqz a4,a4 +80000610: 00171713 sll a4,a4,0x1 +80000614: 00e7d7b3 srl a5,a5,a4 +80000618: 0017d513 srl a0,a5,0x1 +8000061c: fff7c793 not a5,a5 +80000620: 00b60633 add a2,a2,a1 +80000624: 0017f793 and a5,a5,1 +80000628: 00157593 and a1,a0,1 +8000062c: 00200513 li a0,2 +80000630: 00c686b3 add a3,a3,a2 +80000634: 40b50533 sub a0,a0,a1 +80000638: 40f007b3 neg a5,a5 +8000063c: 00f57533 and a0,a0,a5 +80000640: 00d70733 add a4,a4,a3 +80000644: 00e50533 add a0,a0,a4 +80000648: 00008067 ret diff --git a/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.bin new file mode 100755 index 0000000..a5e0b36 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.elf new file mode 100755 index 0000000..f5f9681 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.txt new file mode 100644 index 0000000..4ad8df1 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.txt @@ -0,0 +1,109 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/min3-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 14c000ef jal 80000158 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 128000ef jal 8000014c + +80000028
: +80000028: fc010113 add sp,sp,-64 +8000002c: 03612023 sw s6,32(sp) +80000030: 00000b17 auipc s6,0x0 +80000034: 24cb0b13 add s6,s6,588 # 8000027c +80000038: 02912a23 sw s1,52(sp) +8000003c: 03312623 sw s3,44(sp) +80000040: 03512223 sw s5,36(sp) +80000044: 01712e23 sw s7,28(sp) +80000048: 01812c23 sw s8,24(sp) +8000004c: 02112e23 sw ra,60(sp) +80000050: 02812c23 sw s0,56(sp) +80000054: 03212823 sw s2,48(sp) +80000058: 03412423 sw s4,40(sp) +8000005c: 01912a23 sw s9,20(sp) +80000060: 01a12823 sw s10,16(sp) +80000064: 01b12623 sw s11,12(sp) +80000068: 00000c17 auipc s8,0x0 +8000006c: 114c0c13 add s8,s8,276 # 8000017c +80000070: 000b0a93 mv s5,s6 +80000074: 000b0b93 mv s7,s6 +80000078: 01000993 li s3,16 +8000007c: 00000497 auipc s1,0x0 +80000080: 21048493 add s1,s1,528 # 8000028c <_bss_start> +80000084: 000baa03 lw s4,0(s7) +80000088: ff098413 add s0,s3,-16 +8000008c: 000c0913 mv s2,s8 +80000090: 008a87b3 add a5,s5,s0 +80000094: 0007ac83 lw s9,0(a5) +80000098: 019a5463 bge s4,s9,800000a0 +8000009c: 000a0c93 mv s9,s4 +800000a0: 00090d93 mv s11,s2 +800000a4: 000b0d13 mv s10,s6 +800000a8: 000d2503 lw a0,0(s10) +800000ac: 00acd463 bge s9,a0,800000b4 +800000b0: 000c8513 mv a0,s9 +800000b4: 000da703 lw a4,0(s11) +800000b8: 004d0d13 add s10,s10,4 +800000bc: 004d8d93 add s11,s11,4 +800000c0: 40e50533 sub a0,a0,a4 +800000c4: 00153513 seqz a0,a0 +800000c8: f49ff0ef jal 80000010 +800000cc: fda49ee3 bne s1,s10,800000a8 +800000d0: 00100513 li a0,1 +800000d4: 00440413 add s0,s0,4 +800000d8: f39ff0ef jal 80000010 +800000dc: 01090913 add s2,s2,16 +800000e0: fb3418e3 bne s0,s3,80000090 +800000e4: 00100513 li a0,1 +800000e8: f29ff0ef jal 80000010 +800000ec: 01040993 add s3,s0,16 +800000f0: 05000793 li a5,80 +800000f4: 004b8b93 add s7,s7,4 +800000f8: 040c0c13 add s8,s8,64 +800000fc: ff0a8a93 add s5,s5,-16 +80000100: f8f992e3 bne s3,a5,80000084 +80000104: 00100513 li a0,1 +80000108: f09ff0ef jal 80000010 +8000010c: 03c12083 lw ra,60(sp) +80000110: 03812403 lw s0,56(sp) +80000114: 03412483 lw s1,52(sp) +80000118: 03012903 lw s2,48(sp) +8000011c: 02c12983 lw s3,44(sp) +80000120: 02812a03 lw s4,40(sp) +80000124: 02412a83 lw s5,36(sp) +80000128: 02012b03 lw s6,32(sp) +8000012c: 01c12b83 lw s7,28(sp) +80000130: 01812c03 lw s8,24(sp) +80000134: 01412c83 lw s9,20(sp) +80000138: 01012d03 lw s10,16(sp) +8000013c: 00c12d83 lw s11,12(sp) +80000140: 00000513 li a0,0 +80000144: 04010113 add sp,sp,64 +80000148: 00008067 ret + +8000014c : +8000014c: 00050513 mv a0,a0 +80000150: 00100073 ebreak +80000154: 0000006f j 80000154 + +80000158 <_trm_init>: +80000158: ff010113 add sp,sp,-16 +8000015c: 00000517 auipc a0,0x0 +80000160: 01c50513 add a0,a0,28 # 80000178 <_etext> +80000164: 00112623 sw ra,12(sp) +80000168: ec1ff0ef jal 80000028
+8000016c: 00050513 mv a0,a0 +80000170: 00100073 ebreak +80000174: 0000006f j 80000174 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.bin new file mode 100755 index 0000000..42261e0 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.elf new file mode 100755 index 0000000..6223017 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.txt new file mode 100644 index 0000000..f2bec1e --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.txt @@ -0,0 +1,90 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/mov-c-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 100000ef jal 8000010c <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0dc000ef jal 80000100 + +80000028
: +80000028: ff010113 add sp,sp,-16 +8000002c: 00112623 sw ra,12(sp) +80000030: 00812423 sw s0,8(sp) +80000034: 00912223 sw s1,4(sp) +80000038: 00000417 auipc s0,0x0 +8000003c: 0f840413 add s0,s0,248 # 80000130 +80000040: 00042023 sw zero,0(s0) +80000044: 00100793 li a5,1 +80000048: 00f42223 sw a5,4(s0) +8000004c: 00200793 li a5,2 +80000050: 00f42423 sw a5,8(s0) +80000054: 00300793 li a5,3 +80000058: 00f42623 sw a5,12(s0) +8000005c: 00400793 li a5,4 +80000060: 00f42823 sw a5,16(s0) +80000064: 00c42783 lw a5,12(s0) +80000068: 00000497 auipc s1,0x0 +8000006c: 0f048493 add s1,s1,240 # 80000158 +80000070: 00f4a023 sw a5,0(s1) +80000074: 0004a783 lw a5,0(s1) +80000078: 00f42a23 sw a5,20(s0) +8000007c: 00042503 lw a0,0(s0) +80000080: 00153513 seqz a0,a0 +80000084: f8dff0ef jal 80000010 +80000088: 00442503 lw a0,4(s0) +8000008c: fff50513 add a0,a0,-1 +80000090: 00153513 seqz a0,a0 +80000094: f7dff0ef jal 80000010 +80000098: 00842503 lw a0,8(s0) +8000009c: ffe50513 add a0,a0,-2 +800000a0: 00153513 seqz a0,a0 +800000a4: f6dff0ef jal 80000010 +800000a8: 00c42503 lw a0,12(s0) +800000ac: ffd50513 add a0,a0,-3 +800000b0: 00153513 seqz a0,a0 +800000b4: f5dff0ef jal 80000010 +800000b8: 01042503 lw a0,16(s0) +800000bc: ffc50513 add a0,a0,-4 +800000c0: 00153513 seqz a0,a0 +800000c4: f4dff0ef jal 80000010 +800000c8: 0004a503 lw a0,0(s1) +800000cc: ffd50513 add a0,a0,-3 +800000d0: 00153513 seqz a0,a0 +800000d4: f3dff0ef jal 80000010 +800000d8: 01442503 lw a0,20(s0) +800000dc: ffd50513 add a0,a0,-3 +800000e0: 00153513 seqz a0,a0 +800000e4: f2dff0ef jal 80000010 +800000e8: 00c12083 lw ra,12(sp) +800000ec: 00812403 lw s0,8(sp) +800000f0: 00412483 lw s1,4(sp) +800000f4: 00000513 li a0,0 +800000f8: 01010113 add sp,sp,16 +800000fc: 00008067 ret + +80000100 : +80000100: 00050513 mv a0,a0 +80000104: 00100073 ebreak +80000108: 0000006f j 80000108 + +8000010c <_trm_init>: +8000010c: ff010113 add sp,sp,-16 +80000110: 00000517 auipc a0,0x0 +80000114: 01c50513 add a0,a0,28 # 8000012c <_etext> +80000118: 00112623 sw ra,12(sp) +8000011c: f0dff0ef jal 80000028
+80000120: 00050513 mv a0,a0 +80000124: 00100073 ebreak +80000128: 0000006f j 80000128 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.bin new file mode 100755 index 0000000..43482c4 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.elf new file mode 100755 index 0000000..62af668 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.txt new file mode 100644 index 0000000..82a55ed --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.txt @@ -0,0 +1,133 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/movsx-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 1ac000ef jal 800001b8 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 188000ef jal 800001ac + +80000028
: +80000028: ff010113 add sp,sp,-16 +8000002c: 00112623 sw ra,12(sp) +80000030: 00812423 sw s0,8(sp) +80000034: 00912223 sw s1,4(sp) +80000038: 01212023 sw s2,0(sp) +8000003c: 00000417 auipc s0,0x0 +80000040: 1ac40413 add s0,s0,428 # 800001e8 +80000044: 00042023 sw zero,0(s0) +80000048: 00100793 li a5,1 +8000004c: 00f42223 sw a5,4(s0) +80000050: 00200793 li a5,2 +80000054: 00f42423 sw a5,8(s0) +80000058: 00300793 li a5,3 +8000005c: 00f42623 sw a5,12(s0) +80000060: 00400793 li a5,4 +80000064: 00f42823 sw a5,16(s0) +80000068: 00c42783 lw a5,12(s0) +8000006c: 00000917 auipc s2,0x0 +80000070: 1a490913 add s2,s2,420 # 80000210 +80000074: 00000497 auipc s1,0x0 +80000078: 16848493 add s1,s1,360 # 800001dc +8000007c: 00f92023 sw a5,0(s2) +80000080: 00092783 lw a5,0(s2) +80000084: 00f42a23 sw a5,20(s0) +80000088: 06100793 li a5,97 +8000008c: 00f48023 sb a5,0(s1) +80000090: 0004c503 lbu a0,0(s1) +80000094: 01851513 sll a0,a0,0x18 +80000098: 41855513 sra a0,a0,0x18 +8000009c: f9f50513 add a0,a0,-97 +800000a0: 00153513 seqz a0,a0 +800000a4: f6dff0ef jal 80000010 +800000a8: 0004c783 lbu a5,0(s1) +800000ac: 01879793 sll a5,a5,0x18 +800000b0: 4187d793 sra a5,a5,0x18 +800000b4: 00f480a3 sb a5,1(s1) +800000b8: 0014c503 lbu a0,1(s1) +800000bc: 01851513 sll a0,a0,0x18 +800000c0: 41855513 sra a0,a0,0x18 +800000c4: f9f50513 add a0,a0,-97 +800000c8: 00153513 seqz a0,a0 +800000cc: f45ff0ef jal 80000010 +800000d0: 0004c783 lbu a5,0(s1) +800000d4: 01879793 sll a5,a5,0x18 +800000d8: 4187d793 sra a5,a5,0x18 +800000dc: 00f42023 sw a5,0(s0) +800000e0: 00042503 lw a0,0(s0) +800000e4: f9f50513 add a0,a0,-97 +800000e8: 00153513 seqz a0,a0 +800000ec: f25ff0ef jal 80000010 +800000f0: f8000793 li a5,-128 +800000f4: 00f480a3 sb a5,1(s1) +800000f8: 0014c783 lbu a5,1(s1) +800000fc: 01879793 sll a5,a5,0x18 +80000100: 4187d793 sra a5,a5,0x18 +80000104: 00f42023 sw a5,0(s0) +80000108: 00442503 lw a0,4(s0) +8000010c: fff50513 add a0,a0,-1 +80000110: 00153513 seqz a0,a0 +80000114: efdff0ef jal 80000010 +80000118: 00842503 lw a0,8(s0) +8000011c: ffe50513 add a0,a0,-2 +80000120: 00153513 seqz a0,a0 +80000124: eedff0ef jal 80000010 +80000128: 00c42503 lw a0,12(s0) +8000012c: ffd50513 add a0,a0,-3 +80000130: 00153513 seqz a0,a0 +80000134: eddff0ef jal 80000010 +80000138: 01042503 lw a0,16(s0) +8000013c: ffc50513 add a0,a0,-4 +80000140: 00153513 seqz a0,a0 +80000144: ecdff0ef jal 80000010 +80000148: 00092503 lw a0,0(s2) +8000014c: ffd50513 add a0,a0,-3 +80000150: 00153513 seqz a0,a0 +80000154: ebdff0ef jal 80000010 +80000158: 01442503 lw a0,20(s0) +8000015c: ffd50513 add a0,a0,-3 +80000160: 00153513 seqz a0,a0 +80000164: eadff0ef jal 80000010 +80000168: 0014c503 lbu a0,1(s1) +8000016c: 01851513 sll a0,a0,0x18 +80000170: 41855513 sra a0,a0,0x18 +80000174: 08050513 add a0,a0,128 +80000178: 00153513 seqz a0,a0 +8000017c: e95ff0ef jal 80000010 +80000180: 00042503 lw a0,0(s0) +80000184: 08050513 add a0,a0,128 +80000188: 00153513 seqz a0,a0 +8000018c: e85ff0ef jal 80000010 +80000190: 00c12083 lw ra,12(sp) +80000194: 00812403 lw s0,8(sp) +80000198: 00412483 lw s1,4(sp) +8000019c: 00012903 lw s2,0(sp) +800001a0: 00000513 li a0,0 +800001a4: 01010113 add sp,sp,16 +800001a8: 00008067 ret + +800001ac : +800001ac: 00050513 mv a0,a0 +800001b0: 00100073 ebreak +800001b4: 0000006f j 800001b4 + +800001b8 <_trm_init>: +800001b8: ff010113 add sp,sp,-16 +800001bc: 00000517 auipc a0,0x0 +800001c0: 01c50513 add a0,a0,28 # 800001d8 <_etext> +800001c4: 00112623 sw ra,12(sp) +800001c8: e61ff0ef jal 80000028
+800001cc: 00050513 mv a0,a0 +800001d0: 00100073 ebreak +800001d4: 0000006f j 800001d4 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.bin new file mode 100755 index 0000000..5d556c4 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.elf new file mode 100755 index 0000000..7726e91 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.txt new file mode 100644 index 0000000..d8f3f5e --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.txt @@ -0,0 +1,95 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/mul-longlong-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 114000ef jal 80000120 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0f0000ef jal 80000114 + +80000028
: +80000028: fd010113 add sp,sp,-48 +8000002c: 02912223 sw s1,36(sp) +80000030: 03212023 sw s2,32(sp) +80000034: 01312e23 sw s3,28(sp) +80000038: 01412c23 sw s4,24(sp) +8000003c: 01512a23 sw s5,20(sp) +80000040: 01612823 sw s6,16(sp) +80000044: 02112623 sw ra,44(sp) +80000048: 02812423 sw s0,40(sp) +8000004c: 01712623 sw s7,12(sp) +80000050: 01812423 sw s8,8(sp) +80000054: 00000a17 auipc s4,0x0 +80000058: 144a0a13 add s4,s4,324 # 80000198 +8000005c: 00000493 li s1,0 +80000060: 00000993 li s3,0 +80000064: 00000b17 auipc s6,0x0 +80000068: 0e4b0b13 add s6,s6,228 # 80000148 +8000006c: 00000917 auipc s2,0x0 +80000070: 13c90913 add s2,s2,316 # 800001a8 <_bss_start> +80000074: 00400a93 li s5,4 +80000078: 000a2c03 lw s8,0(s4) +8000007c: 00349413 sll s0,s1,0x3 +80000080: 008b0433 add s0,s6,s0 +80000084: 000a0b93 mv s7,s4 +80000088: 000ba783 lw a5,0(s7) +8000008c: 00442703 lw a4,4(s0) +80000090: 00042503 lw a0,0(s0) +80000094: 02fc06b3 mul a3,s8,a5 +80000098: 004b8b93 add s7,s7,4 +8000009c: 00840413 add s0,s0,8 +800000a0: 02fc17b3 mulh a5,s8,a5 +800000a4: 00d54533 xor a0,a0,a3 +800000a8: 00f747b3 xor a5,a4,a5 +800000ac: 00f56533 or a0,a0,a5 +800000b0: 00153513 seqz a0,a0 +800000b4: f5dff0ef jal 80000010 +800000b8: fd7918e3 bne s2,s7,80000088 +800000bc: 00448493 add s1,s1,4 +800000c0: 00100513 li a0,1 +800000c4: 413484b3 sub s1,s1,s3 +800000c8: 00198993 add s3,s3,1 +800000cc: f45ff0ef jal 80000010 +800000d0: 004a0a13 add s4,s4,4 +800000d4: fb5992e3 bne s3,s5,80000078 +800000d8: 00100513 li a0,1 +800000dc: f35ff0ef jal 80000010 +800000e0: 02c12083 lw ra,44(sp) +800000e4: 02812403 lw s0,40(sp) +800000e8: 02412483 lw s1,36(sp) +800000ec: 02012903 lw s2,32(sp) +800000f0: 01c12983 lw s3,28(sp) +800000f4: 01812a03 lw s4,24(sp) +800000f8: 01412a83 lw s5,20(sp) +800000fc: 01012b03 lw s6,16(sp) +80000100: 00c12b83 lw s7,12(sp) +80000104: 00812c03 lw s8,8(sp) +80000108: 00000513 li a0,0 +8000010c: 03010113 add sp,sp,48 +80000110: 00008067 ret + +80000114 : +80000114: 00050513 mv a0,a0 +80000118: 00100073 ebreak +8000011c: 0000006f j 8000011c + +80000120 <_trm_init>: +80000120: ff010113 add sp,sp,-16 +80000124: 00000517 auipc a0,0x0 +80000128: 01c50513 add a0,a0,28 # 80000140 <_etext> +8000012c: 00112623 sw ra,12(sp) +80000130: ef9ff0ef jal 80000028
+80000134: 00050513 mv a0,a0 +80000138: 00100073 ebreak +8000013c: 0000006f j 8000013c <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.bin new file mode 100755 index 0000000..221a16f Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.elf new file mode 100755 index 0000000..cee153a Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.txt new file mode 100644 index 0000000..bbfd8a3 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.txt @@ -0,0 +1,82 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/pascal-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0e0000ef jal 800000ec <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0bc000ef jal 800000e0 + +80000028
: +80000028: ff010113 add sp,sp,-16 +8000002c: 00812423 sw s0,8(sp) +80000030: 01212023 sw s2,0(sp) +80000034: 00112623 sw ra,12(sp) +80000038: 00912223 sw s1,4(sp) +8000003c: 00000417 auipc s0,0x0 +80000040: 15040413 add s0,s0,336 # 8000018c +80000044: 00100793 li a5,1 +80000048: 00f42223 sw a5,4(s0) +8000004c: 00f42023 sw a5,0(s0) +80000050: 00000617 auipc a2,0x0 +80000054: 14460613 add a2,a2,324 # 80000194 +80000058: 00000917 auipc s2,0x0 +8000005c: 1b090913 add s2,s2,432 # 80000208 +80000060: 00100593 li a1,1 +80000064: 00000797 auipc a5,0x0 +80000068: 12c78793 add a5,a5,300 # 80000190 +8000006c: 00100693 li a3,1 +80000070: 00068713 mv a4,a3 +80000074: 0007a683 lw a3,0(a5) +80000078: 00478793 add a5,a5,4 +8000007c: 00e68733 add a4,a3,a4 +80000080: fee7ae23 sw a4,-4(a5) +80000084: fec796e3 bne a5,a2,80000070 +80000088: 00b7a023 sw a1,0(a5) +8000008c: 00478613 add a2,a5,4 +80000090: fd261ae3 bne a2,s2,80000064 +80000094: 00000497 auipc s1,0x0 +80000098: 07c48493 add s1,s1,124 # 80000110 +8000009c: 0004a783 lw a5,0(s1) +800000a0: 00042503 lw a0,0(s0) +800000a4: 00440413 add s0,s0,4 +800000a8: 00448493 add s1,s1,4 +800000ac: 40f50533 sub a0,a0,a5 +800000b0: 00153513 seqz a0,a0 +800000b4: f5dff0ef jal 80000010 +800000b8: ff2412e3 bne s0,s2,8000009c +800000bc: 00100513 li a0,1 +800000c0: f51ff0ef jal 80000010 +800000c4: 00c12083 lw ra,12(sp) +800000c8: 00812403 lw s0,8(sp) +800000cc: 00412483 lw s1,4(sp) +800000d0: 00012903 lw s2,0(sp) +800000d4: 00000513 li a0,0 +800000d8: 01010113 add sp,sp,16 +800000dc: 00008067 ret + +800000e0 : +800000e0: 00050513 mv a0,a0 +800000e4: 00100073 ebreak +800000e8: 0000006f j 800000e8 + +800000ec <_trm_init>: +800000ec: ff010113 add sp,sp,-16 +800000f0: 00000517 auipc a0,0x0 +800000f4: 01c50513 add a0,a0,28 # 8000010c <_etext> +800000f8: 00112623 sw ra,12(sp) +800000fc: f2dff0ef jal 80000028
+80000100: 00050513 mv a0,a0 +80000104: 00100073 ebreak +80000108: 0000006f j 80000108 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.bin new file mode 100755 index 0000000..c29d38a Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.elf new file mode 100755 index 0000000..da701fc Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.txt new file mode 100644 index 0000000..559882f --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.txt @@ -0,0 +1,73 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/prime-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0bc000ef jal 800000c8 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 098000ef jal 800000bc + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00812c23 sw s0,24(sp) +80000030: 00912a23 sw s1,20(sp) +80000034: 01212823 sw s2,16(sp) +80000038: 01312623 sw s3,12(sp) +8000003c: 00112e23 sw ra,28(sp) +80000040: 00000493 li s1,0 +80000044: 06500413 li s0,101 +80000048: 00000997 auipc s3,0x0 +8000004c: 0a498993 add s3,s3,164 # 800000ec +80000050: 09700913 li s2,151 +80000054: 00200793 li a5,2 +80000058: 00c0006f j 80000064 +8000005c: 02f46733 rem a4,s0,a5 +80000060: 02070463 beqz a4,80000088 +80000064: 00178793 add a5,a5,1 +80000068: fe879ae3 bne a5,s0,8000005c +8000006c: 00249793 sll a5,s1,0x2 +80000070: 00f987b3 add a5,s3,a5 +80000074: 0007a503 lw a0,0(a5) +80000078: 00148493 add s1,s1,1 +8000007c: 40850533 sub a0,a0,s0 +80000080: 00153513 seqz a0,a0 +80000084: f8dff0ef jal 80000010 +80000088: 00240413 add s0,s0,2 +8000008c: fd2414e3 bne s0,s2,80000054 +80000090: ff648513 add a0,s1,-10 +80000094: 00153513 seqz a0,a0 +80000098: f79ff0ef jal 80000010 +8000009c: 01c12083 lw ra,28(sp) +800000a0: 01812403 lw s0,24(sp) +800000a4: 01412483 lw s1,20(sp) +800000a8: 01012903 lw s2,16(sp) +800000ac: 00c12983 lw s3,12(sp) +800000b0: 00000513 li a0,0 +800000b4: 02010113 add sp,sp,32 +800000b8: 00008067 ret + +800000bc : +800000bc: 00050513 mv a0,a0 +800000c0: 00100073 ebreak +800000c4: 0000006f j 800000c4 + +800000c8 <_trm_init>: +800000c8: ff010113 add sp,sp,-16 +800000cc: 00000517 auipc a0,0x0 +800000d0: 01c50513 add a0,a0,28 # 800000e8 <_etext> +800000d4: 00112623 sw ra,12(sp) +800000d8: f51ff0ef jal 80000028
+800000dc: 00050513 mv a0,a0 +800000e0: 00100073 ebreak +800000e4: 0000006f j 800000e4 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.bin new file mode 100755 index 0000000..15eddfe Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.elf new file mode 100755 index 0000000..c446a3e Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.txt new file mode 100644 index 0000000..7de003d --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.txt @@ -0,0 +1,265 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/quick-sort-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 3ac000ef jal 800003b8 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 388000ef jal 800003ac + +80000028 : +80000028: 00259693 sll a3,a1,0x2 +8000002c: 00d506b3 add a3,a0,a3 +80000030: 00050893 mv a7,a0 +80000034: 0006a803 lw a6,0(a3) +80000038: 00060513 mv a0,a2 +8000003c: 06c5dc63 bge a1,a2,800000b4 +80000040: 00261793 sll a5,a2,0x2 +80000044: 00f887b3 add a5,a7,a5 +80000048: 0007a783 lw a5,0(a5) +8000004c: fff50613 add a2,a0,-1 +80000050: 00261613 sll a2,a2,0x2 +80000054: 00c88633 add a2,a7,a2 +80000058: 0140006f j 8000006c +8000005c: fff50513 add a0,a0,-1 +80000060: 00472783 lw a5,4(a4) +80000064: 06b50863 beq a0,a1,800000d4 +80000068: 00070613 mv a2,a4 +8000006c: ffc60713 add a4,a2,-4 +80000070: fef846e3 blt a6,a5,8000005c +80000074: 00259693 sll a3,a1,0x2 +80000078: 00d886b3 add a3,a7,a3 +8000007c: 00251313 sll t1,a0,0x2 +80000080: 00f6a023 sw a5,0(a3) +80000084: 00688633 add a2,a7,t1 +80000088: 04a5de63 bge a1,a0,800000e4 +8000008c: 00068713 mv a4,a3 +80000090: 00c0006f j 8000009c +80000094: 00158593 add a1,a1,1 +80000098: 02a58463 beq a1,a0,800000c0 +8000009c: 00072783 lw a5,0(a4) +800000a0: 00070693 mv a3,a4 +800000a4: 00470713 add a4,a4,4 +800000a8: fef856e3 bge a6,a5,80000094 +800000ac: 00f62023 sw a5,0(a2) +800000b0: f8a5cee3 blt a1,a0,8000004c +800000b4: 00058513 mv a0,a1 +800000b8: 0106a023 sw a6,0(a3) +800000bc: 00008067 ret +800000c0: 006886b3 add a3,a7,t1 +800000c4: 0006a783 lw a5,0(a3) +800000c8: 00f62023 sw a5,0(a2) +800000cc: 0106a023 sw a6,0(a3) +800000d0: 00008067 ret +800000d4: 00251693 sll a3,a0,0x2 +800000d8: 00d886b3 add a3,a7,a3 +800000dc: 00f6a023 sw a5,0(a3) +800000e0: fe9ff06f j 800000c8 +800000e4: 00058513 mv a0,a1 +800000e8: fe1ff06f j 800000c8 + +800000ec : +800000ec: 1ec5dc63 bge a1,a2,800002e4 +800000f0: fa010113 add sp,sp,-96 +800000f4: 04812c23 sw s0,88(sp) +800000f8: 05612023 sw s6,64(sp) +800000fc: 03812c23 sw s8,56(sp) +80000100: 04112e23 sw ra,92(sp) +80000104: 03912a23 sw s9,52(sp) +80000108: 00058c13 mv s8,a1 +8000010c: 00060b13 mv s6,a2 +80000110: 00050413 mv s0,a0 +80000114: 000b0613 mv a2,s6 +80000118: 000c0593 mv a1,s8 +8000011c: 00040513 mv a0,s0 +80000120: f09ff0ef jal 80000028 +80000124: 00a12023 sw a0,0(sp) +80000128: fff50c93 add s9,a0,-1 +8000012c: 199c5863 bge s8,s9,800002bc +80000130: 04912a23 sw s1,84(sp) +80000134: 05212823 sw s2,80(sp) +80000138: 05312623 sw s3,76(sp) +8000013c: 03a12823 sw s10,48(sp) +80000140: 03b12623 sw s11,44(sp) +80000144: 000c8613 mv a2,s9 +80000148: 000c0593 mv a1,s8 +8000014c: 00040513 mv a0,s0 +80000150: ed9ff0ef jal 80000028 +80000154: 00a12223 sw a0,4(sp) +80000158: fff50d13 add s10,a0,-1 +8000015c: 15ac5063 bge s8,s10,8000029c +80000160: 000d0613 mv a2,s10 +80000164: 000c0593 mv a1,s8 +80000168: 00040513 mv a0,s0 +8000016c: ebdff0ef jal 80000028 +80000170: 00a12423 sw a0,8(sp) +80000174: fff50d93 add s11,a0,-1 +80000178: 11bc5c63 bge s8,s11,80000290 +8000017c: 000d8613 mv a2,s11 +80000180: 000c0593 mv a1,s8 +80000184: 00040513 mv a0,s0 +80000188: ea1ff0ef jal 80000028 +8000018c: 00a12623 sw a0,12(sp) +80000190: fff50993 add s3,a0,-1 +80000194: 0f3c5863 bge s8,s3,80000284 +80000198: 00098613 mv a2,s3 +8000019c: 000c0593 mv a1,s8 +800001a0: 00040513 mv a0,s0 +800001a4: e85ff0ef jal 80000028 +800001a8: fff50913 add s2,a0,-1 +800001ac: 00050493 mv s1,a0 +800001b0: 0d2c5663 bge s8,s2,8000027c +800001b4: 05412423 sw s4,72(sp) +800001b8: 03712e23 sw s7,60(sp) +800001bc: 00090613 mv a2,s2 +800001c0: 000c0593 mv a1,s8 +800001c4: 00040513 mv a0,s0 +800001c8: e61ff0ef jal 80000028 +800001cc: fff50b93 add s7,a0,-1 +800001d0: 00050a13 mv s4,a0 +800001d4: 097c5c63 bge s8,s7,8000026c +800001d8: 05512223 sw s5,68(sp) +800001dc: 000b8613 mv a2,s7 +800001e0: 000c0593 mv a1,s8 +800001e4: 00040513 mv a0,s0 +800001e8: e41ff0ef jal 80000028 +800001ec: 00a12823 sw a0,16(sp) +800001f0: fff50a93 add s5,a0,-1 +800001f4: 075c5463 bge s8,s5,8000025c +800001f8: 000a8613 mv a2,s5 +800001fc: 000c0593 mv a1,s8 +80000200: 00040513 mv a0,s0 +80000204: e25ff0ef jal 80000028 +80000208: fff50713 add a4,a0,-1 +8000020c: 00050793 mv a5,a0 +80000210: 04ec5263 bge s8,a4,80000254 +80000214: 00070613 mv a2,a4 +80000218: 000c0593 mv a1,s8 +8000021c: 00040513 mv a0,s0 +80000220: 00f12e23 sw a5,28(sp) +80000224: 00e12c23 sw a4,24(sp) +80000228: e01ff0ef jal 80000028 +8000022c: fff50613 add a2,a0,-1 +80000230: 00a12a23 sw a0,20(sp) +80000234: 000c0593 mv a1,s8 +80000238: 00040513 mv a0,s0 +8000023c: eb1ff0ef jal 800000ec +80000240: 01412683 lw a3,20(sp) +80000244: 01812703 lw a4,24(sp) +80000248: 01c12783 lw a5,28(sp) +8000024c: 00168c13 add s8,a3,1 +80000250: fcec42e3 blt s8,a4,80000214 +80000254: 00178c13 add s8,a5,1 +80000258: fb5c40e3 blt s8,s5,800001f8 +8000025c: 01012783 lw a5,16(sp) +80000260: 00178c13 add s8,a5,1 +80000264: f77c4ce3 blt s8,s7,800001dc +80000268: 04412a83 lw s5,68(sp) +8000026c: 001a0c13 add s8,s4,1 +80000270: f52c46e3 blt s8,s2,800001bc +80000274: 04812a03 lw s4,72(sp) +80000278: 03c12b83 lw s7,60(sp) +8000027c: 00148c13 add s8,s1,1 +80000280: f13c4ce3 blt s8,s3,80000198 +80000284: 00c12783 lw a5,12(sp) +80000288: 00178c13 add s8,a5,1 +8000028c: efbc48e3 blt s8,s11,8000017c +80000290: 00812783 lw a5,8(sp) +80000294: 00178c13 add s8,a5,1 +80000298: edac44e3 blt s8,s10,80000160 +8000029c: 00412783 lw a5,4(sp) +800002a0: 00178c13 add s8,a5,1 +800002a4: eb9c40e3 blt s8,s9,80000144 +800002a8: 05412483 lw s1,84(sp) +800002ac: 05012903 lw s2,80(sp) +800002b0: 04c12983 lw s3,76(sp) +800002b4: 03012d03 lw s10,48(sp) +800002b8: 02c12d83 lw s11,44(sp) +800002bc: 00012783 lw a5,0(sp) +800002c0: 00178c13 add s8,a5,1 +800002c4: e56c48e3 blt s8,s6,80000114 +800002c8: 05c12083 lw ra,92(sp) +800002cc: 05812403 lw s0,88(sp) +800002d0: 04012b03 lw s6,64(sp) +800002d4: 03812c03 lw s8,56(sp) +800002d8: 03412c83 lw s9,52(sp) +800002dc: 06010113 add sp,sp,96 +800002e0: 00008067 ret +800002e4: 00008067 ret + +800002e8
: +800002e8: fe010113 add sp,sp,-32 +800002ec: 00912a23 sw s1,20(sp) +800002f0: 01300613 li a2,19 +800002f4: 00000593 li a1,0 +800002f8: 00000517 auipc a0,0x0 +800002fc: 0e450513 add a0,a0,228 # 800003dc +80000300: 00000497 auipc s1,0x0 +80000304: 0dc48493 add s1,s1,220 # 800003dc +80000308: 00812c23 sw s0,24(sp) +8000030c: 01212823 sw s2,16(sp) +80000310: 01312623 sw s3,12(sp) +80000314: 00112e23 sw ra,28(sp) +80000318: 00048913 mv s2,s1 +8000031c: dd1ff0ef jal 800000ec +80000320: 00000413 li s0,0 +80000324: 01400993 li s3,20 +80000328: 00092503 lw a0,0(s2) +8000032c: 00490913 add s2,s2,4 +80000330: 40850533 sub a0,a0,s0 +80000334: 00153513 seqz a0,a0 +80000338: 00140413 add s0,s0,1 +8000033c: cd5ff0ef jal 80000010 +80000340: ff3414e3 bne s0,s3,80000328 +80000344: 00100513 li a0,1 +80000348: cc9ff0ef jal 80000010 +8000034c: 01300613 li a2,19 +80000350: 00000593 li a1,0 +80000354: 00000517 auipc a0,0x0 +80000358: 08850513 add a0,a0,136 # 800003dc +8000035c: d91ff0ef jal 800000ec +80000360: 00000413 li s0,0 +80000364: 01400913 li s2,20 +80000368: 0004a503 lw a0,0(s1) +8000036c: 00448493 add s1,s1,4 +80000370: 40850533 sub a0,a0,s0 +80000374: 00153513 seqz a0,a0 +80000378: 00140413 add s0,s0,1 +8000037c: c95ff0ef jal 80000010 +80000380: ff2414e3 bne s0,s2,80000368 +80000384: 00100513 li a0,1 +80000388: c89ff0ef jal 80000010 +8000038c: 01c12083 lw ra,28(sp) +80000390: 01812403 lw s0,24(sp) +80000394: 01412483 lw s1,20(sp) +80000398: 01012903 lw s2,16(sp) +8000039c: 00c12983 lw s3,12(sp) +800003a0: 00000513 li a0,0 +800003a4: 02010113 add sp,sp,32 +800003a8: 00008067 ret + +800003ac : +800003ac: 00050513 mv a0,a0 +800003b0: 00100073 ebreak +800003b4: 0000006f j 800003b4 + +800003b8 <_trm_init>: +800003b8: ff010113 add sp,sp,-16 +800003bc: 00000517 auipc a0,0x0 +800003c0: 01c50513 add a0,a0,28 # 800003d8 <_etext> +800003c4: 00112623 sw ra,12(sp) +800003c8: f21ff0ef jal 800002e8
+800003cc: 00050513 mv a0,a0 +800003d0: 00100073 ebreak +800003d4: 0000006f j 800003d4 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.bin new file mode 100755 index 0000000..c4536d1 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.elf new file mode 100755 index 0000000..9f8838b Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.txt new file mode 100644 index 0000000..e991879 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.txt @@ -0,0 +1,181 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/recursion-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 24c000ef jal 80000258 <_trm_init> + +80000010 : +80000010: 00000797 auipc a5,0x0 +80000014: 28878793 add a5,a5,648 # 80000298 +80000018: 0007a703 lw a4,0(a5) +8000001c: 00b75463 bge a4,a1,80000024 +80000020: 00b7a023 sw a1,0(a5) +80000024: 00000717 auipc a4,0x0 +80000028: 27870713 add a4,a4,632 # 8000029c +8000002c: 00072783 lw a5,0(a4) +80000030: 00178793 add a5,a5,1 +80000034: 00f72023 sw a5,0(a4) +80000038: 00a05e63 blez a0,80000054 +8000003c: 00300793 li a5,3 +80000040: 02f54533 div a0,a0,a5 +80000044: 00158593 add a1,a1,1 +80000048: 00000797 auipc a5,0x0 +8000004c: 24c7a783 lw a5,588(a5) # 80000294 +80000050: 00078067 jr a5 +80000054: 00100513 li a0,1 +80000058: 00008067 ret + +8000005c : +8000005c: 00000797 auipc a5,0x0 +80000060: 23c78793 add a5,a5,572 # 80000298 +80000064: 0007a703 lw a4,0(a5) +80000068: 00b75463 bge a4,a1,80000070 +8000006c: 00b7a023 sw a1,0(a5) +80000070: 00000717 auipc a4,0x0 +80000074: 22c70713 add a4,a4,556 # 8000029c +80000078: 00072783 lw a5,0(a4) +8000007c: 00178793 add a5,a5,1 +80000080: 00f72023 sw a5,0(a4) +80000084: 00a05c63 blez a0,8000009c +80000088: 00158593 add a1,a1,1 +8000008c: fff50513 add a0,a0,-1 +80000090: 00000797 auipc a5,0x0 +80000094: 1f87a783 lw a5,504(a5) # 80000288 +80000098: 00078067 jr a5 +8000009c: 00100513 li a0,1 +800000a0: 00008067 ret + +800000a4 : +800000a4: 00000717 auipc a4,0x0 +800000a8: 1f470713 add a4,a4,500 # 80000298 +800000ac: 00072683 lw a3,0(a4) +800000b0: 00050793 mv a5,a0 +800000b4: 00b6d463 bge a3,a1,800000bc +800000b8: 00b72023 sw a1,0(a4) +800000bc: 00000697 auipc a3,0x0 +800000c0: 1e068693 add a3,a3,480 # 8000029c +800000c4: 0006a703 lw a4,0(a3) +800000c8: 00100513 li a0,1 +800000cc: 00170713 add a4,a4,1 +800000d0: 00e6a023 sw a4,0(a3) +800000d4: 02f05863 blez a5,80000104 +800000d8: ff010113 add sp,sp,-16 +800000dc: 00112623 sw ra,12(sp) +800000e0: 00078513 mv a0,a5 +800000e4: 00158593 add a1,a1,1 +800000e8: 00000797 auipc a5,0x0 +800000ec: 1a47a783 lw a5,420(a5) # 8000028c +800000f0: 000780e7 jalr a5 +800000f4: 00c12083 lw ra,12(sp) +800000f8: 00950513 add a0,a0,9 +800000fc: 01010113 add sp,sp,16 +80000100: 00008067 ret +80000104: 00008067 ret + +80000108 : +80000108: 00000717 auipc a4,0x0 +8000010c: 19070713 add a4,a4,400 # 80000298 +80000110: 00072683 lw a3,0(a4) +80000114: 00050793 mv a5,a0 +80000118: 00b6d463 bge a3,a1,80000120 +8000011c: 00b72023 sw a1,0(a4) +80000120: 00000697 auipc a3,0x0 +80000124: 17c68693 add a3,a3,380 # 8000029c +80000128: 0006a703 lw a4,0(a3) +8000012c: 00100513 li a0,1 +80000130: 00170713 add a4,a4,1 +80000134: 00e6a023 sw a4,0(a3) +80000138: 06f05c63 blez a5,800001b0 +8000013c: ff010113 add sp,sp,-16 +80000140: 01212023 sw s2,0(sp) +80000144: 00000917 auipc s2,0x0 +80000148: 14490913 add s2,s2,324 # 80000288 +8000014c: 00892703 lw a4,8(s2) +80000150: 00812423 sw s0,8(sp) +80000154: 00912223 sw s1,4(sp) +80000158: 00158413 add s0,a1,1 +8000015c: 4017d493 sra s1,a5,0x1 +80000160: 00112623 sw ra,12(sp) +80000164: 00040593 mv a1,s0 +80000168: 00048513 mv a0,s1 +8000016c: 000700e7 jalr a4 +80000170: 00892703 lw a4,8(s2) +80000174: 00050793 mv a5,a0 +80000178: 00040593 mv a1,s0 +8000017c: 00048513 mv a0,s1 +80000180: 00078413 mv s0,a5 +80000184: 000700e7 jalr a4 +80000188: 00141793 sll a5,s0,0x1 +8000018c: 00c12083 lw ra,12(sp) +80000190: 008787b3 add a5,a5,s0 +80000194: 00812403 lw s0,8(sp) +80000198: 00151513 sll a0,a0,0x1 +8000019c: 00412483 lw s1,4(sp) +800001a0: 00012903 lw s2,0(sp) +800001a4: 00a78533 add a0,a5,a0 +800001a8: 01010113 add sp,sp,16 +800001ac: 00008067 ret +800001b0: 00008067 ret + +800001b4 : +800001b4: 00050463 beqz a0,800001bc +800001b8: 00008067 ret +800001bc: ff010113 add sp,sp,-16 +800001c0: 00100513 li a0,1 +800001c4: 00112623 sw ra,12(sp) +800001c8: 084000ef jal 8000024c + +800001cc
: +800001cc: ff010113 add sp,sp,-16 +800001d0: 00004537 lui a0,0x4 +800001d4: 00112623 sw ra,12(sp) +800001d8: 00812423 sw s0,8(sp) +800001dc: 00000593 li a1,0 +800001e0: 00000797 auipc a5,0x0 +800001e4: 0a87a783 lw a5,168(a5) # 80000288 +800001e8: 82350513 add a0,a0,-2013 # 3823 <_entry_offset+0x3823> +800001ec: 000780e7 jalr a5 +800001f0: 00000417 auipc s0,0x0 +800001f4: 08c40413 add s0,s0,140 # 8000027c +800001f8: 00042783 lw a5,0(s0) +800001fc: 40a78533 sub a0,a5,a0 +80000200: 00153513 seqz a0,a0 +80000204: fb1ff0ef jal 800001b4 +80000208: 00442503 lw a0,4(s0) +8000020c: 00000797 auipc a5,0x0 +80000210: 0907a783 lw a5,144(a5) # 8000029c +80000214: 40f50533 sub a0,a0,a5 +80000218: 00153513 seqz a0,a0 +8000021c: f99ff0ef jal 800001b4 +80000220: 00842503 lw a0,8(s0) +80000224: 00000797 auipc a5,0x0 +80000228: 0747a783 lw a5,116(a5) # 80000298 +8000022c: 40f50533 sub a0,a0,a5 +80000230: 00153513 seqz a0,a0 +80000234: f81ff0ef jal 800001b4 +80000238: 00c12083 lw ra,12(sp) +8000023c: 00812403 lw s0,8(sp) +80000240: 00000513 li a0,0 +80000244: 01010113 add sp,sp,16 +80000248: 00008067 ret + +8000024c : +8000024c: 00050513 mv a0,a0 +80000250: 00100073 ebreak +80000254: 0000006f j 80000254 + +80000258 <_trm_init>: +80000258: ff010113 add sp,sp,-16 +8000025c: 00000517 auipc a0,0x0 +80000260: 01c50513 add a0,a0,28 # 80000278 <_etext> +80000264: 00112623 sw ra,12(sp) +80000268: f65ff0ef jal 800001cc
+8000026c: 00050513 mv a0,a0 +80000270: 00100073 ebreak +80000274: 0000006f j 80000274 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add-longlong.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add-longlong.d new file mode 100644 index 0000000..4fd9cbc --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add-longlong.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add-longlong.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/add-longlong.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add-longlong.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add-longlong.o new file mode 100644 index 0000000..b0b08ea Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add-longlong.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add.d new file mode 100644 index 0000000..b0f9ee1 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/add.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add.o new file mode 100644 index 0000000..ccf7e79 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/add.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bit.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bit.d new file mode 100644 index 0000000..ff9ba45 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bit.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bit.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/bit.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bit.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bit.o new file mode 100644 index 0000000..0622ead Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bit.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bubble-sort.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bubble-sort.d new file mode 100644 index 0000000..4c8865f --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bubble-sort.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bubble-sort.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/bubble-sort.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bubble-sort.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bubble-sort.o new file mode 100644 index 0000000..6c680ea Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/bubble-sort.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/crc32.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/crc32.d new file mode 100644 index 0000000..5ccf7ca --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/crc32.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/crc32.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/crc32.c \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/crc32.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/crc32.o new file mode 100644 index 0000000..d9a3f7e Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/crc32.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/div.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/div.d new file mode 100644 index 0000000..51ddb69 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/div.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/div.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/div.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/div.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/div.o new file mode 100644 index 0000000..c64647a Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/div.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/dummy.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/dummy.d new file mode 100644 index 0000000..7b76483 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/dummy.d @@ -0,0 +1,2 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/dummy.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/dummy.c diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/dummy.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/dummy.o new file mode 100644 index 0000000..190ac43 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/dummy.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fact.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fact.d new file mode 100644 index 0000000..3d37f26 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fact.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fact.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/fact.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fact.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fact.o new file mode 100644 index 0000000..ae10b1d Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fact.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fib.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fib.d new file mode 100644 index 0000000..27c9d60 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fib.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fib.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/fib.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fib.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fib.o new file mode 100644 index 0000000..3c1ec6a Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/fib.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/goldbach.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/goldbach.d new file mode 100644 index 0000000..41d719e --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/goldbach.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/goldbach.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/goldbach.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/goldbach.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/goldbach.o new file mode 100644 index 0000000..4302566 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/goldbach.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/hello-str.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/hello-str.d new file mode 100644 index 0000000..e4f1cdf --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/hello-str.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/hello-str.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/hello-str.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/hello-str.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/hello-str.o new file mode 100644 index 0000000..c8fca5c Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/hello-str.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/if-else.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/if-else.d new file mode 100644 index 0000000..e824a8a --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/if-else.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/if-else.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/if-else.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/if-else.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/if-else.o new file mode 100644 index 0000000..8f2bf82 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/if-else.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/leap-year.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/leap-year.d new file mode 100644 index 0000000..04be4ee --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/leap-year.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/leap-year.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/leap-year.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/leap-year.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/leap-year.o new file mode 100644 index 0000000..ebb3bc0 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/leap-year.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/load-store.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/load-store.d new file mode 100644 index 0000000..f594fb5 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/load-store.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/load-store.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/load-store.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/load-store.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/load-store.o new file mode 100644 index 0000000..d3f0daf Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/load-store.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/matrix-mul.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/matrix-mul.d new file mode 100644 index 0000000..759010e --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/matrix-mul.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/matrix-mul.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/matrix-mul.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/matrix-mul.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/matrix-mul.o new file mode 100644 index 0000000..9af2f1c Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/matrix-mul.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/max.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/max.d new file mode 100644 index 0000000..0d263b7 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/max.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/max.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/max.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/max.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/max.o new file mode 100644 index 0000000..c230eea Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/max.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mersenne.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mersenne.d new file mode 100644 index 0000000..eda1b05 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mersenne.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mersenne.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/mersenne.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mersenne.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mersenne.o new file mode 100644 index 0000000..744e54b Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mersenne.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/min3.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/min3.d new file mode 100644 index 0000000..6a38ec3 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/min3.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/min3.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/min3.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/min3.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/min3.o new file mode 100644 index 0000000..da0449e Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/min3.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mov-c.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mov-c.d new file mode 100644 index 0000000..b81333a --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mov-c.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mov-c.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/mov-c.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mov-c.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mov-c.o new file mode 100644 index 0000000..0d35e22 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mov-c.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/movsx.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/movsx.d new file mode 100644 index 0000000..dad20e8 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/movsx.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/movsx.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/movsx.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/movsx.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/movsx.o new file mode 100644 index 0000000..587aaf8 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/movsx.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mul-longlong.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mul-longlong.d new file mode 100644 index 0000000..7553c3d --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mul-longlong.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mul-longlong.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/mul-longlong.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mul-longlong.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mul-longlong.o new file mode 100644 index 0000000..7fbdb76 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/mul-longlong.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/pascal.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/pascal.d new file mode 100644 index 0000000..e9c4d37 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/pascal.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/pascal.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/pascal.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/pascal.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/pascal.o new file mode 100644 index 0000000..86c161c Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/pascal.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/prime.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/prime.d new file mode 100644 index 0000000..52b34f3 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/prime.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/prime.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/prime.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/prime.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/prime.o new file mode 100644 index 0000000..9c06590 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/prime.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/quick-sort.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/quick-sort.d new file mode 100644 index 0000000..0efaa90 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/quick-sort.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/quick-sort.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/quick-sort.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/quick-sort.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/quick-sort.o new file mode 100644 index 0000000..fdd15a4 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/quick-sort.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/recursion.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/recursion.d new file mode 100644 index 0000000..daa2f18 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/recursion.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/recursion.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/recursion.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/recursion.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/recursion.o new file mode 100644 index 0000000..2f2e31b Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/recursion.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/select-sort.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/select-sort.d new file mode 100644 index 0000000..d16b729 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/select-sort.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/select-sort.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/select-sort.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/select-sort.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/select-sort.o new file mode 100644 index 0000000..bf74ee2 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/select-sort.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shift.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shift.d new file mode 100644 index 0000000..d3f5b90 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shift.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shift.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/shift.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shift.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shift.o new file mode 100644 index 0000000..d00d247 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shift.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shuixianhua.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shuixianhua.d new file mode 100644 index 0000000..9c94213 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shuixianhua.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shuixianhua.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/shuixianhua.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shuixianhua.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shuixianhua.o new file mode 100644 index 0000000..75c8f20 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/shuixianhua.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/string.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/string.d new file mode 100644 index 0000000..3103c78 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/string.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/string.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/string.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/string.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/string.o new file mode 100644 index 0000000..f3d505b Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/string.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sub-longlong.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sub-longlong.d new file mode 100644 index 0000000..0211d20 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sub-longlong.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sub-longlong.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/sub-longlong.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sub-longlong.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sub-longlong.o new file mode 100644 index 0000000..b13ae41 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sub-longlong.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sum.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sum.d new file mode 100644 index 0000000..4a9fb70 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sum.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sum.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/sum.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sum.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sum.o new file mode 100644 index 0000000..d309ab1 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/sum.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/switch.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/switch.d new file mode 100644 index 0000000..894f595 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/switch.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/switch.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/switch.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/switch.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/switch.o new file mode 100644 index 0000000..8712b15 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/switch.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/to-lower-case.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/to-lower-case.d new file mode 100644 index 0000000..ba91e88 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/to-lower-case.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/to-lower-case.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/to-lower-case.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/to-lower-case.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/to-lower-case.o new file mode 100644 index 0000000..3a753b6 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/to-lower-case.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/unalign.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/unalign.d new file mode 100644 index 0000000..0574c58 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/unalign.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/unalign.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/unalign.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/unalign.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/unalign.o new file mode 100644 index 0000000..b6d7624 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/unalign.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/wanshu.d b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/wanshu.d new file mode 100644 index 0000000..6cac988 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/wanshu.d @@ -0,0 +1,8 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/wanshu.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/wanshu.c \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/include/trap.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/am.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/arch/riscv.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/am/include/amdev.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib.h \ + /home/xin/repo/ysyx-workbench/abstract-machine/klib/include/klib-macros.h diff --git a/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/wanshu.o b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/wanshu.o new file mode 100644 index 0000000..6f199ae Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32-nemu/tests/wanshu.o differ diff --git a/am-kernels/tests/cpu-tests/build/riscv32e-nemu/tests/dummy.d b/am-kernels/tests/cpu-tests/build/riscv32e-nemu/tests/dummy.d new file mode 100644 index 0000000..bad4dac --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/riscv32e-nemu/tests/dummy.d @@ -0,0 +1,2 @@ +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/riscv32e-nemu/tests/dummy.o: \ + /home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/tests/dummy.c diff --git a/am-kernels/tests/cpu-tests/build/riscv32e-nemu/tests/dummy.o b/am-kernels/tests/cpu-tests/build/riscv32e-nemu/tests/dummy.o new file mode 100644 index 0000000..9ce45fc Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/riscv32e-nemu/tests/dummy.o differ diff --git a/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.bin new file mode 100755 index 0000000..3e7cbcb Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.elf new file mode 100755 index 0000000..1a56ac2 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.txt new file mode 100644 index 0000000..3bde9f0 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.txt @@ -0,0 +1,106 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/select-sort-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 138000ef jal 80000144 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 114000ef jal 80000138 + +80000028 : +80000028: 00000897 auipc a7,0x0 +8000002c: 14488893 add a7,a7,324 # 8000016c +80000030: 00000813 li a6,0 +80000034: 00000e97 auipc t4,0x0 +80000038: 134e8e93 add t4,t4,308 # 80000168 +8000003c: 01400513 li a0,20 +80000040: 01300e13 li t3,19 +80000044: ffc8a303 lw t1,-4(a7) +80000048: 00080593 mv a1,a6 +8000004c: 00180813 add a6,a6,1 +80000050: 00088713 mv a4,a7 +80000054: 00030613 mv a2,t1 +80000058: 00080793 mv a5,a6 +8000005c: 00072683 lw a3,0(a4) +80000060: 00470713 add a4,a4,4 +80000064: 00c6d663 bge a3,a2,80000070 +80000068: 00078593 mv a1,a5 +8000006c: 00068613 mv a2,a3 +80000070: 00178793 add a5,a5,1 +80000074: fea794e3 bne a5,a0,8000005c +80000078: 00259593 sll a1,a1,0x2 +8000007c: fec8ae23 sw a2,-4(a7) +80000080: 00be85b3 add a1,t4,a1 +80000084: 0065a023 sw t1,0(a1) +80000088: 00488893 add a7,a7,4 +8000008c: fbc81ce3 bne a6,t3,80000044 +80000090: 00008067 ret + +80000094
: +80000094: fe010113 add sp,sp,-32 +80000098: 00912a23 sw s1,20(sp) +8000009c: 00000497 auipc s1,0x0 +800000a0: 0cc48493 add s1,s1,204 # 80000168 +800000a4: 00812c23 sw s0,24(sp) +800000a8: 01212823 sw s2,16(sp) +800000ac: 01312623 sw s3,12(sp) +800000b0: 00112e23 sw ra,28(sp) +800000b4: 00048913 mv s2,s1 +800000b8: f71ff0ef jal 80000028 +800000bc: 00000413 li s0,0 +800000c0: 01400993 li s3,20 +800000c4: 00092503 lw a0,0(s2) +800000c8: 00490913 add s2,s2,4 +800000cc: 40850533 sub a0,a0,s0 +800000d0: 00153513 seqz a0,a0 +800000d4: 00140413 add s0,s0,1 +800000d8: f39ff0ef jal 80000010 +800000dc: ff3414e3 bne s0,s3,800000c4 +800000e0: 00100513 li a0,1 +800000e4: f2dff0ef jal 80000010 +800000e8: 00000413 li s0,0 +800000ec: f3dff0ef jal 80000028 +800000f0: 01400913 li s2,20 +800000f4: 0004a503 lw a0,0(s1) +800000f8: 00448493 add s1,s1,4 +800000fc: 40850533 sub a0,a0,s0 +80000100: 00153513 seqz a0,a0 +80000104: 00140413 add s0,s0,1 +80000108: f09ff0ef jal 80000010 +8000010c: ff2414e3 bne s0,s2,800000f4 +80000110: 00100513 li a0,1 +80000114: efdff0ef jal 80000010 +80000118: 01c12083 lw ra,28(sp) +8000011c: 01812403 lw s0,24(sp) +80000120: 01412483 lw s1,20(sp) +80000124: 01012903 lw s2,16(sp) +80000128: 00c12983 lw s3,12(sp) +8000012c: 00000513 li a0,0 +80000130: 02010113 add sp,sp,32 +80000134: 00008067 ret + +80000138 : +80000138: 00050513 mv a0,a0 +8000013c: 00100073 ebreak +80000140: 0000006f j 80000140 + +80000144 <_trm_init>: +80000144: ff010113 add sp,sp,-16 +80000148: 00000517 auipc a0,0x0 +8000014c: 01c50513 add a0,a0,28 # 80000164 <_etext> +80000150: 00112623 sw ra,12(sp) +80000154: f41ff0ef jal 80000094
+80000158: 00050513 mv a0,a0 +8000015c: 00100073 ebreak +80000160: 0000006f j 80000160 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.bin new file mode 100755 index 0000000..27fbda1 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.elf new file mode 100755 index 0000000..6fb5389 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.txt new file mode 100644 index 0000000..fc68848 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.txt @@ -0,0 +1,98 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/shift-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 120000ef jal 8000012c <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0fc000ef jal 80000120 + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00912a23 sw s1,20(sp) +80000030: 00000497 auipc s1,0x0 +80000034: 18048493 add s1,s1,384 # 800001b0 +80000038: 00812c23 sw s0,24(sp) +8000003c: 01212823 sw s2,16(sp) +80000040: 01312623 sw s3,12(sp) +80000044: 00112e23 sw ra,28(sp) +80000048: 01412423 sw s4,8(sp) +8000004c: 00000917 auipc s2,0x0 +80000050: 14490913 add s2,s2,324 # 80000190 +80000054: 00000997 auipc s3,0x0 +80000058: 17c98993 add s3,s3,380 # 800001d0 <_bss_start> +8000005c: 00048413 mv s0,s1 +80000060: 00042503 lw a0,0(s0) +80000064: 00092783 lw a5,0(s2) +80000068: 00440413 add s0,s0,4 +8000006c: 00755513 srl a0,a0,0x7 +80000070: 40f50533 sub a0,a0,a5 +80000074: 00153513 seqz a0,a0 +80000078: f99ff0ef jal 80000010 +8000007c: 00490913 add s2,s2,4 +80000080: ff3410e3 bne s0,s3,80000060 +80000084: 00000997 auipc s3,0x0 +80000088: 0cc98993 add s3,s3,204 # 80000150 +8000008c: 00000917 auipc s2,0x0 +80000090: 12490913 add s2,s2,292 # 800001b0 +80000094: 00400413 li s0,4 +80000098: 00c00a13 li s4,12 +8000009c: 00092503 lw a0,0(s2) +800000a0: 0009a783 lw a5,0(s3) +800000a4: 00490913 add s2,s2,4 +800000a8: 40855533 sra a0,a0,s0 +800000ac: 40f50533 sub a0,a0,a5 +800000b0: 00153513 seqz a0,a0 +800000b4: 00140413 add s0,s0,1 +800000b8: f59ff0ef jal 80000010 +800000bc: 00498993 add s3,s3,4 +800000c0: fd441ee3 bne s0,s4,8000009c +800000c4: 00000917 auipc s2,0x0 +800000c8: 0ac90913 add s2,s2,172 # 80000170 +800000cc: 00400413 li s0,4 +800000d0: 00c00993 li s3,12 +800000d4: 0004a503 lw a0,0(s1) +800000d8: 00092783 lw a5,0(s2) +800000dc: 00448493 add s1,s1,4 +800000e0: 00855533 srl a0,a0,s0 +800000e4: 40f50533 sub a0,a0,a5 +800000e8: 00153513 seqz a0,a0 +800000ec: 00140413 add s0,s0,1 +800000f0: f21ff0ef jal 80000010 +800000f4: 00490913 add s2,s2,4 +800000f8: fd341ee3 bne s0,s3,800000d4 +800000fc: 01c12083 lw ra,28(sp) +80000100: 01812403 lw s0,24(sp) +80000104: 01412483 lw s1,20(sp) +80000108: 01012903 lw s2,16(sp) +8000010c: 00c12983 lw s3,12(sp) +80000110: 00812a03 lw s4,8(sp) +80000114: 00000513 li a0,0 +80000118: 02010113 add sp,sp,32 +8000011c: 00008067 ret + +80000120 : +80000120: 00050513 mv a0,a0 +80000124: 00100073 ebreak +80000128: 0000006f j 80000128 + +8000012c <_trm_init>: +8000012c: ff010113 add sp,sp,-16 +80000130: 00000517 auipc a0,0x0 +80000134: 01c50513 add a0,a0,28 # 8000014c <_etext> +80000138: 00112623 sw ra,12(sp) +8000013c: eedff0ef jal 80000028
+80000140: 00050513 mv a0,a0 +80000144: 00100073 ebreak +80000148: 0000006f j 80000148 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.bin new file mode 100755 index 0000000..b8c534f Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.elf new file mode 100755 index 0000000..195932f Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.txt new file mode 100644 index 0000000..2005987 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.txt @@ -0,0 +1,89 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/shuixianhua-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0fc000ef jal 80000108 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0d8000ef jal 800000fc + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00812c23 sw s0,24(sp) +80000030: 00912a23 sw s1,20(sp) +80000034: 01212823 sw s2,16(sp) +80000038: 01312623 sw s3,12(sp) +8000003c: 01412423 sw s4,8(sp) +80000040: 01512223 sw s5,4(sp) +80000044: 00112e23 sw ra,28(sp) +80000048: 00000a93 li s5,0 +8000004c: 06400413 li s0,100 +80000050: 06400a13 li s4,100 +80000054: 00a00913 li s2,10 +80000058: 00000497 auipc s1,0x0 +8000005c: 0d448493 add s1,s1,212 # 8000012c +80000060: 1f400993 li s3,500 +80000064: 00c0006f j 80000070 +80000068: 00140413 add s0,s0,1 +8000006c: 05340e63 beq s0,s3,800000c8 +80000070: 03244733 div a4,s0,s2 +80000074: 03444633 div a2,s0,s4 +80000078: 032466b3 rem a3,s0,s2 +8000007c: 03276733 rem a4,a4,s2 +80000080: 02c607b3 mul a5,a2,a2 +80000084: 02d68533 mul a0,a3,a3 +80000088: 02e705b3 mul a1,a4,a4 +8000008c: 02c787b3 mul a5,a5,a2 +80000090: 02d506b3 mul a3,a0,a3 +80000094: 02e58733 mul a4,a1,a4 +80000098: 00d787b3 add a5,a5,a3 +8000009c: 00e787b3 add a5,a5,a4 +800000a0: fc8794e3 bne a5,s0,80000068 +800000a4: 002a9793 sll a5,s5,0x2 +800000a8: 00f487b3 add a5,s1,a5 +800000ac: 0007a503 lw a0,0(a5) +800000b0: 001a8a93 add s5,s5,1 +800000b4: 40850533 sub a0,a0,s0 +800000b8: 00153513 seqz a0,a0 +800000bc: 00140413 add s0,s0,1 +800000c0: f51ff0ef jal 80000010 +800000c4: fb3416e3 bne s0,s3,80000070 +800000c8: ffca8513 add a0,s5,-4 +800000cc: 00153513 seqz a0,a0 +800000d0: f41ff0ef jal 80000010 +800000d4: 01c12083 lw ra,28(sp) +800000d8: 01812403 lw s0,24(sp) +800000dc: 01412483 lw s1,20(sp) +800000e0: 01012903 lw s2,16(sp) +800000e4: 00c12983 lw s3,12(sp) +800000e8: 00812a03 lw s4,8(sp) +800000ec: 00412a83 lw s5,4(sp) +800000f0: 00000513 li a0,0 +800000f4: 02010113 add sp,sp,32 +800000f8: 00008067 ret + +800000fc : +800000fc: 00050513 mv a0,a0 +80000100: 00100073 ebreak +80000104: 0000006f j 80000104 + +80000108 <_trm_init>: +80000108: ff010113 add sp,sp,-16 +8000010c: 00000517 auipc a0,0x0 +80000110: 01c50513 add a0,a0,28 # 80000128 <_etext> +80000114: 00112623 sw ra,12(sp) +80000118: f11ff0ef jal 80000028
+8000011c: 00050513 mv a0,a0 +80000120: 00100073 ebreak +80000124: 0000006f j 80000124 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.bin new file mode 100755 index 0000000..2723d46 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.elf new file mode 100755 index 0000000..dae7c93 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.txt new file mode 100644 index 0000000..0adaa51 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.txt @@ -0,0 +1,243 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/string-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 12c000ef jal 80000138 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 108000ef jal 8000012c + +80000028
: +80000028: ff010113 add sp,sp,-16 +8000002c: 00812423 sw s0,8(sp) +80000030: 00000417 auipc s0,0x0 +80000034: 59440413 add s0,s0,1428 # 800005c4 +80000038: 00842583 lw a1,8(s0) +8000003c: 00042503 lw a0,0(s0) +80000040: 00112623 sw ra,12(sp) +80000044: 1e4000ef jal 80000228 +80000048: 00153513 seqz a0,a0 +8000004c: fc5ff0ef jal 80000010 +80000050: 00442583 lw a1,4(s0) +80000054: 00042503 lw a0,0(s0) +80000058: 1d0000ef jal 80000228 +8000005c: 01f55513 srl a0,a0,0x1f +80000060: fb1ff0ef jal 80000010 +80000064: 00442583 lw a1,4(s0) +80000068: 00042503 lw a0,0(s0) +8000006c: 00158593 add a1,a1,1 +80000070: 00150513 add a0,a0,1 +80000074: 1b4000ef jal 80000228 +80000078: 01f55513 srl a0,a0,0x1f +8000007c: f95ff0ef jal 80000010 +80000080: 00442583 lw a1,4(s0) +80000084: 00042503 lw a0,0(s0) +80000088: 00258593 add a1,a1,2 +8000008c: 00250513 add a0,a0,2 +80000090: 198000ef jal 80000228 +80000094: 01f55513 srl a0,a0,0x1f +80000098: f79ff0ef jal 80000010 +8000009c: 00442583 lw a1,4(s0) +800000a0: 00042503 lw a0,0(s0) +800000a4: 00358593 add a1,a1,3 +800000a8: 00350513 add a0,a0,3 +800000ac: 17c000ef jal 80000228 +800000b0: 01f55513 srl a0,a0,0x1f +800000b4: f5dff0ef jal 80000010 +800000b8: 00000597 auipc a1,0x0 +800000bc: 50458593 add a1,a1,1284 # 800005bc +800000c0: 00000517 auipc a0,0x0 +800000c4: 51c50513 add a0,a0,1308 # 800005dc +800000c8: 090000ef jal 80000158 +800000cc: 00c42583 lw a1,12(s0) +800000d0: 0f0000ef jal 800001c0 +800000d4: 01042583 lw a1,16(s0) +800000d8: 150000ef jal 80000228 +800000dc: 00153513 seqz a0,a0 +800000e0: f31ff0ef jal 80000010 +800000e4: 00500613 li a2,5 +800000e8: 02300593 li a1,35 +800000ec: 00000517 auipc a0,0x0 +800000f0: 4f050513 add a0,a0,1264 # 800005dc +800000f4: 19c000ef jal 80000290 +800000f8: 01442583 lw a1,20(s0) +800000fc: 00500613 li a2,5 +80000100: 1f8000ef jal 800002f8 +80000104: 00153513 seqz a0,a0 +80000108: f09ff0ef jal 80000010 +8000010c: 00c12083 lw ra,12(sp) +80000110: 00812403 lw s0,8(sp) +80000114: 00000513 li a0,0 +80000118: 01010113 add sp,sp,16 +8000011c: 00008067 ret + +80000120 : +80000120: a00007b7 lui a5,0xa0000 +80000124: 3ea78c23 sb a0,1016(a5) # a00003f8 <_end+0x1fff73f8> +80000128: 00008067 ret + +8000012c : +8000012c: 00050513 mv a0,a0 +80000130: 00100073 ebreak +80000134: 0000006f j 80000134 + +80000138 <_trm_init>: +80000138: ff010113 add sp,sp,-16 +8000013c: 00000517 auipc a0,0x0 +80000140: 47c50513 add a0,a0,1148 # 800005b8 +80000144: 00112623 sw ra,12(sp) +80000148: ee1ff0ef jal 80000028
+8000014c: 00050513 mv a0,a0 +80000150: 00100073 ebreak +80000154: 0000006f j 80000154 <_trm_init+0x1c> + +80000158 : +80000158: ff010113 add sp,sp,-16 +8000015c: 00812423 sw s0,8(sp) +80000160: 00112623 sw ra,12(sp) +80000164: 00000417 auipc s0,0x0 +80000168: 27040413 add s0,s0,624 # 800003d4 <_etext+0x74> +8000016c: 04100513 li a0,65 +80000170: fb1ff0ef jal 80000120 +80000174: 00144503 lbu a0,1(s0) +80000178: 00140413 add s0,s0,1 +8000017c: fe051ae3 bnez a0,80000170 +80000180: 00000417 auipc s0,0x0 +80000184: 26040413 add s0,s0,608 # 800003e0 <_etext+0x80> +80000188: 04e00513 li a0,78 +8000018c: f95ff0ef jal 80000120 +80000190: 00144503 lbu a0,1(s0) +80000194: 00140413 add s0,s0,1 +80000198: fe051ae3 bnez a0,8000018c +8000019c: 00000417 auipc s0,0x0 +800001a0: 2a040413 add s0,s0,672 # 8000043c <_etext+0xdc> +800001a4: 02000513 li a0,32 +800001a8: f79ff0ef jal 80000120 +800001ac: 00144503 lbu a0,1(s0) +800001b0: 00140413 add s0,s0,1 +800001b4: fe051ae3 bnez a0,800001a8 +800001b8: 00100513 li a0,1 +800001bc: f71ff0ef jal 8000012c + +800001c0 : +800001c0: ff010113 add sp,sp,-16 +800001c4: 00812423 sw s0,8(sp) +800001c8: 00112623 sw ra,12(sp) +800001cc: 00000417 auipc s0,0x0 +800001d0: 20840413 add s0,s0,520 # 800003d4 <_etext+0x74> +800001d4: 04100513 li a0,65 +800001d8: f49ff0ef jal 80000120 +800001dc: 00144503 lbu a0,1(s0) +800001e0: 00140413 add s0,s0,1 +800001e4: fe051ae3 bnez a0,800001d8 +800001e8: 00000417 auipc s0,0x0 +800001ec: 1f840413 add s0,s0,504 # 800003e0 <_etext+0x80> +800001f0: 04e00513 li a0,78 +800001f4: f2dff0ef jal 80000120 +800001f8: 00144503 lbu a0,1(s0) +800001fc: 00140413 add s0,s0,1 +80000200: fe051ae3 bnez a0,800001f4 +80000204: 00000417 auipc s0,0x0 +80000208: 28440413 add s0,s0,644 # 80000488 <_etext+0x128> +8000020c: 02000513 li a0,32 +80000210: f11ff0ef jal 80000120 +80000214: 00144503 lbu a0,1(s0) +80000218: 00140413 add s0,s0,1 +8000021c: fe051ae3 bnez a0,80000210 +80000220: 00100513 li a0,1 +80000224: f09ff0ef jal 8000012c + +80000228 : +80000228: ff010113 add sp,sp,-16 +8000022c: 00812423 sw s0,8(sp) +80000230: 00112623 sw ra,12(sp) +80000234: 00000417 auipc s0,0x0 +80000238: 1a040413 add s0,s0,416 # 800003d4 <_etext+0x74> +8000023c: 04100513 li a0,65 +80000240: ee1ff0ef jal 80000120 +80000244: 00144503 lbu a0,1(s0) +80000248: 00140413 add s0,s0,1 +8000024c: fe051ae3 bnez a0,80000240 +80000250: 00000417 auipc s0,0x0 +80000254: 19040413 add s0,s0,400 # 800003e0 <_etext+0x80> +80000258: 04e00513 li a0,78 +8000025c: ec5ff0ef jal 80000120 +80000260: 00144503 lbu a0,1(s0) +80000264: 00140413 add s0,s0,1 +80000268: fe051ae3 bnez a0,8000025c +8000026c: 00000417 auipc s0,0x0 +80000270: 26840413 add s0,s0,616 # 800004d4 <_etext+0x174> +80000274: 02000513 li a0,32 +80000278: ea9ff0ef jal 80000120 +8000027c: 00144503 lbu a0,1(s0) +80000280: 00140413 add s0,s0,1 +80000284: fe051ae3 bnez a0,80000278 +80000288: 00100513 li a0,1 +8000028c: ea1ff0ef jal 8000012c + +80000290 : +80000290: ff010113 add sp,sp,-16 +80000294: 00812423 sw s0,8(sp) +80000298: 00112623 sw ra,12(sp) +8000029c: 00000417 auipc s0,0x0 +800002a0: 13840413 add s0,s0,312 # 800003d4 <_etext+0x74> +800002a4: 04100513 li a0,65 +800002a8: e79ff0ef jal 80000120 +800002ac: 00144503 lbu a0,1(s0) +800002b0: 00140413 add s0,s0,1 +800002b4: fe051ae3 bnez a0,800002a8 +800002b8: 00000417 auipc s0,0x0 +800002bc: 12840413 add s0,s0,296 # 800003e0 <_etext+0x80> +800002c0: 04e00513 li a0,78 +800002c4: e5dff0ef jal 80000120 +800002c8: 00144503 lbu a0,1(s0) +800002cc: 00140413 add s0,s0,1 +800002d0: fe051ae3 bnez a0,800002c4 +800002d4: 00000417 auipc s0,0x0 +800002d8: 24c40413 add s0,s0,588 # 80000520 <_etext+0x1c0> +800002dc: 02000513 li a0,32 +800002e0: e41ff0ef jal 80000120 +800002e4: 00144503 lbu a0,1(s0) +800002e8: 00140413 add s0,s0,1 +800002ec: fe051ae3 bnez a0,800002e0 +800002f0: 00100513 li a0,1 +800002f4: e39ff0ef jal 8000012c + +800002f8 : +800002f8: ff010113 add sp,sp,-16 +800002fc: 00812423 sw s0,8(sp) +80000300: 00112623 sw ra,12(sp) +80000304: 00000417 auipc s0,0x0 +80000308: 0d040413 add s0,s0,208 # 800003d4 <_etext+0x74> +8000030c: 04100513 li a0,65 +80000310: e11ff0ef jal 80000120 +80000314: 00144503 lbu a0,1(s0) +80000318: 00140413 add s0,s0,1 +8000031c: fe051ae3 bnez a0,80000310 +80000320: 00000417 auipc s0,0x0 +80000324: 0c040413 add s0,s0,192 # 800003e0 <_etext+0x80> +80000328: 04e00513 li a0,78 +8000032c: df5ff0ef jal 80000120 +80000330: 00144503 lbu a0,1(s0) +80000334: 00140413 add s0,s0,1 +80000338: fe051ae3 bnez a0,8000032c +8000033c: 00000417 auipc s0,0x0 +80000340: 23040413 add s0,s0,560 # 8000056c <_etext+0x20c> +80000344: 02000513 li a0,32 +80000348: dd9ff0ef jal 80000120 +8000034c: 00144503 lbu a0,1(s0) +80000350: 00140413 add s0,s0,1 +80000354: fe051ae3 bnez a0,80000348 +80000358: 00100513 li a0,1 +8000035c: dd1ff0ef jal 8000012c diff --git a/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.bin new file mode 100755 index 0000000..8b3f6e8 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.elf new file mode 100755 index 0000000..a9c8b88 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.txt new file mode 100644 index 0000000..3e492a0 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.txt @@ -0,0 +1,95 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/sub-longlong-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 114000ef jal 80000120 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0f0000ef jal 80000114 + +80000028
: +80000028: fd010113 add sp,sp,-48 +8000002c: 01512a23 sw s5,20(sp) +80000030: 00000a97 auipc s5,0x0 +80000034: 318a8a93 add s5,s5,792 # 80000348 +80000038: 02912223 sw s1,36(sp) +8000003c: 03212023 sw s2,32(sp) +80000040: 01312e23 sw s3,28(sp) +80000044: 01412c23 sw s4,24(sp) +80000048: 01612823 sw s6,16(sp) +8000004c: 02112623 sw ra,44(sp) +80000050: 02812423 sw s0,40(sp) +80000054: 01712623 sw s7,12(sp) +80000058: 01812423 sw s8,8(sp) +8000005c: 01912223 sw s9,4(sp) +80000060: 00000a17 auipc s4,0x0 +80000064: 0e8a0a13 add s4,s4,232 # 80000148 +80000068: 000a8913 mv s2,s5 +8000006c: 00000993 li s3,0 +80000070: 00000497 auipc s1,0x0 +80000074: 31848493 add s1,s1,792 # 80000388 <_bss_start> +80000078: 04000b13 li s6,64 +8000007c: 00092c83 lw s9,0(s2) +80000080: 00492403 lw s0,4(s2) +80000084: 000a0c13 mv s8,s4 +80000088: 000a8b93 mv s7,s5 +8000008c: 000ba703 lw a4,0(s7) +80000090: 004ba783 lw a5,4(s7) +80000094: 004c2683 lw a3,4(s8) +80000098: 40ec8733 sub a4,s9,a4 +8000009c: 000c2503 lw a0,0(s8) +800000a0: 00ecb633 sltu a2,s9,a4 +800000a4: 40f407b3 sub a5,s0,a5 +800000a8: 40c787b3 sub a5,a5,a2 +800000ac: 00e54533 xor a0,a0,a4 +800000b0: 00f6c7b3 xor a5,a3,a5 +800000b4: 00f56533 or a0,a0,a5 +800000b8: 00153513 seqz a0,a0 +800000bc: 008b8b93 add s7,s7,8 +800000c0: f51ff0ef jal 80000010 +800000c4: 008c0c13 add s8,s8,8 +800000c8: fd7492e3 bne s1,s7,8000008c +800000cc: 00898993 add s3,s3,8 +800000d0: 00890913 add s2,s2,8 +800000d4: 040a0a13 add s4,s4,64 +800000d8: fb6992e3 bne s3,s6,8000007c +800000dc: 02c12083 lw ra,44(sp) +800000e0: 02812403 lw s0,40(sp) +800000e4: 02412483 lw s1,36(sp) +800000e8: 02012903 lw s2,32(sp) +800000ec: 01c12983 lw s3,28(sp) +800000f0: 01812a03 lw s4,24(sp) +800000f4: 01412a83 lw s5,20(sp) +800000f8: 01012b03 lw s6,16(sp) +800000fc: 00c12b83 lw s7,12(sp) +80000100: 00812c03 lw s8,8(sp) +80000104: 00412c83 lw s9,4(sp) +80000108: 00000513 li a0,0 +8000010c: 03010113 add sp,sp,48 +80000110: 00008067 ret + +80000114 : +80000114: 00050513 mv a0,a0 +80000118: 00100073 ebreak +8000011c: 0000006f j 8000011c + +80000120 <_trm_init>: +80000120: ff010113 add sp,sp,-16 +80000124: 00000517 auipc a0,0x0 +80000128: 01c50513 add a0,a0,28 # 80000140 <_etext> +8000012c: 00112623 sw ra,12(sp) +80000130: ef9ff0ef jal 80000028
+80000134: 00050513 mv a0,a0 +80000138: 00100073 ebreak +8000013c: 0000006f j 8000013c <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.bin new file mode 100755 index 0000000..0308d1f Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.elf new file mode 100755 index 0000000..eb1e2b1 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.txt new file mode 100644 index 0000000..122c55a --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.txt @@ -0,0 +1,56 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/sum-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 078000ef jal 80000084 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 054000ef jal 80000078 + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00112e23 sw ra,28(sp) +80000030: 00012623 sw zero,12(sp) +80000034: 00100793 li a5,1 +80000038: 06500693 li a3,101 +8000003c: 00c12703 lw a4,12(sp) +80000040: 00f70733 add a4,a4,a5 +80000044: 00e12623 sw a4,12(sp) +80000048: 00178793 add a5,a5,1 +8000004c: fed798e3 bne a5,a3,8000003c +80000050: 00c12503 lw a0,12(sp) +80000054: fffff7b7 lui a5,0xfffff +80000058: c4678793 add a5,a5,-954 # ffffec46 <_end+0x7fff5c46> +8000005c: 00f50533 add a0,a0,a5 +80000060: 00153513 seqz a0,a0 +80000064: fadff0ef jal 80000010 +80000068: 01c12083 lw ra,28(sp) +8000006c: 00000513 li a0,0 +80000070: 02010113 add sp,sp,32 +80000074: 00008067 ret + +80000078 : +80000078: 00050513 mv a0,a0 +8000007c: 00100073 ebreak +80000080: 0000006f j 80000080 + +80000084 <_trm_init>: +80000084: ff010113 add sp,sp,-16 +80000088: 00000517 auipc a0,0x0 +8000008c: 01c50513 add a0,a0,28 # 800000a4 <_etext> +80000090: 00112623 sw ra,12(sp) +80000094: f95ff0ef jal 80000028
+80000098: 00050513 mv a0,a0 +8000009c: 00100073 ebreak +800000a0: 0000006f j 800000a0 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.bin new file mode 100755 index 0000000..6523484 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.elf new file mode 100755 index 0000000..1c17fa6 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.txt new file mode 100644 index 0000000..9269ced --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.txt @@ -0,0 +1,75 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/switch-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0c4000ef jal 800000d0 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0a0000ef jal 800000c4 + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00812c23 sw s0,24(sp) +80000030: 00912a23 sw s1,20(sp) +80000034: 01212823 sw s2,16(sp) +80000038: 01312623 sw s3,12(sp) +8000003c: 01412423 sw s4,8(sp) +80000040: 00112e23 sw ra,28(sp) +80000044: 00000417 auipc s0,0x0 +80000048: 0e440413 add s0,s0,228 # 80000128 +8000004c: 00000917 auipc s2,0x0 +80000050: 0a090913 add s2,s2,160 # 800000ec <_trm_init+0x1c> +80000054: 00000997 auipc s3,0x0 +80000058: 11098993 add s3,s3,272 # 80000164 <_bss_start> +8000005c: fff00493 li s1,-1 +80000060: fff00793 li a5,-1 +80000064: 00c00a13 li s4,12 +80000068: 00042503 lw a0,0(s0) +8000006c: 00440413 add s0,s0,4 +80000070: 00148493 add s1,s1,1 +80000074: 40f50533 sub a0,a0,a5 +80000078: 00153513 seqz a0,a0 +8000007c: f95ff0ef jal 80000010 +80000080: 00490913 add s2,s2,4 +80000084: 01340a63 beq s0,s3,80000098 +80000088: fff00793 li a5,-1 +8000008c: fc9a6ee3 bltu s4,s1,80000068 +80000090: 00092783 lw a5,0(s2) +80000094: fd5ff06f j 80000068 +80000098: 00100513 li a0,1 +8000009c: f75ff0ef jal 80000010 +800000a0: 01c12083 lw ra,28(sp) +800000a4: 01812403 lw s0,24(sp) +800000a8: 01412483 lw s1,20(sp) +800000ac: 01012903 lw s2,16(sp) +800000b0: 00c12983 lw s3,12(sp) +800000b4: 00812a03 lw s4,8(sp) +800000b8: 00000513 li a0,0 +800000bc: 02010113 add sp,sp,32 +800000c0: 00008067 ret + +800000c4 : +800000c4: 00050513 mv a0,a0 +800000c8: 00100073 ebreak +800000cc: 0000006f j 800000cc + +800000d0 <_trm_init>: +800000d0: ff010113 add sp,sp,-16 +800000d4: 00000517 auipc a0,0x0 +800000d8: 05050513 add a0,a0,80 # 80000124 +800000dc: 00112623 sw ra,12(sp) +800000e0: f49ff0ef jal 80000028
+800000e4: 00050513 mv a0,a0 +800000e8: 00100073 ebreak +800000ec: 0000006f j 800000ec <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.bin new file mode 100755 index 0000000..4f77e96 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.elf new file mode 100755 index 0000000..915e282 Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.txt new file mode 100644 index 0000000..3a5db06 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.txt @@ -0,0 +1,80 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/to-lower-case-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0d8000ef jal 800000e4 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0b4000ef jal 800000d8 + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00812c23 sw s0,24(sp) +80000030: 00912a23 sw s1,20(sp) +80000034: 01212823 sw s2,16(sp) +80000038: 01312623 sw s3,12(sp) +8000003c: 00112e23 sw ra,28(sp) +80000040: 00000413 li s0,0 +80000044: 00000497 auipc s1,0x0 +80000048: 0c448493 add s1,s1,196 # 80000108 +8000004c: 01900913 li s2,25 +80000050: 08000993 li s3,128 +80000054: 0ff47713 zext.b a4,s0 +80000058: fbf70793 add a5,a4,-65 +8000005c: 02070513 add a0,a4,32 +80000060: 0ff7f793 zext.b a5,a5 +80000064: 008486b3 add a3,s1,s0 +80000068: 0ff57513 zext.b a0,a0 +8000006c: 02f96a63 bltu s2,a5,800000a0 +80000070: 0006c783 lbu a5,0(a3) +80000074: 00140413 add s0,s0,1 +80000078: 40f50533 sub a0,a0,a5 +8000007c: 00153513 seqz a0,a0 +80000080: f91ff0ef jal 80000010 +80000084: 0ff47713 zext.b a4,s0 +80000088: fbf70793 add a5,a4,-65 +8000008c: 02070513 add a0,a4,32 +80000090: 0ff7f793 zext.b a5,a5 +80000094: 008486b3 add a3,s1,s0 +80000098: 0ff57513 zext.b a0,a0 +8000009c: fcf97ae3 bgeu s2,a5,80000070 +800000a0: 0006c503 lbu a0,0(a3) +800000a4: 00140413 add s0,s0,1 +800000a8: 40e50533 sub a0,a0,a4 +800000ac: 00153513 seqz a0,a0 +800000b0: f61ff0ef jal 80000010 +800000b4: fb3410e3 bne s0,s3,80000054 +800000b8: 01c12083 lw ra,28(sp) +800000bc: 01812403 lw s0,24(sp) +800000c0: 01412483 lw s1,20(sp) +800000c4: 01012903 lw s2,16(sp) +800000c8: 00c12983 lw s3,12(sp) +800000cc: 00000513 li a0,0 +800000d0: 02010113 add sp,sp,32 +800000d4: 00008067 ret + +800000d8 : +800000d8: 00050513 mv a0,a0 +800000dc: 00100073 ebreak +800000e0: 0000006f j 800000e0 + +800000e4 <_trm_init>: +800000e4: ff010113 add sp,sp,-16 +800000e8: 00000517 auipc a0,0x0 +800000ec: 01c50513 add a0,a0,28 # 80000104 <_etext> +800000f0: 00112623 sw ra,12(sp) +800000f4: f35ff0ef jal 80000028
+800000f8: 00050513 mv a0,a0 +800000fc: 00100073 ebreak +80000100: 0000006f j 80000100 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.bin new file mode 100755 index 0000000..9a0ef7c Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.elf new file mode 100755 index 0000000..94a176a Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.txt new file mode 100644 index 0000000..e78cbba --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.txt @@ -0,0 +1,98 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/unalign-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 120000ef jal 8000012c <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0fc000ef jal 80000120 + +80000028
: +80000028: fd010113 add sp,sp,-48 +8000002c: 02912223 sw s1,36(sp) +80000030: 554434b7 lui s1,0x55443 +80000034: 02812423 sw s0,40(sp) +80000038: 03212023 sw s2,32(sp) +8000003c: 01312e23 sw s3,28(sp) +80000040: 01412c23 sw s4,24(sp) +80000044: 01512a23 sw s5,20(sp) +80000048: 01612823 sw s6,16(sp) +8000004c: 01712623 sw s7,12(sp) +80000050: 02112623 sw ra,44(sp) +80000054: 00400b13 li s6,4 +80000058: 00000417 auipc s0,0x0 +8000005c: 0fc40413 add s0,s0,252 # 80000154 +80000060: 00000b97 auipc s7,0x0 +80000064: 0f0b8b93 add s7,s7,240 # 80000150 +80000068: fdd00a93 li s5,-35 +8000006c: fcc00a13 li s4,-52 +80000070: fbb00993 li s3,-69 +80000074: faa00913 li s2,-86 +80000078: 32348493 add s1,s1,803 # 55443323 <_entry_offset+0x55443323> +8000007c: 00344783 lbu a5,3(s0) +80000080: 015401a3 sb s5,3(s0) +80000084: 00444783 lbu a5,4(s0) +80000088: 01440223 sb s4,4(s0) +8000008c: 00544783 lbu a5,5(s0) +80000090: 013402a3 sb s3,5(s0) +80000094: 00644783 lbu a5,6(s0) +80000098: 01240323 sb s2,6(s0) +8000009c: 00344603 lbu a2,3(s0) +800000a0: 00444683 lbu a3,4(s0) +800000a4: 00544703 lbu a4,5(s0) +800000a8: 00644783 lbu a5,6(s0) +800000ac: 00869693 sll a3,a3,0x8 +800000b0: 00c6e6b3 or a3,a3,a2 +800000b4: 01071713 sll a4,a4,0x10 +800000b8: 00d76733 or a4,a4,a3 +800000bc: 01879793 sll a5,a5,0x18 +800000c0: 00e7e7b3 or a5,a5,a4 +800000c4: 00fba023 sw a5,0(s7) +800000c8: 000ba503 lw a0,0(s7) +800000cc: fffb0b13 add s6,s6,-1 +800000d0: 00950533 add a0,a0,s1 +800000d4: 00153513 seqz a0,a0 +800000d8: f39ff0ef jal 80000010 +800000dc: 00000797 auipc a5,0x0 +800000e0: 06078ca3 sb zero,121(a5) # 80000155 +800000e4: 00000797 auipc a5,0x0 +800000e8: 06078823 sb zero,112(a5) # 80000154 +800000ec: f80b18e3 bnez s6,8000007c +800000f0: 02c12083 lw ra,44(sp) +800000f4: 02812403 lw s0,40(sp) +800000f8: 02412483 lw s1,36(sp) +800000fc: 02012903 lw s2,32(sp) +80000100: 01c12983 lw s3,28(sp) +80000104: 01812a03 lw s4,24(sp) +80000108: 01412a83 lw s5,20(sp) +8000010c: 01012b03 lw s6,16(sp) +80000110: 00c12b83 lw s7,12(sp) +80000114: 00000513 li a0,0 +80000118: 03010113 add sp,sp,48 +8000011c: 00008067 ret + +80000120 : +80000120: 00050513 mv a0,a0 +80000124: 00100073 ebreak +80000128: 0000006f j 80000128 + +8000012c <_trm_init>: +8000012c: ff010113 add sp,sp,-16 +80000130: 00000517 auipc a0,0x0 +80000134: 01c50513 add a0,a0,28 # 8000014c <_etext> +80000138: 00112623 sw ra,12(sp) +8000013c: eedff0ef jal 80000028
+80000140: 00050513 mv a0,a0 +80000144: 00100073 ebreak +80000148: 0000006f j 80000148 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.bin b/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.bin new file mode 100755 index 0000000..8e0d49a Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.bin differ diff --git a/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.elf b/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.elf new file mode 100755 index 0000000..630e75c Binary files /dev/null and b/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.elf differ diff --git a/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.txt b/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.txt new file mode 100644 index 0000000..cf03059 --- /dev/null +++ b/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.txt @@ -0,0 +1,76 @@ + +/home/xin/repo/ysyx-workbench/am-kernels/tests/cpu-tests/build/wanshu-riscv32-nemu.elf: file format elf32-littleriscv + + +Disassembly of section .text: + +80000000 <_start>: +80000000: 00000413 li s0,0 +80000004: 00009117 auipc sp,0x9 +80000008: ffc10113 add sp,sp,-4 # 80009000 <_end> +8000000c: 0c8000ef jal 800000d4 <_trm_init> + +80000010 : +80000010: 00050463 beqz a0,80000018 +80000014: 00008067 ret +80000018: ff010113 add sp,sp,-16 +8000001c: 00100513 li a0,1 +80000020: 00112623 sw ra,12(sp) +80000024: 0a4000ef jal 800000c8 + +80000028
: +80000028: fe010113 add sp,sp,-32 +8000002c: 00812c23 sw s0,24(sp) +80000030: 00912a23 sw s1,20(sp) +80000034: 01212823 sw s2,16(sp) +80000038: 01312623 sw s3,12(sp) +8000003c: 00112e23 sw ra,28(sp) +80000040: 00000913 li s2,0 +80000044: 00200413 li s0,2 +80000048: 00000997 auipc s3,0x0 +8000004c: 0b098993 add s3,s3,176 # 800000f8 +80000050: 01e00493 li s1,30 +80000054: 00100793 li a5,1 +80000058: 00000693 li a3,0 +8000005c: 02f46733 rem a4,s0,a5 +80000060: 00071463 bnez a4,80000068 +80000064: 00f686b3 add a3,a3,a5 +80000068: 00178793 add a5,a5,1 +8000006c: fef418e3 bne s0,a5,8000005c +80000070: 02d40c63 beq s0,a3,800000a8 +80000074: 00140413 add s0,s0,1 +80000078: fc941ee3 bne s0,s1,80000054 +8000007c: ffe90513 add a0,s2,-2 +80000080: 00153513 seqz a0,a0 +80000084: f8dff0ef jal 80000010 +80000088: 01c12083 lw ra,28(sp) +8000008c: 01812403 lw s0,24(sp) +80000090: 01412483 lw s1,20(sp) +80000094: 01012903 lw s2,16(sp) +80000098: 00c12983 lw s3,12(sp) +8000009c: 00000513 li a0,0 +800000a0: 02010113 add sp,sp,32 +800000a4: 00008067 ret +800000a8: 00291793 sll a5,s2,0x2 +800000ac: 00f987b3 add a5,s3,a5 +800000b0: 0007a503 lw a0,0(a5) +800000b4: 00190913 add s2,s2,1 +800000b8: 40850533 sub a0,a0,s0 +800000bc: 00153513 seqz a0,a0 +800000c0: f51ff0ef jal 80000010 +800000c4: fb1ff06f j 80000074 + +800000c8 : +800000c8: 00050513 mv a0,a0 +800000cc: 00100073 ebreak +800000d0: 0000006f j 800000d0 + +800000d4 <_trm_init>: +800000d4: ff010113 add sp,sp,-16 +800000d8: 00000517 auipc a0,0x0 +800000dc: 01c50513 add a0,a0,28 # 800000f4 <_etext> +800000e0: 00112623 sw ra,12(sp) +800000e4: f45ff0ef jal 80000028
+800000e8: 00050513 mv a0,a0 +800000ec: 00100073 ebreak +800000f0: 0000006f j 800000f0 <_trm_init+0x1c> diff --git a/am-kernels/tests/cpu-tests/include/trap.h b/am-kernels/tests/cpu-tests/include/trap.h new file mode 100644 index 0000000..e1036aa --- /dev/null +++ b/am-kernels/tests/cpu-tests/include/trap.h @@ -0,0 +1,13 @@ +#ifndef __TRAP_H__ +#define __TRAP_H__ + +#include +#include +#include + +__attribute__((noinline)) +void check(bool cond) { + if (!cond) halt(1); +} + +#endif diff --git a/am-kernels/tests/cpu-tests/tests/CMakeLists.txt b/am-kernels/tests/cpu-tests/tests/CMakeLists.txt new file mode 100644 index 0000000..3e1bb7a --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/CMakeLists.txt @@ -0,0 +1,53 @@ +find_package(am-${ARCH}) +find_package(klib) + +set(SOURCES + add.c + add-longlong.c + bit.c + bubble-sort.c + crc32.c + div.c + dummy.c + fact.c + fib.c + goldbach.c + hello-str.c + if-else.c + leap-year.c + load-store.c + matrix-mul.c + max.c + mersenne.c + min3.c + mov-c.c + movsx.c + mul-longlong.c + pascal.c + prime.c + quick-sort.c + recursion.c + select-sort.c + shift.c + shuixianhua.c + string.c + sub-longlong.c + sum.c + switch.c + to-lower-case.c + unalign.c + wanshu.c) + +foreach(SOURCE IN LISTS SOURCES) + get_filename_component(SOURCE_NAME ${SOURCE} NAME_WLE) + add_executable(${SOURCE_NAME} + ${SOURCE}) + target_link_libraries(${SOURCE_NAME} PRIVATE am-${ARCH}) + + # -- Extract binary file from ELF + add_custom_command(TARGET ${SOURCE_NAME} + COMMAND ${CMAKE_OBJCOPY} ARGS -S --set-section-flags .bss=alloc,contents -O binary ${SOURCE_NAME} ${SOURCE_NAME}.bin) + + install(TARGETS ${SOURCE_NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_DATADIR}/elf) + install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${SOURCE_NAME}.bin DESTINATION ${CMAKE_INSTALL_DATADIR}/binary) +endforeach() diff --git a/am-kernels/tests/cpu-tests/tests/add-longlong.c b/am-kernels/tests/cpu-tests/tests/add-longlong.c new file mode 100644 index 0000000..f41e82c --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/add-longlong.c @@ -0,0 +1,22 @@ +#include "trap.h" + +long long add(long long a, long long b) { + long long c = a + b; + return c; +} + +long long test_data[] = {0, 1, 2, 0x7fffffffffffffffLL, 0x8000000000000000LL, 0x8000000000000001LL, 0xfffffffffffffffeLL, 0xffffffffffffffffLL}; +long long ans[] = {0LL, 0x1LL, 0x2LL, 0x7fffffffffffffffLL, 0x8000000000000000LL, 0x8000000000000001LL, 0xfffffffffffffffeLL, 0xffffffffffffffffLL, 0x1LL, 0x2LL, 0x3LL, 0x8000000000000000LL, 0x8000000000000001LL, 0x8000000000000002LL, 0xffffffffffffffffLL, 0LL, 0x2LL, 0x3LL, 0x4LL, 0x8000000000000001LL, 0x8000000000000002LL, 0x8000000000000003LL, 0LL, 0x1LL, 0x7fffffffffffffffLL, 0x8000000000000000LL, 0x8000000000000001LL, 0xfffffffffffffffeLL, 0xffffffffffffffffLL, 0LL, 0x7ffffffffffffffdLL, 0x7ffffffffffffffeLL, 0x8000000000000000LL, 0x8000000000000001LL, 0x8000000000000002LL, 0xffffffffffffffffLL, 0LL, 0x1LL, 0x7ffffffffffffffeLL, 0x7fffffffffffffffLL, 0x8000000000000001LL, 0x8000000000000002LL, 0x8000000000000003LL, 0LL, 0x1LL, 0x2LL, 0x7fffffffffffffffLL, 0x8000000000000000LL, 0xfffffffffffffffeLL, 0xffffffffffffffffLL, 0LL, 0x7ffffffffffffffdLL, 0x7ffffffffffffffeLL, 0x7fffffffffffffffLL, 0xfffffffffffffffcLL, 0xfffffffffffffffdLL, 0xffffffffffffffffLL, 0LL, 0x1LL, 0x7ffffffffffffffeLL, 0x7fffffffffffffffLL, 0x8000000000000000LL, 0xfffffffffffffffdLL, 0xfffffffffffffffeLL}; + +#define NR_DATA LENGTH(test_data) + +int main() { + int i, j, ans_idx = 0; + for(i = 0; i < NR_DATA; i ++) { + for(j = 0; j < NR_DATA; j ++) { + check(add(test_data[i], test_data[j]) == ans[ans_idx ++]); + } + } + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/add.c b/am-kernels/tests/cpu-tests/tests/add.c new file mode 100644 index 0000000..493490c --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/add.c @@ -0,0 +1,25 @@ +#include "trap.h" + +int add(int a, int b) { + int c = a + b; + return c; +} + +int test_data[] = {0, 1, 2, 0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff}; +int ans[] = {0, 0x1, 0x2, 0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff, 0x1, 0x2, 0x3, 0x80000000, 0x80000001, 0x80000002, 0xffffffff, 0, 0x2, 0x3, 0x4, 0x80000001, 0x80000002, 0x80000003, 0, 0x1, 0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff, 0, 0x7ffffffd, 0x7ffffffe, 0x80000000, 0x80000001, 0x80000002, 0xffffffff, 0, 0x1, 0x7ffffffe, 0x7fffffff, 0x80000001, 0x80000002, 0x80000003, 0, 0x1, 0x2, 0x7fffffff, 0x80000000, 0xfffffffe, 0xffffffff, 0, 0x7ffffffd, 0x7ffffffe, 0x7fffffff, 0xfffffffc, 0xfffffffd, 0xffffffff, 0, 0x1, 0x7ffffffe, 0x7fffffff, 0x80000000, 0xfffffffd, 0xfffffffe}; + +#define NR_DATA LENGTH(test_data) + +int main() { + int i, j, ans_idx = 0; + for(i = 0; i < NR_DATA; i ++) { + for(j = 0; j < NR_DATA; j ++) { + check(add(test_data[i], test_data[j]) == ans[ans_idx ++]); + } + check(j == NR_DATA); + } + + check(i == NR_DATA); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/bit.c b/am-kernels/tests/cpu-tests/tests/bit.c new file mode 100644 index 0000000..e186e59 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/bit.c @@ -0,0 +1,46 @@ +#include "trap.h" + +typedef unsigned char uint8_t; +__attribute__((noinline)) +bool getbit(void *buf, int offset){ + int byte = offset >> 3; + offset &= 7; + uint8_t mask = 1 << offset; + return (((uint8_t *)buf)[byte] & mask) != 0; +} +__attribute__((noinline)) +void setbit(void *buf, int offset, bool bit){ + int byte = offset >> 3; + offset &= 7; + uint8_t mask = 1 << offset; + + uint8_t * volatile p = buf + byte; + *p = (bit == 0 ? (*p & ~mask) : (*p | mask)); +} + +int main() { + uint8_t buf[2]; + + buf[0] = 0xaa; + buf[1] = 0x0; + check(getbit(buf, 0) == 0); + check(getbit(buf, 1) == 1); + check(getbit(buf, 2) == 0); + check(getbit(buf, 3) == 1); + check(getbit(buf, 4) == 0); + check(getbit(buf, 5) == 1); + check(getbit(buf, 6) == 0); + check(getbit(buf, 7) == 1); + + setbit(buf, 8, 1); + setbit(buf, 9, 0); + setbit(buf, 10, 1); + setbit(buf, 11, 0); + setbit(buf, 12, 1); + setbit(buf, 13, 0); + setbit(buf, 14, 1); + setbit(buf, 15, 0); + check(buf[1] == 0x55); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/bubble-sort.c b/am-kernels/tests/cpu-tests/tests/bubble-sort.c new file mode 100644 index 0000000..7685be5 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/bubble-sort.c @@ -0,0 +1,39 @@ +#include "trap.h" + +#define N 20 + +int a[N] = {2, 12, 14, 6, 13, 15, 16, 10, 0, 18, 11, 19, 9, 1, 7, 5, 4, 3, 8, 17}; + +void bubble_sort() { + int i, j, t; + for(j = 0; j < N; j ++) { + for(i = 0; i < N - 1 - j; i ++) { + if(a[i] > a[i + 1]) { + t = a[i]; + a[i] = a[i + 1]; + a[i + 1] = t; + } + } + } +} + +int main() { + bubble_sort(); + + int i; + for(i = 0; i < N; i ++) { + check(a[i] == i); + } + + check(i == N); + + bubble_sort(); + + for(i = 0; i < N; i ++) { + check(a[i] == i); + } + + check(i == N); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/crc32.c b/am-kernels/tests/cpu-tests/tests/crc32.c new file mode 100644 index 0000000..3f694c5 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/crc32.c @@ -0,0 +1,47 @@ +/* from http://rosettacode.org/wiki/CRC-32#C */ + +#include +#include "trap.h" + +#define STR "The quick brown fox jumps over the lazy dog" +#define STRLEN (sizeof(STR) - 1) + +uint32_t rc_crc32(uint32_t crc, const char *buf, size_t len) { + static uint32_t table[256]; + static int have_table = 0; + uint32_t rem; + uint8_t octet; + int i, j; + const char *p, *q; + + /* This check is not thread safe; there is no mutex. */ + if (have_table == 0) { + /* Calculate CRC table. */ + for (i = 0; i < 256; i++) { + rem = i; /* remainder from polynomial division */ + for (j = 0; j < 8; j++) { + if (rem & 1) { + rem >>= 1; + rem ^= 0xedb88320; + } else + rem >>= 1; + } + table[i] = rem; + } + have_table = 1; + } + + crc = ~crc; + q = buf + len; + for (p = buf; p < q; p++) { + octet = *p; /* Cast to unsigned octet. */ + crc = (crc >> 8) ^ table[(crc & 0xff) ^ octet]; + } + return ~crc; +} + +int main() { + uint32_t res = rc_crc32(0, STR, STRLEN); + check(res == 0x414FA339); + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/div.c b/am-kernels/tests/cpu-tests/tests/div.c new file mode 100644 index 0000000..9e256ef --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/div.c @@ -0,0 +1,21 @@ +#include "trap.h" + +#define N 10 +int a[N]; + +int main() { + int i, j; + for(i = 0; i < N; i ++) + a[i] = i; + for(i = 0; i < N; i ++) + for(j = 1; j < N + 1; j ++) + a[i] *= j; + for(i = 0; i < N; i ++) + for(j = 1; j < N + 1; j ++) + a[i] /= j; + + for(i = 0; i < N; i ++) + check(a[i] == i); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/dummy.c b/am-kernels/tests/cpu-tests/tests/dummy.c new file mode 100644 index 0000000..4cce7f6 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/dummy.c @@ -0,0 +1,3 @@ +int main() { + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/fact.c b/am-kernels/tests/cpu-tests/tests/fact.c new file mode 100644 index 0000000..db06460 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/fact.c @@ -0,0 +1,20 @@ +#include "trap.h" + +int f[15]; +int ans[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600}; + +int fact(int n) { + if(n == 0 || n == 1) return 1; + else return fact(n - 1) * n; +} + +int main() { + int i; + for(i = 0; i < 13; i ++) { + f[i] = fact(i); + check(f[i] == ans[i]); + } + + return 0; +} + diff --git a/am-kernels/tests/cpu-tests/tests/fib.c b/am-kernels/tests/cpu-tests/tests/fib.c new file mode 100644 index 0000000..75f1a31 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/fib.c @@ -0,0 +1,16 @@ +#include "trap.h" + +int fib[40] = {1, 1}; +int ans[] = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155}; + +int main() { + int i; + for(i = 2; i < 40; i ++) { + fib[i] = fib[i - 1] + fib[i - 2]; + check(fib[i] == ans[i]); + } + + check(i == 40); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/goldbach.c b/am-kernels/tests/cpu-tests/tests/goldbach.c new file mode 100644 index 0000000..c7f0d2e --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/goldbach.c @@ -0,0 +1,34 @@ +#include "trap.h" + +int is_prime(int n) { + if(n < 2) return 0; + + int i; + for(i = 2; i < n; i ++) { + if(n % i == 0) { + return 0; + } + } + + return 1; +} + +int goldbach(int n) { + int i; + for(i = 2; i < n; i ++) { + if(is_prime(i) && is_prime(n - i)) { + return 1; + } + } + + return 0; +} + +int main() { + int n; + for(n = 4; n <= 30; n += 2) { + check(goldbach(n) == 1); + } + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/hello-str.c b/am-kernels/tests/cpu-tests/tests/hello-str.c new file mode 100644 index 0000000..90e5b1a --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/hello-str.c @@ -0,0 +1,16 @@ +#include "trap.h" + +char buf[128]; + +int main() { + sprintf(buf, "%s", "Hello world!\n"); + check(strcmp(buf, "Hello world!\n") == 0); + + sprintf(buf, "%d + %d = %d\n", 1, 1, 2); + check(strcmp(buf, "1 + 1 = 2\n") == 0); + + sprintf(buf, "%d + %d = %d\n", 2, 10, 12); + check(strcmp(buf, "2 + 10 = 12\n") == 0); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/if-else.c b/am-kernels/tests/cpu-tests/tests/if-else.c new file mode 100644 index 0000000..e91fad4 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/if-else.c @@ -0,0 +1,28 @@ +#include "trap.h" + +int if_else(int n) { + int cost; + if(n > 500) cost = 150; + else if(n > 300) cost = 100; + else if(n > 100) cost = 75; + else if(n > 50) cost = 50; + else cost = 0; + + return cost; +} + +int test_data[] = {-1, 0, 49, 50, 51, 99, 100, 101, 299, 300, 301, 499, 500, 501}; +int ans[] = {0, 0, 0, 0, 50, 50, 50, 75, 75, 75, 100, 100, 100, 150}; + +#define NR_DATA LENGTH(test_data) + +int main() { + int i, ans_idx = 0; + for(i = 0; i < NR_DATA; i ++) { + check(if_else(test_data[i]) == ans[ans_idx ++]); + } + + check(i == NR_DATA); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/leap-year.c b/am-kernels/tests/cpu-tests/tests/leap-year.c new file mode 100644 index 0000000..7a1aa49 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/leap-year.c @@ -0,0 +1,16 @@ +#include "trap.h" + +int is_leap_year(int n) { + return (n % 4 == 0 && n % 100 != 0) || (n % 400 == 0); +} + +int ans[] = {0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0}; + +int main() { + int i; + for(i = 0; i < 125; i ++) { + check(is_leap_year(i + 1890) == ans[i]); + } + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/load-store.c b/am-kernels/tests/cpu-tests/tests/load-store.c new file mode 100644 index 0000000..343a9bc --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/load-store.c @@ -0,0 +1,45 @@ +#include "trap.h" + +unsigned short mem[] = { + 0x0, 0x0258, 0x4abc, 0x7fff, 0x8000, 0x8100, 0xabcd, 0xffff +}; + +unsigned lh_ans[] = { + 0x00000000, 0x00000258, 0x00004abc, 0x00007fff, 0xffff8000, 0xffff8100, 0xffffabcd, 0xffffffff +}; + +unsigned lhu_ans[] = { + 0x00000000, 0x00000258, 0x00004abc, 0x00007fff, 0x00008000, 0x00008100, 0x0000abcd, 0x0000ffff +}; + +unsigned sh_ans[] = { + 0x0000fffd, 0x0000fff7, 0x0000ffdf, 0x0000ff7f, 0x0000fdff, 0x0000f7ff, 0x0000dfff, 0x00007fff +}; + +unsigned lwlr_ans[] = { + 0xbc025800, 0x7fff4a, 0xcd810080, 0xffffab +}; + +int main() { + unsigned i; + + for(i = 0; i < LENGTH(mem); i ++) { + check((short)mem[i] == lh_ans[i]); + } + + for(i = 0; i < LENGTH(mem); i ++) { + check(mem[i] == lhu_ans[i]); + } + + for(i = 0; i < ((LENGTH(mem) / 2) - 1); i ++) { + unsigned x = ((unsigned*)((void*)mem + 1))[i]; + check(x == lwlr_ans[i]); + } + + for(i = 0; i < LENGTH(mem); i ++) { + mem[i] = ~(1 << (2 * i + 1)); + check(mem[i] == sh_ans[i]); + } + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/matrix-mul.c b/am-kernels/tests/cpu-tests/tests/matrix-mul.c new file mode 100644 index 0000000..723ac47 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/matrix-mul.c @@ -0,0 +1,60 @@ +#include "trap.h" + +#define N 10 +int a[N][N] = { +{31, -73, -67, -28, 87, -17, -15, -35, -53, -54}, +{52, 36, 9, -91, -27, -78, 42, 82, 19, -6}, +{41, -56, 31, 32, -52, 74, 28, 20, 55, -72}, +{-59, 2, -79, -8, 44, 55, -83, -95, -45, 50}, +{-95, 61, -63, 62, -16, 52, 40, 92, -32, -26}, +{-99, 52, 96, 63, -75, -74, -82, 82, -95, 42}, +{11, -22, 27, -27, -27, -76, -71, 58, -40, -65}, +{91, -53, -67, 72, 36, -77, -3, 93, -24, 97}, +{-52, -11, -77, -93, -92, -24, 70, 18, 56, 88}, +{-43, -41, -26, 11, -84, -14, -41, 83, 27, -11} +}; +int b[N][N] = { + {-48, -70, -40, -82, -74, -63, -59, -72, -100, -72}, +{5, -84, 28, 56, 60, -33, -42, -50, -83, -83}, +{-5, 5, 48, 75, -78, -9, 9, 2, 88, 70}, +{69, 23, 66, 66, -11, 50, 67, 18, -58, 76}, +{30, 45, 32, 25, -73, 57, -67, -14, 53, -33}, +{98, -86, -63, 80, -45, -88, 80, -64, 58, -84}, +{-55, -39, -13, -27, -37, 8, -96, 84, -89, 31}, +{-82, 58, 81, -41, -58, 36, 76, -79, -29, 23}, +{86, -46, 16, -18, 81, 90, 35, -90, 43, 55}, +{-38, -19, -40, 82, -76, 57, -29, -2, 79, -48}, +}; + +int ans[N][N] = { + {-1317, 10379, -5821, -14322, -4330, -3114, -9940, 7033, -1883, -6027}, + {-24266, -861, 4044, -19824, -223, 886, -11988, -6442, -13846, -1054}, + {9783, -7073, -918, -5911, -967, -7100, 14605, -7556, -3439, 9607}, + {15980, -520, -13297, 15043, 6185, -3654, 1325, 4193, 16925, -17761}, + {2566, 3187, 10248, 7925, 6318, 1421, 14648, 700, -12193, 1083}, + {-12603, 19006, 20952, 18599, -1539, 5184, 17408, 6740, 6264, 15114}, + {-12715, 15121, 9963, -13717, 2411, -2196, 6147, -1698, -3389, 8200}, + {-19007, 12417, 5723, -11309, -19242, 15740, -3791, -3949, -13130, -21}, + {-12557, -5970, -11570, -8905, 12227, 7814, -5094, 4532, 1071, -1309}, + {-2955, 9381, 6372, -6898, 9117, 5753, 20778, -5045, 1047, 12114}}; + +int c[N][N]; + +int main() { + int i, j, k; + for(i = 0; i < N; i ++) { + for(j = 0; j < N; j ++) { + c[i][j] = 0; + for(k = 0; k < N; k ++) { + c[i][j] += a[i][k] * b[k][j]; + } + check(c[i][j] == ans[i][j]); + check(k == N); + } + check(j == N); + } + + check(i == N); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/max.c b/am-kernels/tests/cpu-tests/tests/max.c new file mode 100644 index 0000000..893c4d8 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/max.c @@ -0,0 +1,27 @@ +#include "trap.h" + +int max(int x, int y) { + int z; + if(x > y) { z = x; } + else { z = y; } + return z; +} + +int test_data[] = {0, 1, 2, 0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff}; +int ans[] = {0, 0x1, 0x2, 0x7fffffff, 0, 0, 0, 0, 0x1, 0x1, 0x2, 0x7fffffff, 0x1, 0x1, 0x1, 0x1, 0x2, 0x2, 0x2, 0x7fffffff, 0x2, 0x2, 0x2, 0x2, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0x7fffffff, 0, 0x1, 0x2, 0x7fffffff, 0x80000000, 0x80000001, 0xfffffffe, 0xffffffff, 0, 0x1, 0x2, 0x7fffffff, 0x80000001, 0x80000001, 0xfffffffe, 0xffffffff, 0, 0x1, 0x2, 0x7fffffff, 0xfffffffe, 0xfffffffe, 0xfffffffe, 0xffffffff, 0, 0x1, 0x2, 0x7fffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff}; + +#define NR_DATA LENGTH(test_data) + +int main() { + int i, j, ans_idx = 0; + for(i = 0; i < NR_DATA; i ++) { + for(j = 0; j < NR_DATA; j ++) { + check(max(test_data[i], test_data[j]) == ans[ans_idx ++]); + } + check(j == NR_DATA); + } + + check(i == NR_DATA); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/mersenne.c b/am-kernels/tests/cpu-tests/tests/mersenne.c new file mode 100644 index 0000000..8eab567 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/mersenne.c @@ -0,0 +1,34 @@ +/* adapted from http://rosettacode.org/wiki/Factors_of_a_Mersenne_number#C */ +#include "trap.h" + +int isPrime(int n) { + int d = 5; + if (n % 2 == 0) return n==2; + if (n % 3 == 0) return n==3; + while (d * d <= n) { + if (n % d == 0) return 0; + d += 2; + if (n % d == 0) return 0; + d += 4; + } + return 1; +} + +int main() { + int i, d, p, r, q = 929; + if (!isPrime(q)) return 1; + r = q; + while (r > 0) r <<= 1; + d = 2 * q + 1; + do { + for (p = r, i = 1; p; p <<= 1) { + i = ((long long)i * i) % d; + if (p < 0) i *= 2; + if (i > d) i -= d; + } + if (i != 1) d += 2 * q; + else break; + } while(1); + check(d == 13007); + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/min3.c b/am-kernels/tests/cpu-tests/tests/min3.c new file mode 100644 index 0000000..e8aa7c6 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/min3.c @@ -0,0 +1,31 @@ +#include "trap.h" + +int min3(int x, int y, int z) { + int m; + if(x < y) { m = x; } + else { m = y; } + if(z < m) m = z; + return m; +} + +int test_data[] = {0, 0x7fffffff, 0x80000000, 0xffffffff}; +int ans [] = {0, 0, -2147483648, -1, 0, 0, -2147483648, -1, -2147483648, -2147483648, -2147483648, -2147483648, -1, -1, -2147483648, -1, 0, 0, -2147483648, -1, 0, 2147483647, -2147483648, -1, -2147483648, -2147483648, -2147483648, -2147483648, -1, -1, -2147483648, -1, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -2147483648, -1, -1, -2147483648, -1, -1, -1, -2147483648, -1, -2147483648, -2147483648, -2147483648, -2147483648, -1, -1, -2147483648, -1}; + +#define NR_DATA LENGTH(test_data) + +int main() { + int i, j, k, ans_idx = 0; + for(i = 0; i < NR_DATA; i ++) { + for(j = 0; j < NR_DATA; j ++) { + for(k = 0; k < NR_DATA; k ++) { + check(min3(test_data[i], test_data[j], test_data[k]) == ans[ans_idx ++]); + } + check(k == NR_DATA); + } + check(j == NR_DATA); + } + + check(i == NR_DATA); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/mov-c.c b/am-kernels/tests/cpu-tests/tests/mov-c.c new file mode 100644 index 0000000..f9fa23a --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/mov-c.c @@ -0,0 +1,25 @@ +#include "trap.h" + +volatile int A[10]; +volatile int b; + +int main() { + A[0] = 0; + A[1] = 1; + A[2] = 2; + A[3] = 3; + A[4] = 4; + + b = A[3]; + A[5] = b; + + check(A[0] == 0); + check(A[1] == 1); + check(A[2] == 2); + check(A[3] == 3); + check(A[4] == 4); + check(b == 3); + check(A[5] == 3); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/movsx.c b/am-kernels/tests/cpu-tests/tests/movsx.c new file mode 100644 index 0000000..b033ef3 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/movsx.c @@ -0,0 +1,33 @@ +#include "trap.h" + +volatile int A[10]; +volatile int b; +volatile signed char C[10]; +int main() { + A[0] = 0; + A[1] = 1; + A[2] = 2; + A[3] = 3; + A[4] = 4; + + b = A[3]; + A[5] = b; + C[0] = 'a'; + check(C[0] == 'a'); + C[1] = C[0]; + check(C[1] == 'a'); + A[0] = (int)C[0]; + check(A[0] == 'a'); + C[1] = 0x80; + A[0] = (int)C[1]; + check(A[1] == 1); + check(A[2] == 2); + check(A[3] == 3); + check(A[4] == 4); + check(b == 3); + check(A[5] == 3); + check(C[1] == 0xffffff80); + check(A[0] == 0xffffff80); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/mul-longlong.c b/am-kernels/tests/cpu-tests/tests/mul-longlong.c new file mode 100644 index 0000000..16a3dc7 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/mul-longlong.c @@ -0,0 +1,26 @@ +#include "trap.h" + +long long mul(long long a,long long b) { + long long ans = a*b; + return ans; +} + +int test_data[] = { 0xaeb1c2aa, 0x4500ff2b, 0x877190af, 0x11f42438}; +long long ans[] = { 0x19d29ab9db1a18e4LL, 0xea15986d3ac3088eLL, 0x2649e980fc0db236LL, 0xfa4c43da0a4a7d30LL, 0x1299898e2c56b139LL, 0xdf8123d50a319e65LL, 0x4d6dfa84c15dd68LL, 0x38c5d79b9e4357a1LL, 0xf78b91cb1efc4248LL, 0x14255a47fdfcc40LL}; + +#define NR_DATA LENGTH(test_data) + +int main() { + int i,j,ans_idx = 0; + for (i = 0;i < NR_DATA;i++) { + for (j = i;j < NR_DATA;j++) { + check(ans[ans_idx++] == mul(test_data[i],test_data[j])); + } + check(j == NR_DATA); + } + + check(i == NR_DATA); + + return 0; +} + diff --git a/am-kernels/tests/cpu-tests/tests/pascal.c b/am-kernels/tests/cpu-tests/tests/pascal.c new file mode 100644 index 0000000..02bf57a --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/pascal.c @@ -0,0 +1,30 @@ +#include "trap.h" + +#define N 31 + +int a[N]; +int ans[] = {1, 30, 435, 4060, 27405, 142506, 593775, 2035800, 5852925, 14307150, 30045015, 54627300, 86493225, 119759850, 145422675, 155117520, 145422675, 119759850, 86493225, 54627300, 30045015, 14307150, 5852925, 2035800, 593775, 142506, 27405, 4060, 435, 30, 1}; + +int main() { + int i, j; + int t0, t1; + a[0] = a[1] = 1; + + for(i = 2; i < N; i ++) { + t0 = 1; + for(j = 1; j < i; j ++) { + t1 = a[j]; + a[j] = t0 + t1; + t0 = t1; + } + a[i] = 1; + } + + for(j = 0; j < N; j ++) { + check(a[j] == ans[j]); + } + + check(j == N); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/prime.c b/am-kernels/tests/cpu-tests/tests/prime.c new file mode 100644 index 0000000..8cd26bb --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/prime.c @@ -0,0 +1,25 @@ +#include "trap.h" + +int ans[] = {101, 103, 107, 109, 113, 127, 131, 137, 139, 149}; + +int main() { + int m, i, n = 0; + int prime; + for(m = 101; m <= 150; m += 2) { + prime = 1; + for(i = 2; i < m; i ++) { + if(m % i == 0) { + prime = 0; + break; + } + } + if(prime) { + check(i == ans[n]); + n ++; + } + } + + check(n == 10); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/quick-sort.c b/am-kernels/tests/cpu-tests/tests/quick-sort.c new file mode 100644 index 0000000..dedbe5c --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/quick-sort.c @@ -0,0 +1,49 @@ +#include "trap.h" + +#define N 20 + +int a[N] = {2, 12, 14, 6, 13, 15, 16, 10, 0, 18, 11, 19, 9, 1, 7, 5, 4, 3, 8, 17}; + +int partition(int *a, int p, int q) { + int pivot = a[p]; + int i = p, j = q; + while(i < j) { + while(i < j && a[j] > pivot) j --; + a[i] = a[j]; + + while(i < j && a[i] <= pivot) i ++; + a[j] = a[i]; + } + + a[i] = pivot; + return i; +} + +void quick_sort(int *a, int p, int q) { + if(p >= q) return; + + int m = partition(a, p, q); + quick_sort(a, p, m - 1); + quick_sort(a, m + 1, q); +} + +int main() { + quick_sort(a, 0, N - 1); + + int i; + for(i = 0; i < N; i ++) { + check(a[i] == i); + } + + check(i == N); + + quick_sort(a, 0, N - 1); + + for(i = 0; i < N; i ++) { + check(a[i] == i); + } + + check(i == N); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/recursion.c b/am-kernels/tests/cpu-tests/tests/recursion.c new file mode 100644 index 0000000..9c3cb2a --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/recursion.c @@ -0,0 +1,46 @@ +#include "trap.h" + +int f0(int, int); +int f1(int, int); +int f2(int, int); +int f3(int, int); + +int (*func[])(int, int) = { + f0, f1, f2, f3, +}; + +int rec = 0, lvl = 0; + +int f0(int n, int l) { + if (l > lvl) lvl = l; + rec ++; + return n <= 0 ? 1 : func[3](n / 3, l + 1); +}; + +int f1(int n, int l) { + if (l > lvl) lvl = l; + rec ++; + return n <= 0 ? 1 : func[0](n - 1, l + 1); +}; + +int f2(int n, int l) { + if (l > lvl) lvl = l; + rec ++; + return n <= 0 ? 1 : func[1](n, l + 1) + 9; +}; + +int f3(int n, int l) { + if (l > lvl) lvl = l; + rec ++; + return n <= 0 ? 1 : func[2](n / 2, l + 1) * 3 + func[2](n / 2, l + 1) * 2; +}; + +int ans[] = {38270, 218, 20}; + +int main() { + int x = func[0](14371, 0); + check(x == ans[0]); // answer + check(rec == ans[1]); // # recursions + check(lvl == ans[2]); // max depth + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/select-sort.c b/am-kernels/tests/cpu-tests/tests/select-sort.c new file mode 100644 index 0000000..9d370c3 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/select-sort.c @@ -0,0 +1,42 @@ +#include "trap.h" + +#define N 20 + +int a[N] = {2, 12, 14, 6, 13, 15, 16, 10, 0, 18, 11, 19, 9, 1, 7, 5, 4, 3, 8, 17}; + +void select_sort() { + int i, j, k, t; + for(i = 0; i < N - 1; i ++) { + k = i; + for(j = i + 1; j < N; j ++) { + if(a[j] < a[k]) { + k = j; + } + } + + t = a[i]; + a[i] = a[k]; + a[k] = t; + } +} + +int main() { + select_sort(); + + int i; + for(i = 0; i < N; i ++) { + check(a[i] == i); + } + + check(i == N); + + select_sort(); + + for(i = 0; i < N; i ++) { + check(a[i] == i); + } + + check(i == N); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/shift.c b/am-kernels/tests/cpu-tests/tests/shift.c new file mode 100644 index 0000000..1581e70 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/shift.c @@ -0,0 +1,36 @@ +#include "trap.h" + +unsigned test[] = { + 0x12345678, 0x98765432, 0x0, 0xeffa1000, 0x7fffffff, 0x80000000, 0x33, 0xffffffff +}; + +unsigned srl_ans[] = { + 0x2468ac, 0x130eca8, 0x0, 0x1dff420, 0xffffff, 0x1000000, 0x0, 0x1ffffff +}; + +unsigned srlv_ans[] = { + 0x1234567, 0x4c3b2a1, 0x0, 0x1dff420, 0x7fffff, 0x400000, 0x0, 0x1fffff +}; + +unsigned srav_ans[] = { + 0x1234567, 0xfcc3b2a1, 0x0, 0xffdff420, 0x7fffff, 0xffc00000, 0x0, 0xffffffff +}; + + +int main() { + unsigned i; + + for(i = 0; i < LENGTH(test); i ++) { + check((test[i] >> 7) == srl_ans[i]); + } + + for(i = 0; i < LENGTH(test); i ++) { + check((unsigned)((int)test[i] >> (i + 4)) == srav_ans[i]); + } + + for(i = 0; i < LENGTH(test); i ++) { + check((test[i] >> (i + 4)) == srlv_ans[i]); + } + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/shuixianhua.c b/am-kernels/tests/cpu-tests/tests/shuixianhua.c new file mode 100644 index 0000000..046674e --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/shuixianhua.c @@ -0,0 +1,26 @@ +#include "trap.h" + +int ans[] = {153, 370, 371, 407}; + +int cube(int n) { + return n * n * n; +} + +int main() { + int n, n2, n1, n0; + int k = 0; + for(n = 100; n < 500; n ++) { + n2 = n / 100; + n1 = (n / 10) % 10; + n0 = n % 10; + + if(n == cube(n2) + cube(n1) + cube(n0)) { + check(n == ans[k]); + k ++; + } + } + + check(k == 4); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/string.c b/am-kernels/tests/cpu-tests/tests/string.c new file mode 100644 index 0000000..3a9200d --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/string.c @@ -0,0 +1,27 @@ +#include "trap.h" + +char *s[] = { + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab", + "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + ", World!\n", + "Hello, World!\n", + "#####" +}; + +char str1[] = "Hello"; +char str[20]; + +int main() { + check(strcmp(s[0], s[2]) == 0); + check(strcmp(s[0], s[1]) < 0); + check(strcmp(s[0] + 1, s[1] + 1) < 0); + check(strcmp(s[0] + 2, s[1] + 2) < 0); + check(strcmp(s[0] + 3, s[1] + 3) < 0); + + check(strcmp( strcat(strcpy(str, str1), s[3]), s[4]) == 0); + + check(memcmp(memset(str, '#', 5), s[5], 5) == 0); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/sub-longlong.c b/am-kernels/tests/cpu-tests/tests/sub-longlong.c new file mode 100644 index 0000000..4e40270 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/sub-longlong.c @@ -0,0 +1,22 @@ +#include "trap.h" + +long long sub(long long a, long long b) { + long long c = a - b; + return c; +} + +long long test_data[] = {0, 1, 2, 0x7fffffffffffffffLL, 0x8000000000000000LL, 0x8000000000000001LL, 0xfffffffffffffffeLL, 0xffffffffffffffffLL}; +long long ans[] = {0LL, 0xffffffffffffffffLL, 0xfffffffffffffffeLL, 0x8000000000000001LL, 0x8000000000000000LL, 0x7fffffffffffffffLL, 0x2LL, 0x1LL, 0x1LL, 0LL, 0xffffffffffffffffLL, 0x8000000000000002LL, 0x8000000000000001LL, 0x8000000000000000LL, 0x3LL, 0x2LL, 0x2LL, 0x1LL, 0LL, 0x8000000000000003LL, 0x8000000000000002LL, 0x8000000000000001LL, 0x4LL, 0x3LL, 0x7fffffffffffffffLL, 0x7ffffffffffffffeLL, 0x7ffffffffffffffdLL, 0LL, 0xffffffffffffffffLL, 0xfffffffffffffffeLL, 0x8000000000000001LL, 0x8000000000000000LL, 0x8000000000000000LL, 0x7fffffffffffffffLL, 0x7ffffffffffffffeLL, 0x1LL, 0LL, 0xffffffffffffffffLL, 0x8000000000000002LL, 0x8000000000000001LL, 0x8000000000000001LL, 0x8000000000000000LL, 0x7fffffffffffffffLL, 0x2LL, 0x1LL, 0LL, 0x8000000000000003LL, 0x8000000000000002LL, 0xfffffffffffffffeLL, 0xfffffffffffffffdLL, 0xfffffffffffffffcLL, 0x7fffffffffffffffLL, 0x7ffffffffffffffeLL, 0x7ffffffffffffffdLL, 0LL, 0xffffffffffffffffLL, 0xffffffffffffffffLL, 0xfffffffffffffffeLL, 0xfffffffffffffffdLL, 0x8000000000000000LL, 0x7fffffffffffffffLL, 0x7ffffffffffffffeLL, 0x1LL, 0LL}; + +#define NR_DATA LENGTH(test_data) + +int main() { + int i, j, ans_idx = 0; + for(i = 0; i < NR_DATA; i ++) { + for(j = 0; j < NR_DATA; j ++) { + check(sub(test_data[i], test_data[j]) == ans[ans_idx ++]); + } + } + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/sum.c b/am-kernels/tests/cpu-tests/tests/sum.c new file mode 100644 index 0000000..e0301a2 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/sum.c @@ -0,0 +1,14 @@ +#include "trap.h" + +int main() { + int i = 1; + volatile int sum = 0; + while(i <= 100) { + sum += i; + i ++; + } + + check(sum == 5050); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/switch.c b/am-kernels/tests/cpu-tests/tests/switch.c new file mode 100644 index 0000000..c29c916 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/switch.c @@ -0,0 +1,29 @@ +#include "trap.h" + +int switch_case(int n) { + int ret; + switch(n) { + case 0: ret = 0; break; + case 1: ret = 2; break; + case 2: case 3: ret = 5; break; + case 4: case 5: case 6: case 7: ret = 8; break; + case 8: case 9: case 10: case 11: ret = 10; break; + case 12: ret = 15; break; + default: ret = -1; break; + } + + return ret; +} + +int ans[] = {-1, 0, 2, 5, 5, 8, 8, 8, 8, 10, 10, 10, 10, 15, -1}; + +int main() { + int i; + for(i = 0; i < 15; i ++) { + check(switch_case(i - 1) == ans[i]); + } + + check(i == 15); + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/to-lower-case.c b/am-kernels/tests/cpu-tests/tests/to-lower-case.c new file mode 100644 index 0000000..83a0cc0 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/to-lower-case.c @@ -0,0 +1,18 @@ +#include "trap.h" + +char to_lower_case(char c) { + return (c >= 'A' && c <= 'Z' ? (c + 32) : c); +} + +volatile char ans [] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, + 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, + 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127}; + +int main() { + int i; + for(i = 0; i < 128; i ++) { + check(to_lower_case(i) == ans[i]); + } + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/unalign.c b/am-kernels/tests/cpu-tests/tests/unalign.c new file mode 100644 index 0000000..92c2203 --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/unalign.c @@ -0,0 +1,18 @@ +#include "trap.h" + +volatile unsigned x = 0xffffffff; +volatile unsigned char buf[16]; + +int main() { + + for(int i = 0; i < 4; i++) { + *((volatile unsigned*)(buf + 3)) = 0xaabbccdd; + + x = *((volatile unsigned*)(buf + 3)); + check(x == 0xaabbccdd); + + buf[0] = buf[1] = 0; + } + + return 0; +} diff --git a/am-kernels/tests/cpu-tests/tests/wanshu.c b/am-kernels/tests/cpu-tests/tests/wanshu.c new file mode 100644 index 0000000..ba9fdef --- /dev/null +++ b/am-kernels/tests/cpu-tests/tests/wanshu.c @@ -0,0 +1,24 @@ +#include "trap.h" + +int ans[] = {6, 28}; + +int main() { + int n, sum, i, k = 0; + for(n = 1; n < 30; n ++) { + sum = 0; + for(i = 1; i < n; i ++) { + if(n % i == 0) { + sum += i; + } + } + + if(sum == n) { + check(n == ans[k]); + k ++; + } + } + + check(k == 2); + + return 0; +} diff --git a/flake.nix b/flake.nix index 6154319..869ffc9 100644 --- a/flake.nix +++ b/flake.nix @@ -20,7 +20,7 @@ }; in { - packages.nemu = pkgs.callPackage ./nemu { am-kernels = self.packages.${system}.am-kernels-rv32; }; + packages.nemu = pkgs.callPackage ./nemu { am-kernels = self.packages.${system}.am-kernels-cmake; }; packages.abstract-machine = crossPkgs.stdenv.mkDerivation rec { pname = "abstract-machine"; @@ -28,6 +28,11 @@ src = ./abstract-machine; + cmakeFlags = [ + (pkgs.lib.cmakeFeature "ISA" "riscv") + (pkgs.lib.cmakeBool "__PLATFORM_NEMU__" true) + ]; + nativeBuildInputs = [ pkgs.cmake ]; @@ -35,15 +40,11 @@ buildInputs = [ # SDL2 ]; - cmakeFlags = [ - (pkgs.lib.cmakeFeature "ISA" "riscv") - (pkgs.lib.cmakeBool "__PLATFORM_NEMU__" true) - ]; }; packages.am-kernels-cmake = crossPkgs.stdenv.mkDerivation rec { pname = "am-kernels-cmake"; - version = "2024.02.19"; + version = "2024.02.18"; src = ./am-kernels; @@ -54,7 +55,6 @@ cmakeFlags = [ (pkgs.lib.cmakeFeature "ISA" "riscv") (pkgs.lib.cmakeFeature "PLATFORM" "nemu") - (pkgs.lib.cmakeFeature "CMAKE_INSTALL_DATADIR" "share") ]; diff --git a/nemu/default.nix b/nemu/default.nix index a886b79..e746a7c 100644 --- a/nemu/default.nix +++ b/nemu/default.nix @@ -38,7 +38,7 @@ stdenv.mkDerivation rec { doCheck = true; checkPhase = '' - export IMAGES_PATH=${am-kernels}/share/images + export IMAGES_PATH=${am-kernels}/share/binary make test ''; @@ -49,7 +49,7 @@ stdenv.mkDerivation rec { shellHook = '' export NEMU_HOME=$(pwd) - export IMAGES_PATH=${am-kernels}/share/images + export IMAGES_PATH=${am-kernels}/share/binary ''; meta = with lib; { diff --git a/result b/result index c4a563f..cdb1008 120000 --- a/result +++ b/result @@ -1 +1 @@ -/nix/store/mpn11vhq7f7zqp9ql02n083x1wkp5jbx-am-kernels-cmake-riscv32-none-elf-2024.02.19 \ No newline at end of file +/nix/store/3pqxmgv27p46w3v34zwi5y1rcdkwb7h6-am-kernels-cmake-riscv32-none-elf-2024.02.18 \ No newline at end of file