From 01cf8b15ffd012b6162fd6f74c89e3f6d9ee7e06 Mon Sep 17 00:00:00 2001 From: CentOS Sources Date: Oct 22 2019 12:35:34 +0000 Subject: import valgrind-3.15.0-11.el7 --- diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8e3baf4 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +SOURCES/valgrind-3.15.0.tar.bz2 diff --git a/.valgrind.metadata b/.valgrind.metadata new file mode 100644 index 0000000..88f669e --- /dev/null +++ b/.valgrind.metadata @@ -0,0 +1 @@ +4cc014e2390c4bcecb11aa00b37aa52d352db97f SOURCES/valgrind-3.15.0.tar.bz2 diff --git a/SOURCES/valgrind-3.11.0-ppc-fppo.patch b/SOURCES/valgrind-3.11.0-ppc-fppo.patch new file mode 100644 index 0000000..8890e6b --- /dev/null +++ b/SOURCES/valgrind-3.11.0-ppc-fppo.patch @@ -0,0 +1,37 @@ +--- valgrind-3.10.0.BETA1/configure.orig 2014-09-02 13:49:58.125269536 +0200 ++++ valgrind-3.10.0.BETA1/configure 2014-09-02 13:54:08.188701144 +0200 +@@ -8978,9 +8978,8 @@ + fi + rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext + if test x$ac_have_as_ppc_fpPO = xyes ; then +- +-$as_echo "#define HAVE_AS_PPC_FPPO 1" >>confdefs.h +- ++ { $as_echo "$as_me:${as_lineno-$LINENO}: HAVE_AS_PPC_FPPO found, but ignoring." >&5 ++$as_echo "$as_me: HAVE_AS_PPC_FPPO found, but ignoring." >&6;} + fi + + +--- valgrind-3.11.0/config.h.in.orig 2016-04-15 23:51:26.889440687 +0200 ++++ valgrind-3.11.0/config.h.in 2016-04-15 23:51:43.430126014 +0200 +@@ -55,9 +55,6 @@ + /* Define to 1 if as supports fxsave64/fxrstor64. */ + #undef HAVE_AS_AMD64_FXSAVE64 + +-/* Define to 1 if as supports floating point phased out category. */ +-#undef HAVE_AS_PPC_FPPO +- + /* Define to 1 if as supports mtocrf/mfocrf. */ + #undef HAVE_AS_PPC_MFTOCRF + +--- valgrind-3.10.0.BETA1/configure.ac.orig 2014-09-02 14:01:04.443754937 +0200 ++++ valgrind-3.10.0.BETA1/configure.ac 2014-09-02 14:01:16.483727639 +0200 +@@ -2022,7 +2022,7 @@ + AC_MSG_RESULT([no]) + ]) + if test x$ac_have_as_ppc_fpPO = xyes ; then +- AC_DEFINE(HAVE_AS_PPC_FPPO, 1, [Define to 1 if as supports floating point phased out category.]) ++ AC_MSG_NOTICE([HAVE_AS_PPC_FPPO found, but ignoring.]) + fi + + diff --git a/SOURCES/valgrind-3.15.0-arm-membarrier.patch b/SOURCES/valgrind-3.15.0-arm-membarrier.patch new file mode 100644 index 0000000..945e1a8 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-arm-membarrier.patch @@ -0,0 +1,18 @@ +commit 9616e9bc9a1950f70ab1abd1c6ca9abc3f26eb7f +Author: Mark Wielaard +Date: Fri May 31 15:11:35 2019 +0200 + + Hook up membarrier syscall for arm-linux. + +diff --git a/coregrind/m_syswrap/syswrap-arm-linux.c b/coregrind/m_syswrap/syswrap-arm-linux.c +index 3c5194d55..5e8baf8db 100644 +--- a/coregrind/m_syswrap/syswrap-arm-linux.c ++++ b/coregrind/m_syswrap/syswrap-arm-linux.c +@@ -1014,6 +1014,7 @@ static SyscallTableEntry syscall_main_table[] = { + LINXY(__NR_getrandom, sys_getrandom), // 384 + LINXY(__NR_memfd_create, sys_memfd_create), // 385 + ++ LINX_(__NR_membarrier, sys_membarrier), // 389 + LINX_(__NR_copy_file_range, sys_copy_file_range), // 391 + + LINXY(__NR_statx, sys_statx), // 397 diff --git a/SOURCES/valgrind-3.15.0-arm64-ld-stpcpy.patch b/SOURCES/valgrind-3.15.0-arm64-ld-stpcpy.patch new file mode 100644 index 0000000..b0290ae --- /dev/null +++ b/SOURCES/valgrind-3.15.0-arm64-ld-stpcpy.patch @@ -0,0 +1,45 @@ +commit 89423f5d8ba05a099c2c62227a00a4f4eec59eb3 +Author: Mark Wielaard +Date: Tue May 7 21:20:04 2019 +0200 + + Intercept stpcpy also in ld.so for arm64 + + On other arches stpcpy () is intercepted for both libc.so and ld.so. + But not on arm64, where it is only intercepted for libc.so. + + This can cause memcheck warnings about the use of stpcpy () in ld.so + when called through dlopen () because ld.so contains its own copy of + that functions. + + Fix by introducing VG_Z_LD_LINUX_AARCH64_SO_1 (the encoded name of + ld.so on arm64) and using that in vg_replace_strmem.c to intercept + stpcpy. + + https://bugs.kde.org/show_bug.cgi?id=407307 + +diff --git a/include/pub_tool_redir.h b/include/pub_tool_redir.h +index c97941f..15ba67f 100644 +--- a/include/pub_tool_redir.h ++++ b/include/pub_tool_redir.h +@@ -313,7 +313,9 @@ + #define VG_Z_LD_SO_1 ldZdsoZd1 // ld.so.1 + #define VG_U_LD_SO_1 "ld.so.1" + ++#define VG_Z_LD_LINUX_AARCH64_SO_1 ldZhlinuxZhaarch64ZdsoZd1 + #define VG_U_LD_LINUX_AARCH64_SO_1 "ld-linux-aarch64.so.1" ++ + #define VG_U_LD_LINUX_ARMHF_SO_3 "ld-linux-armhf.so.3" + + #endif +diff --git a/shared/vg_replace_strmem.c b/shared/vg_replace_strmem.c +index 89a7dcc..19143cf 100644 +--- a/shared/vg_replace_strmem.c ++++ b/shared/vg_replace_strmem.c +@@ -1160,6 +1160,7 @@ static inline void my_exit ( int x ) + STPCPY(VG_Z_LIBC_SONAME, __stpcpy_sse2_unaligned) + STPCPY(VG_Z_LD_LINUX_SO_2, stpcpy) + STPCPY(VG_Z_LD_LINUX_X86_64_SO_2, stpcpy) ++ STPCPY(VG_Z_LD_LINUX_AARCH64_SO_1,stpcpy) + + #elif defined(VGO_darwin) + //STPCPY(VG_Z_LIBC_SONAME, stpcpy) diff --git a/SOURCES/valgrind-3.15.0-avx-rdrand-f16c.patch b/SOURCES/valgrind-3.15.0-avx-rdrand-f16c.patch new file mode 100644 index 0000000..cc041fe --- /dev/null +++ b/SOURCES/valgrind-3.15.0-avx-rdrand-f16c.patch @@ -0,0 +1,95 @@ +commit 791fe5ecf909d573bcbf353b677b9404f9da0ed4 +Author: Mark Wielaard +Date: Mon May 27 22:19:27 2019 +0200 + + Expose rdrand and f16c through cpuid also if the host only has avx. + + The amd64 CPUID dirtyhelpers are mostly static since they emulate some + existing CPU "family". The avx2 ("i7-4910MQ") CPUID variant however + can "dynamicly" enable rdrand and/or f16c if the host supports them. + Do the same for the avx_and_cx16 ("i5-2300") CPUID variant. + + https://bugs.kde.org/show_bug.cgi?id=408009 + +diff --git a/VEX/priv/guest_amd64_defs.h b/VEX/priv/guest_amd64_defs.h +index 4f34b41..a5de527 100644 +--- a/VEX/priv/guest_amd64_defs.h ++++ b/VEX/priv/guest_amd64_defs.h +@@ -165,7 +165,9 @@ extern void amd64g_dirtyhelper_storeF80le ( Addr/*addr*/, ULong/*data*/ ); + extern void amd64g_dirtyhelper_CPUID_baseline ( VexGuestAMD64State* st ); + extern void amd64g_dirtyhelper_CPUID_sse3_and_cx16 ( VexGuestAMD64State* st ); + extern void amd64g_dirtyhelper_CPUID_sse42_and_cx16 ( VexGuestAMD64State* st ); +-extern void amd64g_dirtyhelper_CPUID_avx_and_cx16 ( VexGuestAMD64State* st ); ++extern void amd64g_dirtyhelper_CPUID_avx_and_cx16 ( VexGuestAMD64State* st, ++ ULong hasF16C, ++ ULong hasRDRAND ); + extern void amd64g_dirtyhelper_CPUID_avx2 ( VexGuestAMD64State* st, + ULong hasF16C, ULong hasRDRAND ); + +diff --git a/VEX/priv/guest_amd64_helpers.c b/VEX/priv/guest_amd64_helpers.c +index e4cf7e2..182bae0 100644 +--- a/VEX/priv/guest_amd64_helpers.c ++++ b/VEX/priv/guest_amd64_helpers.c +@@ -3141,8 +3141,11 @@ void amd64g_dirtyhelper_CPUID_sse42_and_cx16 ( VexGuestAMD64State* st ) + address sizes : 36 bits physical, 48 bits virtual + power management: + */ +-void amd64g_dirtyhelper_CPUID_avx_and_cx16 ( VexGuestAMD64State* st ) ++void amd64g_dirtyhelper_CPUID_avx_and_cx16 ( VexGuestAMD64State* st, ++ ULong hasF16C, ULong hasRDRAND ) + { ++ vassert((hasF16C >> 1) == 0ULL); ++ vassert((hasRDRAND >> 1) == 0ULL); + # define SET_ABCD(_a,_b,_c,_d) \ + do { st->guest_RAX = (ULong)(_a); \ + st->guest_RBX = (ULong)(_b); \ +@@ -3157,9 +3160,14 @@ void amd64g_dirtyhelper_CPUID_avx_and_cx16 ( VexGuestAMD64State* st ) + case 0x00000000: + SET_ABCD(0x0000000d, 0x756e6547, 0x6c65746e, 0x49656e69); + break; +- case 0x00000001: +- SET_ABCD(0x000206a7, 0x00100800, 0x1f9ae3bf, 0xbfebfbff); ++ case 0x00000001: { ++ // As a baseline, advertise neither F16C (ecx:29) nor RDRAND (ecx:30), ++ // but patch in support for them as directed by the caller. ++ UInt ecx_extra ++ = (hasF16C ? (1U << 29) : 0) | (hasRDRAND ? (1U << 30) : 0); ++ SET_ABCD(0x000206a7, 0x00100800, (0x1f9ae3bf | ecx_extra), 0xbfebfbff); + break; ++ } + case 0x00000002: + SET_ABCD(0x76035a01, 0x00f0b0ff, 0x00000000, 0x00ca0000); + break; +diff --git a/VEX/priv/guest_amd64_toIR.c b/VEX/priv/guest_amd64_toIR.c +index 56e992c..96dee38 100644 +--- a/VEX/priv/guest_amd64_toIR.c ++++ b/VEX/priv/guest_amd64_toIR.c +@@ -22007,7 +22007,8 @@ Long dis_ESC_0F ( + + vassert(fName); vassert(fAddr); + IRExpr** args = NULL; +- if (fAddr == &amd64g_dirtyhelper_CPUID_avx2) { ++ if (fAddr == &amd64g_dirtyhelper_CPUID_avx2 ++ || fAddr == &amd64g_dirtyhelper_CPUID_avx_and_cx16) { + Bool hasF16C = (archinfo->hwcaps & VEX_HWCAPS_AMD64_F16C) != 0; + Bool hasRDRAND = (archinfo->hwcaps & VEX_HWCAPS_AMD64_RDRAND) != 0; + args = mkIRExprVec_3(IRExpr_GSPTR(), +diff --git a/coregrind/m_machine.c b/coregrind/m_machine.c +index 3536e57..56a28d1 100644 +--- a/coregrind/m_machine.c ++++ b/coregrind/m_machine.c +@@ -1076,10 +1076,10 @@ Bool VG_(machine_get_hwcaps)( void ) + have_avx2 = (ebx & (1<<5)) != 0; /* True => have AVX2 */ + } + +- /* Sanity check for RDRAND and F16C. These don't actually *need* AVX2, but +- it's convenient to restrict them to the AVX2 case since the simulated +- CPUID we'll offer them on has AVX2 as a base. */ +- if (!have_avx2) { ++ /* Sanity check for RDRAND and F16C. These don't actually *need* AVX, but ++ it's convenient to restrict them to the AVX case since the simulated ++ CPUID we'll offer them on has AVX as a base. */ ++ if (!have_avx) { + have_f16c = False; + have_rdrand = False; + } diff --git a/SOURCES/valgrind-3.15.0-copy_file_range.patch b/SOURCES/valgrind-3.15.0-copy_file_range.patch new file mode 100644 index 0000000..6cf9827 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-copy_file_range.patch @@ -0,0 +1,374 @@ +commit 5f00db054a6f59502e9deeeb59ace2261207ee31 +Author: Alexandra Hajkova +Date: Thu May 2 08:24:02 2019 -0400 + + Add support for the copy_file_range syscall + + Support amd64, x86, arm64, ppc64, ppc32 and s390x architectures. + Also add sys-copy_file_range test case. + +diff --git a/configure.ac b/configure.ac +index d043ce3..3528925 100755 +--- a/configure.ac ++++ b/configure.ac +@@ -4172,6 +4172,7 @@ AC_CHECK_FUNCS([ \ + utimensat \ + process_vm_readv \ + process_vm_writev \ ++ copy_file_range \ + ]) + + # AC_CHECK_LIB adds any library found to the variable LIBS, and links these +@@ -4187,6 +4188,8 @@ AM_CONDITIONAL([HAVE_PTHREAD_SPINLOCK], + [test x$ac_cv_func_pthread_spin_lock = xyes]) + AM_CONDITIONAL([HAVE_PTHREAD_SETNAME_NP], + [test x$ac_cv_func_pthread_setname_np = xyes]) ++AM_CONDITIONAL([HAVE_COPY_FILE_RANGE], ++ [test x$ac_cv_func_copy_file_range = xyes]) + + if test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX \ + -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX ; then +diff --git a/coregrind/m_syswrap/priv_syswrap-linux.h b/coregrind/m_syswrap/priv_syswrap-linux.h +index f76191a..1edf9eb 100644 +--- a/coregrind/m_syswrap/priv_syswrap-linux.h ++++ b/coregrind/m_syswrap/priv_syswrap-linux.h +@@ -379,6 +379,7 @@ DECL_TEMPLATE(linux, sys_getsockname); + DECL_TEMPLATE(linux, sys_getpeername); + DECL_TEMPLATE(linux, sys_socketpair); + DECL_TEMPLATE(linux, sys_kcmp); ++DECL_TEMPLATE(linux, sys_copy_file_range); + + // Some arch specific functions called from syswrap-linux.c + extern Int do_syscall_clone_x86_linux ( Word (*fn)(void *), +diff --git a/coregrind/m_syswrap/syswrap-amd64-linux.c b/coregrind/m_syswrap/syswrap-amd64-linux.c +index 30e7d0e..0c1d8d1 100644 +--- a/coregrind/m_syswrap/syswrap-amd64-linux.c ++++ b/coregrind/m_syswrap/syswrap-amd64-linux.c +@@ -863,6 +863,8 @@ static SyscallTableEntry syscall_table[] = { + LINXY(__NR_statx, sys_statx), // 332 + + LINX_(__NR_membarrier, sys_membarrier), // 324 ++ ++ LINX_(__NR_copy_file_range, sys_copy_file_range), // 326 + }; + + SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno ) +diff --git a/coregrind/m_syswrap/syswrap-arm64-linux.c b/coregrind/m_syswrap/syswrap-arm64-linux.c +index 290320a..f66be2d 100644 +--- a/coregrind/m_syswrap/syswrap-arm64-linux.c ++++ b/coregrind/m_syswrap/syswrap-arm64-linux.c +@@ -819,7 +819,7 @@ static SyscallTableEntry syscall_main_table[] = { + // (__NR_userfaultfd, sys_ni_syscall), // 282 + LINX_(__NR_membarrier, sys_membarrier), // 283 + // (__NR_mlock2, sys_ni_syscall), // 284 +- // (__NR_copy_file_range, sys_ni_syscall), // 285 ++ LINX_(__NR_copy_file_range, sys_copy_file_range), // 285 + // (__NR_preadv2, sys_ni_syscall), // 286 + // (__NR_pwritev2, sys_ni_syscall), // 287 + // (__NR_pkey_mprotect, sys_ni_syscall), // 288 +diff --git a/coregrind/m_syswrap/syswrap-linux.c b/coregrind/m_syswrap/syswrap-linux.c +index 73ef98d..cd0ee74 100644 +--- a/coregrind/m_syswrap/syswrap-linux.c ++++ b/coregrind/m_syswrap/syswrap-linux.c +@@ -12093,6 +12093,36 @@ POST(sys_bpf) + } + } + ++PRE(sys_copy_file_range) ++{ ++ PRINT("sys_copy_file_range (%lu, %lu, %lu, %lu, %lu, %lu)", ARG1, ARG2, ARG3, ++ ARG4, ARG5, ARG6); ++ ++ PRE_REG_READ6(vki_size_t, "copy_file_range", ++ int, "fd_in", ++ vki_loff_t *, "off_in", ++ int, "fd_out", ++ vki_loff_t *, "off_out", ++ vki_size_t, "len", ++ unsigned int, "flags"); ++ ++ /* File descriptors are "specially" tracked by valgrind. ++ valgrind itself uses some, so make sure someone didn't ++ put in one of our own... */ ++ if (!ML_(fd_allowed)(ARG1, "copy_file_range(fd_in)", tid, False) || ++ !ML_(fd_allowed)(ARG3, "copy_file_range(fd_in)", tid, False)) { ++ SET_STATUS_Failure( VKI_EBADF ); ++ } else { ++ /* Now see if the offsets are defined. PRE_MEM_READ will ++ double check it can dereference them. */ ++ if (ARG2 != 0) ++ PRE_MEM_READ( "copy_file_range(off_in)", ARG2, sizeof(vki_loff_t)); ++ if (ARG4 != 0) ++ PRE_MEM_READ( "copy_file_range(off_out)", ARG4, sizeof(vki_loff_t)); ++ } ++} ++ ++ + #undef PRE + #undef POST + +diff --git a/coregrind/m_syswrap/syswrap-ppc32-linux.c b/coregrind/m_syswrap/syswrap-ppc32-linux.c +index f812f1f..71f208d 100644 +--- a/coregrind/m_syswrap/syswrap-ppc32-linux.c ++++ b/coregrind/m_syswrap/syswrap-ppc32-linux.c +@@ -1021,6 +1021,8 @@ static SyscallTableEntry syscall_table[] = { + LINXY(__NR_getrandom, sys_getrandom), // 359 + LINXY(__NR_memfd_create, sys_memfd_create), // 360 + ++ LINX_(__NR_copy_file_range, sys_copy_file_range), // 379 ++ + LINXY(__NR_statx, sys_statx), // 383 + }; + +diff --git a/coregrind/m_syswrap/syswrap-ppc64-linux.c b/coregrind/m_syswrap/syswrap-ppc64-linux.c +index eada099..1a42c1f 100644 +--- a/coregrind/m_syswrap/syswrap-ppc64-linux.c ++++ b/coregrind/m_syswrap/syswrap-ppc64-linux.c +@@ -1007,6 +1007,8 @@ static SyscallTableEntry syscall_table[] = { + + LINX_(__NR_membarrier, sys_membarrier), // 365 + ++ LINX_(__NR_copy_file_range, sys_copy_file_range), // 379 ++ + LINXY(__NR_statx, sys_statx), // 383 + }; + +diff --git a/coregrind/m_syswrap/syswrap-s390x-linux.c b/coregrind/m_syswrap/syswrap-s390x-linux.c +index ad78384..41ada8d 100644 +--- a/coregrind/m_syswrap/syswrap-s390x-linux.c ++++ b/coregrind/m_syswrap/syswrap-s390x-linux.c +@@ -854,6 +854,8 @@ static SyscallTableEntry syscall_table[] = { + LINXY(__NR_recvmsg, sys_recvmsg), // 372 + LINX_(__NR_shutdown, sys_shutdown), // 373 + ++ LINX_(__NR_copy_file_range, sys_copy_file_range), // 375 ++ + LINXY(__NR_statx, sys_statx), // 379 + }; + +diff --git a/coregrind/m_syswrap/syswrap-x86-linux.c b/coregrind/m_syswrap/syswrap-x86-linux.c +index f05619e..f8d97ea 100644 +--- a/coregrind/m_syswrap/syswrap-x86-linux.c ++++ b/coregrind/m_syswrap/syswrap-x86-linux.c +@@ -1608,6 +1608,8 @@ static SyscallTableEntry syscall_table[] = { + + LINX_(__NR_membarrier, sys_membarrier), // 375 + ++ LINX_(__NR_copy_file_range, sys_copy_file_range), // 377 ++ + LINXY(__NR_statx, sys_statx), // 383 + + /* Explicitly not supported on i386 yet. */ +diff --git a/memcheck/tests/linux/Makefile.am b/memcheck/tests/linux/Makefile.am +index d7515d9..00e99a5 100644 +--- a/memcheck/tests/linux/Makefile.am ++++ b/memcheck/tests/linux/Makefile.am +@@ -20,6 +20,7 @@ EXTRA_DIST = \ + stack_switch.stderr.exp stack_switch.vgtest \ + syscalls-2007.vgtest syscalls-2007.stderr.exp \ + syslog-syscall.vgtest syslog-syscall.stderr.exp \ ++ sys-copy_file_range.vgtest sys-copy_file_range.stderr.exp \ + sys-openat.vgtest sys-openat.stderr.exp sys-openat.stdout.exp \ + sys-statx.vgtest sys-statx.stderr.exp \ + timerfd-syscall.vgtest timerfd-syscall.stderr.exp \ +@@ -49,6 +50,10 @@ if HAVE_AT_FDCWD + check_PROGRAMS += sys-openat + endif + ++if HAVE_COPY_FILE_RANGE ++ check_PROGRAMS += sys-copy_file_range ++endif ++ + AM_CFLAGS += $(AM_FLAG_M3264_PRI) + AM_CXXFLAGS += $(AM_FLAG_M3264_PRI) + +diff --git a/memcheck/tests/linux/sys-copy_file_range.c b/memcheck/tests/linux/sys-copy_file_range.c +new file mode 100644 +index 0000000..83981c6 +--- /dev/null ++++ b/memcheck/tests/linux/sys-copy_file_range.c +@@ -0,0 +1,67 @@ ++#define _GNU_SOURCE ++#include ++#include ++#include ++#include ++#include ++#include ++ ++int main(int argc, char **argv) ++{ ++ int fd_in, fd_out; ++ struct stat stat; ++ loff_t len, ret; ++ ++ fd_in = open("copy_file_range_source", O_CREAT | O_RDWR); ++ if (fd_in == -1) { ++ perror("open copy_file_range_source"); ++ exit(EXIT_FAILURE); ++ } ++ ++ if (write(fd_in, "foo bar\n", 8) != 8) { ++ perror("writing to the copy_file_range_source"); ++ exit(EXIT_FAILURE); ++ } ++ lseek(fd_in, 0, SEEK_SET); ++ ++ if (fstat(fd_in, &stat) == -1) { ++ perror("fstat"); ++ exit(EXIT_FAILURE); ++ } ++ ++ len = stat.st_size; ++ ++ fd_out = open("copy_file_range_dest", O_CREAT | O_WRONLY | O_TRUNC, 0644); ++ if (fd_out == -1) { ++ perror("open copy_file_range_dest"); ++ exit(EXIT_FAILURE); ++ } ++ ++ /* Check copy_file_range called with the correct arguments works. */ ++ do { ++ ret = copy_file_range(fd_in, NULL, fd_out, NULL, len, 0); ++ if (ret == -1) { ++ perror("copy_file_range"); ++ exit(EXIT_FAILURE); ++ } ++ ++ len -= ret; ++ } while (len > 0); ++ ++ /* Check valgrind will produce expected warnings for the ++ various wrong arguments. */ ++ do { ++ void *t; ++ void *z = (void *) -1; ++ ++ ret = copy_file_range(fd_in, t, fd_out, NULL, len, 0); ++ ret = copy_file_range(fd_in, NULL, fd_out, z, len, 0); ++ ret = copy_file_range(- 1, NULL, - 1, NULL, len, 0); ++ } while (0); ++ ++ close(fd_in); ++ close(fd_out); ++ unlink("copy_file_range_source"); ++ unlink("copy_file_range_dest"); ++ exit(EXIT_SUCCESS); ++} +diff --git a/memcheck/tests/linux/sys-copy_file_range.stderr.exp b/memcheck/tests/linux/sys-copy_file_range.stderr.exp +new file mode 100644 +index 0000000..1aa4dc2 +--- /dev/null ++++ b/memcheck/tests/linux/sys-copy_file_range.stderr.exp +@@ -0,0 +1,21 @@ ++ ++Syscall param copy_file_range("off_in") contains uninitialised byte(s) ++ ... ++ by 0x........: main (sys-copy_file_range.c:57) ++ ++Syscall param copy_file_range(off_out) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-copy_file_range.c:58) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Warning: invalid file descriptor -1 in syscall copy_file_range(fd_in)() ++ ++HEAP SUMMARY: ++ in use at exit: 0 bytes in 0 blocks ++ total heap usage: 0 allocs, 0 frees, 0 bytes allocated ++ ++For a detailed leak analysis, rerun with: --leak-check=full ++ ++Use --track-origins=yes to see where uninitialised values come from ++For lists of detected and suppressed errors, rerun with: -s ++ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 0 from 0) +diff --git a/memcheck/tests/linux/sys-copy_file_range.vgtest b/memcheck/tests/linux/sys-copy_file_range.vgtest +new file mode 100644 +index 0000000..b7741e8 +--- /dev/null ++++ b/memcheck/tests/linux/sys-copy_file_range.vgtest +@@ -0,0 +1,2 @@ ++prereq: test -e sys-copy_file_range ++prog: sys-copy_file_range +commit bd27ad3ff31555484b7fdb310c4b033620882e44 +Author: Mark Wielaard +Date: Sun May 5 16:01:41 2019 +0200 + + Hook linux copy_file_range syscall on arm. + +diff --git a/coregrind/m_syswrap/syswrap-arm-linux.c b/coregrind/m_syswrap/syswrap-arm-linux.c +index 9f1bdab..9ba0665 100644 +--- a/coregrind/m_syswrap/syswrap-arm-linux.c ++++ b/coregrind/m_syswrap/syswrap-arm-linux.c +@@ -1016,6 +1016,8 @@ static SyscallTableEntry syscall_main_table[] = { + LINXY(__NR_getrandom, sys_getrandom), // 384 + LINXY(__NR_memfd_create, sys_memfd_create), // 385 + ++ LINX_(__NR_copy_file_range, sys_copy_file_range), // 391 ++ + LINXY(__NR_statx, sys_statx), // 397 + }; + +commit c212b72a63e43be323a4e028bbdbe8b023c22be8 +Author: Mark Wielaard +Date: Wed May 15 21:30:00 2019 +0200 + + Explicitly make testcase variable for sys-copy_file_range undefined. + + On some systems an extra warning could occur when a variable in + the memcheck/tests/linux/sys-copy_file_range testcase was undefined, + but (accidentially) pointed to known bad memory. Fix by defining the + variable as 0, but then marking it explicitly undefined using memcheck + VALGRIND_MAKE_MEM_UNDEFINED. + + Followup for https://bugs.kde.org/show_bug.cgi?id=407218 + +diff --git a/memcheck/tests/linux/sys-copy_file_range.c b/memcheck/tests/linux/sys-copy_file_range.c +index 83981c6..589399c 100644 +--- a/memcheck/tests/linux/sys-copy_file_range.c ++++ b/memcheck/tests/linux/sys-copy_file_range.c +@@ -3,8 +3,8 @@ + #include + #include + #include +-#include + #include ++#include "../../memcheck.h" + + int main(int argc, char **argv) + { +@@ -51,7 +51,7 @@ int main(int argc, char **argv) + /* Check valgrind will produce expected warnings for the + various wrong arguments. */ + do { +- void *t; ++ void *t = 0; VALGRIND_MAKE_MEM_UNDEFINED (&t, sizeof (void *)); + void *z = (void *) -1; + + ret = copy_file_range(fd_in, t, fd_out, NULL, len, 0); +commit 033d013bebeb3471c0da47060deb9a5771e6c913 +Author: Mark Wielaard +Date: Fri May 24 21:51:31 2019 +0200 + + Fix memcheck/tests/linux/sys-copy_file_range open call (mode). + + sys-copy_file_range.c calls open with O_CREAT flag and so must provide + a mode argument. valgrind memcheck actually caught this ommission on + some arches (fedora rawhide i686 specifically). + + This is a small additional fixup for + https://bugs.kde.org/show_bug.cgi?id=407218 + +diff --git a/memcheck/tests/linux/sys-copy_file_range.c b/memcheck/tests/linux/sys-copy_file_range.c +index 589399c..3022fa1 100644 +--- a/memcheck/tests/linux/sys-copy_file_range.c ++++ b/memcheck/tests/linux/sys-copy_file_range.c +@@ -12,7 +12,7 @@ int main(int argc, char **argv) + struct stat stat; + loff_t len, ret; + +- fd_in = open("copy_file_range_source", O_CREAT | O_RDWR); ++ fd_in = open("copy_file_range_source", O_CREAT | O_RDWR, 0644); + if (fd_in == -1) { + perror("open copy_file_range_source"); + exit(EXIT_FAILURE); diff --git a/SOURCES/valgrind-3.15.0-disable-s390x-z13.patch b/SOURCES/valgrind-3.15.0-disable-s390x-z13.patch new file mode 100644 index 0000000..60df335 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-disable-s390x-z13.patch @@ -0,0 +1,34 @@ +diff -ur valgrind-3.14.0.orig/VEX/priv/guest_s390_helpers.c valgrind-3.14.0/VEX/priv/guest_s390_helpers.c +--- valgrind-3.14.0.orig/VEX/priv/guest_s390_helpers.c 2019-01-10 17:00:57.203206690 +0100 ++++ valgrind-3.14.0/VEX/priv/guest_s390_helpers.c 2019-01-10 17:06:23.335253900 +0100 +@@ -2469,7 +2469,7 @@ + /*--- Dirty helper for vector instructions ---*/ + /*------------------------------------------------------------*/ + +-#if defined(VGA_s390x) ++#if defined(VGA_s390x) && 0 /* disable for old binutils */ + ULong + s390x_dirtyhelper_vec_op(VexGuestS390XState *guest_state, + const ULong serialized) +diff -ur valgrind-3.14.0.orig/none/tests/s390x/Makefile.am valgrind-3.14.0/none/tests/s390x/Makefile.am +--- valgrind-3.14.0.orig/none/tests/s390x/Makefile.am 2019-01-10 17:00:57.411202894 +0100 ++++ valgrind-3.14.0/none/tests/s390x/Makefile.am 2019-01-10 17:10:28.963776813 +0100 +@@ -18,8 +18,7 @@ + spechelper-cr spechelper-clr \ + spechelper-ltr spechelper-or \ + spechelper-icm-1 spechelper-icm-2 spechelper-tmll \ +- spechelper-tm laa vector lsc2 ppno vector_string vector_integer \ +- vector_float ++ spechelper-tm laa + + if BUILD_DFP_TESTS + INSN_TESTS += dfp-1 dfp-2 dfp-3 dfp-4 dfptest dfpext dfpconv srnmt pfpo +@@ -68,8 +67,3 @@ + fixbr_CFLAGS = $(AM_CFLAGS) @FLAG_MLONG_DOUBLE_128@ + fpext_CFLAGS = $(AM_CFLAGS) @FLAG_MLONG_DOUBLE_128@ + ex_clone_LDADD = -lpthread +-vector_CFLAGS = $(AM_CFLAGS) -march=z13 +-lsc2_CFLAGS = -march=z13 -DS390_TESTS_NOCOLOR +-vector_string_CFLAGS = $(AM_CFLAGS) -march=z13 -DS390_TEST_COUNT=5 +-vector_integer_CFLAGS = $(AM_CFLAGS) -march=z13 -DS390_TEST_COUNT=4 +-vector_float_CFLAGS = $(AM_CFLAGS) -march=z13 -DS390_TEST_COUNT=4 diff --git a/SOURCES/valgrind-3.15.0-exp-sgcheck-no-aarch64.patch b/SOURCES/valgrind-3.15.0-exp-sgcheck-no-aarch64.patch new file mode 100644 index 0000000..69f13b3 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-exp-sgcheck-no-aarch64.patch @@ -0,0 +1,29 @@ +commit 59784c512ec40e588b21cf5ae8e31e9c4f99d6b8 +Author: Mark Wielaard +Date: Sat May 18 14:55:50 2019 +0200 + + aarch64 (arm64) isn't a supported architecture for exp-sgcheck. + + exp-sgcheck/pc_main.c contains: + + #if defined(VGA_arm) || defined(VGA_arm64) + VG_(printf)("SGCheck doesn't work on ARM yet, sorry.\n"); + VG_(exit)(1); + #endif + + But exp-sgcheck/tests/is_arch_supported checked against uname -m + which returns aarch64 (not arm64). Fix the test check so the + exp-sgcheck tests are skipped instead of producing failures. + +diff --git a/exp-sgcheck/tests/is_arch_supported b/exp-sgcheck/tests/is_arch_supported +index 818cc61..d4c6191 100755 +--- a/exp-sgcheck/tests/is_arch_supported ++++ b/exp-sgcheck/tests/is_arch_supported +@@ -10,6 +10,6 @@ + # architectures. + + case `uname -m` in +- ppc*|arm*|s390x|mips*) exit 1;; ++ ppc*|aarch64|arm*|s390x|mips*) exit 1;; + *) exit 0;; + esac diff --git a/SOURCES/valgrind-3.15.0-pkey.patch b/SOURCES/valgrind-3.15.0-pkey.patch new file mode 100644 index 0000000..3f534c5 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-pkey.patch @@ -0,0 +1,226 @@ +commit b064131bdf099d3647b4501e5d15391e1e9623e6 +Author: Mark Wielaard +Date: Thu May 30 00:29:58 2019 +0200 + + linux x86 and amd64 memory protection key syscalls. + + This implements minimal support for the pkey_alloc, pkey_free and + pkey_mprotect syscalls. pkey_alloc will simply indicate that pkeys + are not supported. pkey_free always fails. pkey_mprotect works just + like mprotect if the special pkey -1 is provided. + + https://bugs.kde.org/show_bug.cgi?id=408091 + +diff --git a/coregrind/m_syswrap/priv_syswrap-generic.h b/coregrind/m_syswrap/priv_syswrap-generic.h +index 88530f0..3e1c8b6 100644 +--- a/coregrind/m_syswrap/priv_syswrap-generic.h ++++ b/coregrind/m_syswrap/priv_syswrap-generic.h +@@ -106,6 +106,10 @@ extern Bool + ML_(handle_auxv_open)(SyscallStatus *status, const HChar *filename, + int flags); + ++/* Helper function for generic mprotect and linux pkey_mprotect. */ ++extern void handle_sys_mprotect (ThreadId tid, SyscallStatus *status, ++ Addr *addr, SizeT *len, Int *prot); ++ + DECL_TEMPLATE(generic, sys_ni_syscall); // * P -- unimplemented + DECL_TEMPLATE(generic, sys_exit); + DECL_TEMPLATE(generic, sys_fork); +diff --git a/coregrind/m_syswrap/priv_syswrap-linux.h b/coregrind/m_syswrap/priv_syswrap-linux.h +index 5cf5407..2471524 100644 +--- a/coregrind/m_syswrap/priv_syswrap-linux.h ++++ b/coregrind/m_syswrap/priv_syswrap-linux.h +@@ -299,6 +299,11 @@ DECL_TEMPLATE(linux, sys_bpf); + // Linux-specific (new in Linux 4.11) + DECL_TEMPLATE(linux, sys_statx); + ++// Linux-specific memory protection key syscalls (since Linux 4.9) ++DECL_TEMPLATE(linux, sys_pkey_alloc); ++DECL_TEMPLATE(linux, sys_pkey_free); ++DECL_TEMPLATE(linux, sys_pkey_mprotect); ++ + /* --------------------------------------------------------------------- + Wrappers for sockets and ipc-ery. These are split into standalone + procedures because x86-linux hides them inside multiplexors +diff --git a/coregrind/m_syswrap/syswrap-amd64-linux.c b/coregrind/m_syswrap/syswrap-amd64-linux.c +index d4fe413..2d6b95f 100644 +--- a/coregrind/m_syswrap/syswrap-amd64-linux.c ++++ b/coregrind/m_syswrap/syswrap-amd64-linux.c +@@ -863,6 +863,10 @@ static SyscallTableEntry syscall_table[] = { + LINX_(__NR_membarrier, sys_membarrier), // 324 + + LINX_(__NR_copy_file_range, sys_copy_file_range), // 326 ++ ++ LINXY(__NR_pkey_mprotect, sys_pkey_mprotect), // 329 ++ LINX_(__NR_pkey_alloc, sys_pkey_alloc), // 330 ++ LINX_(__NR_pkey_free, sys_pkey_free), // 331 + }; + + SyscallTableEntry* ML_(get_linux_syscall_entry) ( UInt sysno ) +diff --git a/coregrind/m_syswrap/syswrap-generic.c b/coregrind/m_syswrap/syswrap-generic.c +index 0b64919..01191f6 100644 +--- a/coregrind/m_syswrap/syswrap-generic.c ++++ b/coregrind/m_syswrap/syswrap-generic.c +@@ -3842,12 +3842,28 @@ PRE(sys_mprotect) + PRE_REG_READ3(long, "mprotect", + unsigned long, addr, vki_size_t, len, unsigned long, prot); + +- if (!ML_(valid_client_addr)(ARG1, ARG2, tid, "mprotect")) { ++ Addr addr = ARG1; ++ SizeT len = ARG2; ++ Int prot = ARG3; ++ ++ handle_sys_mprotect (tid, status, &addr, &len, &prot); ++ ++ ARG1 = addr; ++ ARG2 = len; ++ ARG3 = prot; ++} ++/* This will be called from the generic mprotect, or the linux specific ++ pkey_mprotect. Pass pointers to ARG1, ARG2 and ARG3 as addr, len and prot, ++ they might be adjusted and have to assigned back to ARG1, ARG2 and ARG3. */ ++void handle_sys_mprotect(ThreadId tid, SyscallStatus* status, ++ Addr *addr, SizeT *len, Int *prot) ++{ ++ if (!ML_(valid_client_addr)(*addr, *len, tid, "mprotect")) { + SET_STATUS_Failure( VKI_ENOMEM ); + } + #if defined(VKI_PROT_GROWSDOWN) + else +- if (ARG3 & (VKI_PROT_GROWSDOWN|VKI_PROT_GROWSUP)) { ++ if (*prot & (VKI_PROT_GROWSDOWN|VKI_PROT_GROWSUP)) { + /* Deal with mprotects on growable stack areas. + + The critical files to understand all this are mm/mprotect.c +@@ -3862,8 +3878,8 @@ PRE(sys_mprotect) + + The sanity check provided by the kernel is that the vma must + have the VM_GROWSDOWN/VM_GROWSUP flag set as appropriate. */ +- UInt grows = ARG3 & (VKI_PROT_GROWSDOWN|VKI_PROT_GROWSUP); +- NSegment const *aseg = VG_(am_find_nsegment)(ARG1); ++ UInt grows = *prot & (VKI_PROT_GROWSDOWN|VKI_PROT_GROWSUP); ++ NSegment const *aseg = VG_(am_find_nsegment)(*addr); + NSegment const *rseg; + + vg_assert(aseg); +@@ -3874,10 +3890,10 @@ PRE(sys_mprotect) + && rseg->kind == SkResvn + && rseg->smode == SmUpper + && rseg->end+1 == aseg->start) { +- Addr end = ARG1 + ARG2; +- ARG1 = aseg->start; +- ARG2 = end - aseg->start; +- ARG3 &= ~VKI_PROT_GROWSDOWN; ++ Addr end = *addr + *len; ++ *addr = aseg->start; ++ *len = end - aseg->start; ++ *prot &= ~VKI_PROT_GROWSDOWN; + } else { + SET_STATUS_Failure( VKI_EINVAL ); + } +@@ -3887,8 +3903,8 @@ PRE(sys_mprotect) + && rseg->kind == SkResvn + && rseg->smode == SmLower + && aseg->end+1 == rseg->start) { +- ARG2 = aseg->end - ARG1 + 1; +- ARG3 &= ~VKI_PROT_GROWSUP; ++ *len = aseg->end - *addr + 1; ++ *prot &= ~VKI_PROT_GROWSUP; + } else { + SET_STATUS_Failure( VKI_EINVAL ); + } +diff --git a/coregrind/m_syswrap/syswrap-linux.c b/coregrind/m_syswrap/syswrap-linux.c +index 810ca24..5452b8d 100644 +--- a/coregrind/m_syswrap/syswrap-linux.c ++++ b/coregrind/m_syswrap/syswrap-linux.c +@@ -12120,6 +12120,76 @@ PRE(sys_copy_file_range) + } + } + ++PRE(sys_pkey_alloc) ++{ ++ PRINT("pkey_alloc (%lu, %lu)", ARG1, ARG2); ++ ++ PRE_REG_READ2(long, "pkey_alloc", ++ unsigned long, "flags", ++ unsigned long, "access_rights"); ++ ++ /* The kernel says: pkey_alloc() is always safe to call regardless of ++ whether or not the operating system supports protection keys. It can be ++ used in lieu of any other mechanism for detecting pkey support and will ++ simply fail with the error ENOSPC if the operating system has no pkey ++ support. ++ ++ So we simply always return ENOSPC to signal memory protection keys are ++ not supported under valgrind, unless there are unknown flags, then we ++ return EINVAL. */ ++ unsigned long pkey_flags = ARG1; ++ if (pkey_flags != 0) ++ SET_STATUS_Failure( VKI_EINVAL ); ++ else ++ SET_STATUS_Failure( VKI_ENOSPC ); ++} ++ ++PRE(sys_pkey_free) ++{ ++ PRINT("pkey_free (%" FMT_REGWORD "u )", ARG1); ++ ++ PRE_REG_READ1(long, "pkey_free", ++ unsigned long, "pkey"); ++ ++ /* Since pkey_alloc () can never succeed, see above, freeing any pkey is ++ always an error. */ ++ SET_STATUS_Failure( VKI_EINVAL ); ++} ++ ++PRE(sys_pkey_mprotect) ++{ ++ PRINT("sys_pkey_mprotect ( %#" FMT_REGWORD "x, %" FMT_REGWORD "u, %" ++ FMT_REGWORD "u %" FMT_REGWORD "u )", ARG1, ARG2, ARG3, ARG4); ++ PRE_REG_READ4(long, "pkey_mprotect", ++ unsigned long, addr, vki_size_t, len, unsigned long, prot, ++ unsigned long, pkey); ++ ++ Addr addr = ARG1; ++ SizeT len = ARG2; ++ Int prot = ARG3; ++ Int pkey = ARG4; ++ ++ /* Since pkey_alloc () can never succeed, see above, any pkey is ++ invalid. Except for -1, then pkey_mprotect acts just like mprotect. */ ++ if (pkey != -1) ++ SET_STATUS_Failure( VKI_EINVAL ); ++ else ++ handle_sys_mprotect (tid, status, &addr, &len, &prot); ++ ++ ARG1 = addr; ++ ARG2 = len; ++ ARG3 = prot; ++} ++ ++POST(sys_pkey_mprotect) ++{ ++ Addr addr = ARG1; ++ SizeT len = ARG2; ++ Int prot = ARG3; ++ ++ ML_(notify_core_and_tool_of_mprotect)(addr, len, prot); ++} ++ + + #undef PRE + #undef POST +diff --git a/coregrind/m_syswrap/syswrap-x86-linux.c b/coregrind/m_syswrap/syswrap-x86-linux.c +index ad54cf6..3829fa4 100644 +--- a/coregrind/m_syswrap/syswrap-x86-linux.c ++++ b/coregrind/m_syswrap/syswrap-x86-linux.c +@@ -1608,6 +1608,9 @@ static SyscallTableEntry syscall_table[] = { + + LINX_(__NR_copy_file_range, sys_copy_file_range), // 377 + ++ LINXY(__NR_pkey_mprotect, sys_pkey_mprotect), // 380 ++ LINX_(__NR_pkey_alloc, sys_pkey_alloc), // 381 ++ LINX_(__NR_pkey_free, sys_pkey_free), // 382 + LINXY(__NR_statx, sys_statx), // 383 + + /* Explicitly not supported on i386 yet. */ diff --git a/SOURCES/valgrind-3.15.0-pkglibexecdir.patch b/SOURCES/valgrind-3.15.0-pkglibexecdir.patch new file mode 100644 index 0000000..cd52729 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-pkglibexecdir.patch @@ -0,0 +1,117 @@ +diff --git a/Makefile.all.am b/Makefile.all.am +index 3786e34..1befef5 100644 +--- a/Makefile.all.am ++++ b/Makefile.all.am +@@ -50,20 +50,20 @@ inplace-noinst_DSYMS: build-noinst_DSYMS + done + + # This is used by coregrind/Makefile.am and by /Makefile.am for doing +-# "make install". It copies $(noinst_PROGRAMS) into $prefix/lib/valgrind/. ++# "make install". It copies $(noinst_PROGRAMS) into $prefix/libexec/valgrind/. + # It needs to be depended on by an 'install-exec-local' rule. + install-noinst_PROGRAMS: $(noinst_PROGRAMS) +- $(mkinstalldirs) $(DESTDIR)$(pkglibdir); \ ++ $(mkinstalldirs) $(DESTDIR)$(pkglibexecdir); \ + for f in $(noinst_PROGRAMS); do \ +- $(INSTALL_PROGRAM) $$f $(DESTDIR)$(pkglibdir); \ ++ $(INSTALL_PROGRAM) $$f $(DESTDIR)$(pkglibexecdir); \ + done + + # This is used by coregrind/Makefile.am and by /Makefile.am for doing +-# "make uninstall". It removes $(noinst_PROGRAMS) from $prefix/lib/valgrind/. ++# "make uninstall". It removes $(noinst_PROGRAMS) from $prefix/libexec/valgrind/. + # It needs to be depended on by an 'uninstall-local' rule. + uninstall-noinst_PROGRAMS: + for f in $(noinst_PROGRAMS); do \ +- rm -f $(DESTDIR)$(pkglibdir)/$$f; \ ++ rm -f $(DESTDIR)$(pkglibexecdir)/$$f; \ + done + + # Similar to install-noinst_PROGRAMS. +@@ -71,15 +71,15 @@ uninstall-noinst_PROGRAMS: + # directories. XXX: not sure whether the resulting permissions will be + # correct when using 'cp -R'... + install-noinst_DSYMS: build-noinst_DSYMS +- $(mkinstalldirs) $(DESTDIR)$(pkglibdir); \ ++ $(mkinstalldirs) $(DESTDIR)$(pkglibexecdir); \ + for f in $(noinst_DSYMS); do \ +- cp -R $$f.dSYM $(DESTDIR)$(pkglibdir); \ ++ cp -R $$f.dSYM $(DESTDIR)$(pkglibexecdir); \ + done + + # Similar to uninstall-noinst_PROGRAMS. + uninstall-noinst_DSYMS: + for f in $(noinst_DSYMS); do \ +- rm -f $(DESTDIR)$(pkglibdir)/$$f.dSYM; \ ++ rm -f $(DESTDIR)$(pkglibexecdir)/$$f.dSYM; \ + done + + # This needs to be depended on by a 'clean-local' rule. +diff --git a/Makefile.am b/Makefile.am +index 242b38a..3b7c806 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -58,7 +58,7 @@ DEFAULT_SUPP_FILES = @DEFAULT_SUPP@ + # default.supp, as it is built from the base .supp files at compile-time. + dist_noinst_DATA = $(SUPP_FILES) + +-vglibdir = $(pkglibdir) ++vglibdir = $(pkglibexecdir) + vglib_DATA = default.supp + + pkgconfigdir = $(libdir)/pkgconfig +diff --git a/coregrind/Makefile.am b/coregrind/Makefile.am +index 94030fd..f09763a 100644 +--- a/coregrind/Makefile.am ++++ b/coregrind/Makefile.am +@@ -11,12 +11,12 @@ include $(top_srcdir)/Makefile.all.am + + AM_CPPFLAGS_@VGCONF_PLATFORM_PRI_CAPS@ += \ + -I$(top_srcdir)/coregrind \ +- -DVG_LIBDIR="\"$(pkglibdir)"\" \ ++ -DVG_LIBDIR="\"$(pkglibexecdir)"\" \ + -DVG_PLATFORM="\"@VGCONF_ARCH_PRI@-@VGCONF_OS@\"" + if VGCONF_HAVE_PLATFORM_SEC + AM_CPPFLAGS_@VGCONF_PLATFORM_SEC_CAPS@ += \ + -I$(top_srcdir)/coregrind \ +- -DVG_LIBDIR="\"$(pkglibdir)"\" \ ++ -DVG_LIBDIR="\"$(pkglibexecdir)"\" \ + -DVG_PLATFORM="\"@VGCONF_ARCH_SEC@-@VGCONF_OS@\"" + endif + +@@ -714,7 +714,7 @@ GDBSERVER_XML_FILES = \ + m_gdbserver/mips64-fpu.xml + + # so as to make sure these get copied into the install tree +-vglibdir = $(pkglibdir) ++vglibdir = $(pkglibexecdir) + vglib_DATA = $(GDBSERVER_XML_FILES) + + # so as to make sure these get copied into the tarball +diff --git a/mpi/Makefile.am b/mpi/Makefile.am +index 7ad9a25..471fee0 100644 +--- a/mpi/Makefile.am ++++ b/mpi/Makefile.am +@@ -18,16 +18,18 @@ EXTRA_DIST = \ + # libmpiwrap-.so + #---------------------------------------------------------------------------- + +-noinst_PROGRAMS = ++# These are really real libraries, so they should go to libdir, not libexec. ++mpidir = $(pkglibdir) ++mpi_PROGRAMS = + if BUILD_MPIWRAP_PRI +-noinst_PROGRAMS += libmpiwrap-@VGCONF_ARCH_PRI@-@VGCONF_OS@.so ++mpi_PROGRAMS += libmpiwrap-@VGCONF_ARCH_PRI@-@VGCONF_OS@.so + endif + if BUILD_MPIWRAP_SEC +-noinst_PROGRAMS += libmpiwrap-@VGCONF_ARCH_SEC@-@VGCONF_OS@.so ++mpi_PROGRAMS += libmpiwrap-@VGCONF_ARCH_SEC@-@VGCONF_OS@.so + endif + + if VGCONF_OS_IS_DARWIN +-noinst_DSYMS = $(noinst_PROGRAMS) ++mpi_DSYMS = $(mpi_PROGRAMS) + endif + + diff --git a/SOURCES/valgrind-3.15.0-ppc64-filter_gdb.patch b/SOURCES/valgrind-3.15.0-ppc64-filter_gdb.patch new file mode 100644 index 0000000..b4137fe --- /dev/null +++ b/SOURCES/valgrind-3.15.0-ppc64-filter_gdb.patch @@ -0,0 +1,22 @@ +commit b1cc37ddb660afc536131227a9fb452ac9328972 +Author: Alexandra Hájková +Date: Mon Apr 15 15:34:12 2019 +0200 + + filter_gdb: add regexp to filter out names which starts with a "." + + such names are used for "function descriptors" on ppc64 + + https://bugs.kde.org/show_bug.cgi?id=406561 + +diff --git a/gdbserver_tests/filter_gdb b/gdbserver_tests/filter_gdb +index 6eff229..fd2e8e7 100755 +--- a/gdbserver_tests/filter_gdb ++++ b/gdbserver_tests/filter_gdb +@@ -119,6 +119,7 @@ sed -e '/Remote debugging using/,/vgdb launched process attached/d' + -e 's/in select ()$/in syscall .../' \ + -e 's/in \.__select ()$/in syscall .../' \ + -e 's/in select () at \.\.\/sysdeps\/unix\/syscall-template\.S.*$/in syscall .../' \ ++ -e 's/in \.__select () at \.\.\/sysdeps\/unix\/syscall-template\.S.*$/in syscall .../' \ + -e '/^[ ]*at \.\.\/sysdeps\/unix\/syscall-template\.S/d' \ + -e '/^[ ]*in \.\.\/sysdeps\/unix\/syscall-template\.S/d' \ + -e '/^[1-9][0-9]*[ ]*\.\.\/sysdeps\/unix\/syscall-template\.S/d' \ diff --git a/SOURCES/valgrind-3.15.0-preadv2-pwritev2.patch b/SOURCES/valgrind-3.15.0-preadv2-pwritev2.patch new file mode 100644 index 0000000..eb17a7e --- /dev/null +++ b/SOURCES/valgrind-3.15.0-preadv2-pwritev2.patch @@ -0,0 +1,751 @@ +commit b0861063a8d2a55bb7423e90d26806bab0f78a12 +Author: Alexandra Hájková +Date: Tue Jun 4 13:47:14 2019 +0200 + + Add support for preadv2 and pwritev2 syscalls + + Support for amd64, x86 - 64 and 32 bit, arm64, ppc64, ppc64le, + s390x, mips64. This should work identically on all + arches, tested on x86 32bit and 64bit one, but enabled on all. + + Refactor the code to be reusable between old/new syscalls. Resolve TODO + items in the code. Add the testcase for the preadv2/pwritev2 and also + add the (similar) testcase for the older preadv/pwritev syscalls. + + Trying to test handling an uninitialized flag argument for the v2 syscalls + does not work because the flag always comes out as defined zero. + Turns out glibc does this deliberately on 64bit architectures because + the kernel does actually have a low_offset and high_offset argument, but + ignores the high_offset/assumes it is zero. + https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=601cc11d054ae4b5e9b5babec3d8e4667a2cb9b5 + + https://bugs.kde.org/408414 + +diff --git a/configure.ac b/configure.ac +index 352892565..3596d2fec 100755 +--- a/configure.ac ++++ b/configure.ac +@@ -4173,6 +4173,10 @@ AC_CHECK_FUNCS([ \ + process_vm_readv \ + process_vm_writev \ + copy_file_range \ ++ preadv \ ++ pwritev \ ++ preadv2 \ ++ pwritev2 \ + ]) + + # AC_CHECK_LIB adds any library found to the variable LIBS, and links these +@@ -4190,6 +4194,10 @@ AM_CONDITIONAL([HAVE_PTHREAD_SETNAME_NP], + [test x$ac_cv_func_pthread_setname_np = xyes]) + AM_CONDITIONAL([HAVE_COPY_FILE_RANGE], + [test x$ac_cv_func_copy_file_range = xyes]) ++AM_CONDITIONAL([HAVE_PREADV_PWRITEV], ++ [test x$ac_cv_func_preadv = xyes && test x$ac_cv_func_pwritev = xyes]) ++AM_CONDITIONAL([HAVE_PREADV2_PWRITEV2], ++ [test x$ac_cv_func_preadv2 = xyes && test x$ac_cv_func_pwritev2 = xyes]) + + if test x$VGCONF_PLATFORM_PRI_CAPS = xMIPS32_LINUX \ + -o x$VGCONF_PLATFORM_PRI_CAPS = xMIPS64_LINUX ; then +diff --git a/coregrind/m_syswrap/priv_syswrap-generic.h b/coregrind/m_syswrap/priv_syswrap-generic.h +index 3e1c8b682..73f9224f7 100644 +--- a/coregrind/m_syswrap/priv_syswrap-generic.h ++++ b/coregrind/m_syswrap/priv_syswrap-generic.h +@@ -109,6 +109,19 @@ ML_(handle_auxv_open)(SyscallStatus *status, const HChar *filename, + /* Helper function for generic mprotect and linux pkey_mprotect. */ + extern void handle_sys_mprotect (ThreadId tid, SyscallStatus *status, + Addr *addr, SizeT *len, Int *prot); ++/* Helper functions for preadv/preadv2. */ ++extern ++void handle_pre_sys_preadv(ThreadId tid, SyscallStatus* status, ++ Int fd, Addr vector, Int count, ++ const char *str); ++extern ++void handle_post_sys_preadv(ThreadId tid, SyscallStatus* status, Addr vector, Int count); ++ ++/* Helper function for pwritev/pwritev2. */ ++extern ++void handle_sys_pwritev(ThreadId tid, SyscallStatus* status, ++ Int fd, Addr vector, Int count, ++ const char *str); + + DECL_TEMPLATE(generic, sys_ni_syscall); // * P -- unimplemented + DECL_TEMPLATE(generic, sys_exit); +diff --git a/coregrind/m_syswrap/priv_syswrap-linux.h b/coregrind/m_syswrap/priv_syswrap-linux.h +index be2f9bdde..8ce8ef3d5 100644 +--- a/coregrind/m_syswrap/priv_syswrap-linux.h ++++ b/coregrind/m_syswrap/priv_syswrap-linux.h +@@ -46,7 +46,9 @@ DECL_TEMPLATE(linux, sys_oldumount); + DECL_TEMPLATE(linux, sys_umount); + DECL_TEMPLATE(linux, sys_perf_event_open); + DECL_TEMPLATE(linux, sys_preadv); ++DECL_TEMPLATE(linux, sys_preadv2); + DECL_TEMPLATE(linux, sys_pwritev); ++DECL_TEMPLATE(linux, sys_pwritev2); + DECL_TEMPLATE(linux, sys_sendmmsg); + DECL_TEMPLATE(linux, sys_recvmmsg); + DECL_TEMPLATE(linux, sys_dup3); +diff --git a/coregrind/m_syswrap/syswrap-amd64-linux.c b/coregrind/m_syswrap/syswrap-amd64-linux.c +index 382dc65cf..9b8068d0f 100644 +--- a/coregrind/m_syswrap/syswrap-amd64-linux.c ++++ b/coregrind/m_syswrap/syswrap-amd64-linux.c +@@ -857,6 +857,8 @@ static SyscallTableEntry syscall_table[] = { + // LIN__(__NR_kexec_file_load, sys_ni_syscall), // 320 + LINXY(__NR_bpf, sys_bpf), // 321 + ++ LINXY(__NR_preadv2, sys_preadv2), // 327 ++ LINX_(__NR_pwritev2, sys_pwritev2), // 328 + + LINXY(__NR_statx, sys_statx), // 332 + +diff --git a/coregrind/m_syswrap/syswrap-arm64-linux.c b/coregrind/m_syswrap/syswrap-arm64-linux.c +index c700e3dbe..d12d40632 100644 +--- a/coregrind/m_syswrap/syswrap-arm64-linux.c ++++ b/coregrind/m_syswrap/syswrap-arm64-linux.c +@@ -818,8 +818,8 @@ static SyscallTableEntry syscall_main_table[] = { + LINX_(__NR_membarrier, sys_membarrier), // 283 + // (__NR_mlock2, sys_ni_syscall), // 284 + LINX_(__NR_copy_file_range, sys_copy_file_range), // 285 +- // (__NR_preadv2, sys_ni_syscall), // 286 +- // (__NR_pwritev2, sys_ni_syscall), // 287 ++ LINX_(__NR_preadv2, sys_ni_syscall), // 286 ++ LINX_(__NR_pwritev2, sys_ni_syscall), // 287 + // (__NR_pkey_mprotect, sys_ni_syscall), // 288 + // (__NR_pkey_alloc, sys_ni_syscall), // 289 + // (__NR_pkey_free, sys_ni_syscall), // 290 +diff --git a/coregrind/m_syswrap/syswrap-linux.c b/coregrind/m_syswrap/syswrap-linux.c +index 36d09d6e0..2fe15d97b 100644 +--- a/coregrind/m_syswrap/syswrap-linux.c ++++ b/coregrind/m_syswrap/syswrap-linux.c +@@ -5501,12 +5501,57 @@ POST(sys_open_by_handle_at) + /* --------------------------------------------------------------------- + p{read,write}v wrappers + ------------------------------------------------------------------ */ ++/* This handles the common part of the PRE macro for preadv and preadv2. */ ++void handle_pre_sys_preadv(ThreadId tid, SyscallStatus* status, ++ Int fd, Addr vector, Int count, const char *str) ++{ ++ struct vki_iovec * vec; ++ Int i; ++ /* safe size for the "preadv/preadv2(vector[i])" string */ ++ char tmp[30]; ++ ++ if (!ML_(fd_allowed)(fd, str, tid, False)) { ++ SET_STATUS_Failure( VKI_EBADF ); ++ } else if (count > 0) { ++ VG_(strcpy) (tmp, str); ++ VG_(strcat) (tmp, "(vector)"); ++ PRE_MEM_READ( tmp, vector, count * sizeof(struct vki_iovec) ); ++ ++ if (ML_(safe_to_deref) ((void *)(Addr)vector, ++ count * sizeof(struct vki_iovec))) { ++ vec = (struct vki_iovec *)(Addr)vector; ++ for (i = 0; i < count; i++) { ++ VG_(snprintf) (tmp, 30, "%s(vector[%d])", str, i); ++ PRE_MEM_WRITE( tmp, (Addr)vec[i].iov_base, vec[i].iov_len ); ++ } ++ } ++ } ++} ++ ++/* This handles the common part of the POST macro for preadv and preadv2. */ ++void handle_post_sys_preadv(ThreadId tid, SyscallStatus* status, Addr vector, Int count) ++{ ++ vg_assert(SUCCESS); ++ if (RES > 0) { ++ Int i; ++ struct vki_iovec * vec = (struct vki_iovec *)(Addr)vector; ++ Int remains = RES; ++ ++ /* RES holds the number of bytes read. */ ++ for (i = 0; i < count; i++) { ++ Int nReadThisBuf = vec[i].iov_len; ++ if (nReadThisBuf > remains) nReadThisBuf = remains; ++ POST_MEM_WRITE( (Addr)vec[i].iov_base, nReadThisBuf ); ++ remains -= nReadThisBuf; ++ if (remains < 0) VG_(core_panic)("preadv: remains < 0"); ++ } ++ } ++} + + PRE(sys_preadv) + { +- Int i; +- struct vki_iovec * vec; + *flags |= SfMayBlock; ++ const char *str = "preadv"; + #if VG_WORDSIZE == 4 + /* Note that the offset argument here is in lo+hi order on both + big and little endian platforms... */ +@@ -5525,45 +5570,89 @@ PRE(sys_preadv) + #else + # error Unexpected word size + #endif +- if (!ML_(fd_allowed)(ARG1, "preadv", tid, False)) { +- SET_STATUS_Failure( VKI_EBADF ); +- } else { +- PRE_MEM_READ( "preadv(vector)", ARG2, ARG3 * sizeof(struct vki_iovec) ); ++ Int fd = ARG1; ++ Addr vector = ARG2; ++ Int count = ARG3; ++ ++ handle_pre_sys_preadv(tid, status, fd, vector, count, str); + +- if (ARG2 != 0) { +- /* ToDo: don't do any of the following if the vector is invalid */ +- vec = (struct vki_iovec *)(Addr)ARG2; +- for (i = 0; i < (Int)ARG3; i++) +- PRE_MEM_WRITE( "preadv(vector[...])", +- (Addr)vec[i].iov_base, vec[i].iov_len ); +- } +- } + } + + POST(sys_preadv) + { +- vg_assert(SUCCESS); +- if (RES > 0) { +- Int i; +- struct vki_iovec * vec = (struct vki_iovec *)(Addr)ARG2; +- Int remains = RES; ++ Addr vector = ARG2; ++ Int count = ARG3; + +- /* RES holds the number of bytes read. */ +- for (i = 0; i < (Int)ARG3; i++) { +- Int nReadThisBuf = vec[i].iov_len; +- if (nReadThisBuf > remains) nReadThisBuf = remains; +- POST_MEM_WRITE( (Addr)vec[i].iov_base, nReadThisBuf ); +- remains -= nReadThisBuf; +- if (remains < 0) VG_(core_panic)("preadv: remains < 0"); ++ handle_post_sys_preadv(tid, status, vector, count); ++} ++ ++PRE(sys_preadv2) ++{ ++ *flags |= SfMayBlock; ++ const char *str = "preadv2"; ++#if VG_WORDSIZE == 4 ++ /* Note that the offset argument here is in lo+hi order on both ++ big and little endian platforms... */ ++ PRINT("sys_preadv2 ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD ++ "u, %lld, %" FMT_REGWORD "u )", ++ ARG1, ARG2, ARG3, (Long)LOHI64(ARG4,ARG5), ARG6); ++ PRE_REG_READ6(ssize_t, "preadv2", ++ unsigned long, fd, const struct iovec *, vector, ++ unsigned long, count, vki_u32, offset_low, ++ vki_u32, offset_high, unsigned long, flags); ++#elif VG_WORDSIZE == 8 ++ PRINT("sys_preadv2 ( %lu, %#lx, %lu, %ld, %lu )", ARG1, ARG2, ARG3, SARG4, ARG5); ++ PRE_REG_READ5(ssize_t, "preadv2", ++ unsigned long, fd, const struct iovec *, vector, ++ unsigned long, count, Word, offset, unsigned long, flags); ++#else ++# error Unexpected word size ++#endif ++ Int fd = ARG1; ++ Addr vector = ARG2; ++ Int count = ARG3; ++ ++ handle_pre_sys_preadv(tid, status, fd, vector, count, str); ++} ++ ++POST(sys_preadv2) ++{ ++ Addr vector = ARG2; ++ Int count = ARG3; ++ ++ handle_post_sys_preadv(tid, status, vector, count); ++} ++ ++/* This handles the common part of the PRE macro for pwritev and pwritev2. */ ++void handle_sys_pwritev(ThreadId tid, SyscallStatus* status, ++ Int fd, Addr vector, Int count, const char *str) ++{ ++ Int i; ++ struct vki_iovec * vec; ++ /* safe size for the "preadv/preadv2(vector[i])" string */ ++ char tmp[30]; ++ ++ if (!ML_(fd_allowed)(fd, str, tid, False)) { ++ SET_STATUS_Failure( VKI_EBADF ); ++ } else if (count > 0) { ++ VG_(strcpy) (tmp, str); ++ VG_(strcat) (tmp, "(vector)"); ++ PRE_MEM_READ( tmp, vector, count * sizeof(struct vki_iovec) ); ++ if (ML_(safe_to_deref) ((void *)(Addr)vector, ++ count * sizeof(struct vki_iovec))) { ++ vec = (struct vki_iovec *)(Addr)vector; ++ for (i = 0; i < count; i++) { ++ VG_(snprintf) (tmp, 30, "%s(vector[%d])", str, i); ++ PRE_MEM_READ( tmp, (Addr)vec[i].iov_base, vec[i].iov_len ); ++ } + } + } + } + + PRE(sys_pwritev) + { +- Int i; +- struct vki_iovec * vec; + *flags |= SfMayBlock; ++ const char *str = "pwritev"; + #if VG_WORDSIZE == 4 + /* Note that the offset argument here is in lo+hi order on both + big and little endian platforms... */ +@@ -5581,19 +5670,41 @@ PRE(sys_pwritev) + #else + # error Unexpected word size + #endif +- if (!ML_(fd_allowed)(ARG1, "pwritev", tid, False)) { +- SET_STATUS_Failure( VKI_EBADF ); +- } else { +- PRE_MEM_READ( "pwritev(vector)", +- ARG2, ARG3 * sizeof(struct vki_iovec) ); +- if (ARG2 != 0) { +- /* ToDo: don't do any of the following if the vector is invalid */ +- vec = (struct vki_iovec *)(Addr)ARG2; +- for (i = 0; i < (Int)ARG3; i++) +- PRE_MEM_READ( "pwritev(vector[...])", +- (Addr)vec[i].iov_base, vec[i].iov_len ); +- } +- } ++ Int fd = ARG1; ++ Addr vector = ARG2; ++ Int count = ARG3; ++ ++ handle_sys_pwritev(tid, status, fd, vector, count, str); ++} ++ ++PRE(sys_pwritev2) ++{ ++ *flags |= SfMayBlock; ++ const char *str = "pwritev2"; ++#if VG_WORDSIZE == 4 ++ /* Note that the offset argument here is in lo+hi order on both ++ big and little endian platforms... */ ++ PRINT("sys_pwritev2 ( %" FMT_REGWORD "u, %#" FMT_REGWORD "x, %" FMT_REGWORD ++ "u, %lld, %" FMT_REGWORD "u )", ++ ARG1, ARG2, ARG3, (Long)LOHI64(ARG4,ARG5), ARG6); ++ PRE_REG_READ6(ssize_t, "pwritev2", ++ unsigned long, fd, const struct iovec *, vector, ++ unsigned long, count, vki_u32, offset_low, ++ vki_u32, offset_high, unsigned long, flags); ++#elif VG_WORDSIZE == 8 ++ /* Note offset_high isn't actually used? */ ++ PRE_REG_READ6(ssize_t, "pwritev2", ++ unsigned long, fd, const struct iovec *, vector, ++ unsigned long, count, Word, offset, ++ Word, offset_high, unsigned long, flags); ++#else ++# error Unexpected word size ++#endif ++ Int fd = ARG1; ++ Addr vector = ARG2; ++ Int count = ARG3; ++ ++ handle_sys_pwritev(tid, status, fd, vector, count, str); + } + + /* --------------------------------------------------------------------- +diff --git a/coregrind/m_syswrap/syswrap-ppc64-linux.c b/coregrind/m_syswrap/syswrap-ppc64-linux.c +index baa2934ab..d65a664dd 100644 +--- a/coregrind/m_syswrap/syswrap-ppc64-linux.c ++++ b/coregrind/m_syswrap/syswrap-ppc64-linux.c +@@ -1006,6 +1006,8 @@ static SyscallTableEntry syscall_table[] = { + LINX_(__NR_membarrier, sys_membarrier), // 365 + + LINX_(__NR_copy_file_range, sys_copy_file_range), // 379 ++ LINX_(__NR_preadv2, sys_preadv2), // 380 ++ LINX_(__NR_pwritev2, sys_pwritev2), // 381 + + LINXY(__NR_statx, sys_statx), // 383 + }; +diff --git a/coregrind/m_syswrap/syswrap-s390x-linux.c b/coregrind/m_syswrap/syswrap-s390x-linux.c +index 1481e768b..3354d41c0 100644 +--- a/coregrind/m_syswrap/syswrap-s390x-linux.c ++++ b/coregrind/m_syswrap/syswrap-s390x-linux.c +@@ -853,6 +853,8 @@ static SyscallTableEntry syscall_table[] = { + LINX_(__NR_shutdown, sys_shutdown), // 373 + + LINX_(__NR_copy_file_range, sys_copy_file_range), // 375 ++ LINXY(__NR_preadv2, sys_preadv2), // 376 ++ LINX_(__NR_pwritev2, sys_pwritev2), // 377 + + LINXY(__NR_statx, sys_statx), // 379 + }; +diff --git a/coregrind/m_syswrap/syswrap-x86-linux.c b/coregrind/m_syswrap/syswrap-x86-linux.c +index 9ff53a92a..33d1213a3 100644 +--- a/coregrind/m_syswrap/syswrap-x86-linux.c ++++ b/coregrind/m_syswrap/syswrap-x86-linux.c +@@ -1607,6 +1607,8 @@ static SyscallTableEntry syscall_table[] = { + LINX_(__NR_membarrier, sys_membarrier), // 375 + + LINX_(__NR_copy_file_range, sys_copy_file_range), // 377 ++ LINXY(__NR_preadv2, sys_preadv2), // 378 ++ LINX_(__NR_pwritev2, sys_pwritev2), // 379 + + LINXY(__NR_pkey_mprotect, sys_pkey_mprotect), // 380 + LINX_(__NR_pkey_alloc, sys_pkey_alloc), // 381 +diff --git a/memcheck/tests/linux/Makefile.am b/memcheck/tests/linux/Makefile.am +index 00e99a52a..e13325869 100644 +--- a/memcheck/tests/linux/Makefile.am ++++ b/memcheck/tests/linux/Makefile.am +@@ -26,7 +26,9 @@ EXTRA_DIST = \ + timerfd-syscall.vgtest timerfd-syscall.stderr.exp \ + with-space.stderr.exp with-space.stdout.exp with-space.vgtest \ + proc-auxv.vgtest proc-auxv.stderr.exp getregset.vgtest \ +- getregset.stderr.exp getregset.stdout.exp ++ getregset.stderr.exp getregset.stdout.exp \ ++ sys-preadv_pwritev.vgtest sys-preadv_pwritev.stderr.exp \ ++ sys-preadv2_pwritev2.vgtest sys-preadv2_pwritev2.stderr.exp + + check_PROGRAMS = \ + brk \ +@@ -54,6 +56,14 @@ if HAVE_COPY_FILE_RANGE + check_PROGRAMS += sys-copy_file_range + endif + ++if HAVE_PREADV_PWRITEV ++ check_PROGRAMS += sys-preadv_pwritev ++endif ++ ++if HAVE_PREADV2_PWRITEV2 ++ check_PROGRAMS += sys-preadv2_pwritev2 ++endif ++ + AM_CFLAGS += $(AM_FLAG_M3264_PRI) + AM_CXXFLAGS += $(AM_FLAG_M3264_PRI) + +diff --git a/memcheck/tests/linux/sys-preadv2_pwritev2.c b/memcheck/tests/linux/sys-preadv2_pwritev2.c +new file mode 100644 +index 000000000..942eab68b +--- /dev/null ++++ b/memcheck/tests/linux/sys-preadv2_pwritev2.c +@@ -0,0 +1,79 @@ ++#define _GNU_SOURCE ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "../../memcheck.h" ++ ++#include ++ ++int main(int argc, char **argv) ++{ ++ char str0[] = "hello "; ++ char str1[] = "world\n"; ++ struct iovec iov[2]; ++ int fd; ++ ++ fd = open("prwv2_source", O_CREAT | O_RDWR, 0644); ++ if (fd == -1) { ++ perror("prwv2_source"); ++ exit(EXIT_FAILURE); ++ } ++ ++ iov[0].iov_base = str0; ++ iov[0].iov_len = strlen(str0); ++ iov[1].iov_base = str1; ++ iov[1].iov_len = strlen(str1); ++ ++ /* Check pwritev2 and preadv2 called with the correct arguments works. */ ++ if (pwritev2(fd, iov, 2, 0, 0) == -1) { ++ perror("pwritev2"); ++ exit(EXIT_FAILURE); ++ } ++ ++ if (preadv2(fd, iov, 2, 0, 0) == -1) { ++ perror("preadv2"); ++ printf("errno: %d\n", errno); ++ exit(EXIT_FAILURE); ++ } ++ ++ /* Check valgrind will produce expected warnings for the ++ various wrong arguments. */ ++ do { ++ /* always allocate 16 bytes to not to have different .exps for different reg sizes */ ++ char *mem = malloc(16); ++ void *t = (void *) &mem[0]; ++ void *z = (void *) -1; ++ int c = *((int *) &mem[4]); ++ int flag = *((int *) &mem[8]); ++ pwritev2(fd, NULL, 2, 0, 0); ++ pwritev2(fd, z, 2, 0, 0); ++ pwritev2(fd, t, 2, 0, 0); ++ pwritev2(fd, iov, -1, 0, 0); ++ pwritev2(fd, iov, c, 0, 0); ++ pwritev2(fd, iov, 2, -5, 0); ++ pwritev2(-1, iov, 2, -5, 0); ++ pwritev2(fd, iov, 2, -5, flag); ++ ++ preadv2(fd, NULL, 2, 0, 0); ++ preadv2(fd, z, 2, 0, 0); ++ preadv2(fd, t, 2, 0, 0); ++ preadv2(fd, iov, -1, 0, 0); ++ preadv2(fd, iov, c, 0, 0); ++ preadv2(fd, iov, 2, -5, 0); ++ preadv2(-1, iov, 2, -5, 0); ++ ++ iov[1].iov_base = (void *) -1; ++ pwritev2(fd, iov, 2, 0, 0); ++ preadv2(fd, iov, 2, 0, 0); ++ free(mem); ++ } while (0); ++ ++ close(fd); ++ unlink("prwv2_source"); ++ exit(EXIT_SUCCESS); ++} +diff --git a/memcheck/tests/linux/sys-preadv2_pwritev2.stderr.exp b/memcheck/tests/linux/sys-preadv2_pwritev2.stderr.exp +new file mode 100644 +index 000000000..e11f2a51d +--- /dev/null ++++ b/memcheck/tests/linux/sys-preadv2_pwritev2.stderr.exp +@@ -0,0 +1,56 @@ ++Syscall param pwritev2(vector) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:53) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param pwritev2(vector) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:54) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param pwritev2(vector) points to uninitialised byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:55) ++ Address 0x........ is 0 bytes inside a block of size 16 alloc'd ++ at 0x........: malloc (vg_replace_malloc.c:...) ++ by 0x........: main (sys-preadv2_pwritev2.c:48) ++ ++Syscall param pwritev2(count) contains uninitialised byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:57) ++ ++Syscall param pwritev2(flags) contains uninitialised byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:60) ++ ++Syscall param preadv2(vector) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:62) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param preadv2(vector) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:63) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param preadv2(vector) points to uninitialised byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:64) ++ Address 0x........ is 0 bytes inside a block of size 16 alloc'd ++ at 0x........: malloc (vg_replace_malloc.c:...) ++ by 0x........: main (sys-preadv2_pwritev2.c:48) ++ ++Syscall param preadv2(count) contains uninitialised byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:66) ++ ++Syscall param pwritev2(vector[1]) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:71) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param preadv2(vector[1]) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv2_pwritev2.c:72) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ +diff --git a/memcheck/tests/linux/sys-preadv2_pwritev2.vgtest b/memcheck/tests/linux/sys-preadv2_pwritev2.vgtest +new file mode 100644 +index 000000000..5cd23aacd +--- /dev/null ++++ b/memcheck/tests/linux/sys-preadv2_pwritev2.vgtest +@@ -0,0 +1,3 @@ ++prereq: test -e sys-preadv2_pwritev2 ++prog: sys-preadv2_pwritev2 ++vgopts: -q +diff --git a/memcheck/tests/linux/sys-preadv_pwritev.c b/memcheck/tests/linux/sys-preadv_pwritev.c +new file mode 100644 +index 000000000..f5087dddc +--- /dev/null ++++ b/memcheck/tests/linux/sys-preadv_pwritev.c +@@ -0,0 +1,77 @@ ++#define _GNU_SOURCE ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "../../memcheck.h" ++ ++#include ++ ++int main(int argc, char **argv) ++{ ++ char str0[] = "hello "; ++ char str1[] = "world\n"; ++ struct iovec iov[2]; ++ int fd; ++ ++ fd = open("prwv_source", O_CREAT | O_RDWR, 0644); ++ if (fd == -1) { ++ perror("prwv2_source"); ++ exit(EXIT_FAILURE); ++ } ++ ++ iov[0].iov_base = str0; ++ iov[0].iov_len = strlen(str0); ++ iov[1].iov_base = str1; ++ iov[1].iov_len = strlen(str1); ++ ++ /* Check pwritev and preadv called with the correct arguments works. */ ++ if (pwritev(fd, iov, 2, 0) == -1) { ++ perror("pwritev"); ++ exit(EXIT_FAILURE); ++ } ++ ++ if (preadv(fd, iov, 2, 0) == -1) { ++ perror("preadv"); ++ printf("errno: %d\n", errno); ++ exit(EXIT_FAILURE); ++ } ++ ++ /* Check valgrind will produce expected warnings for the ++ various wrong arguments. */ ++ do { ++ /* always allocate 16 bytes to not to have different .exps for different reg sizes */ ++ char *mem = malloc(16); ++ void *t = (void *) &mem[0]; ++ void *z = (void *) -1; ++ int c = *((int *) &mem[4]); ++ pwritev(fd, NULL, 2, 0); ++ pwritev(fd, z, 2, 0); ++ pwritev(fd, t, 2, 0); ++ pwritev(fd, iov, -1, 0); ++ pwritev(fd, iov, c, 0); ++ pwritev(fd, iov, 2, -5); ++ pwritev(-1, iov, 2, -5); ++ ++ preadv(fd, NULL, 2, 0); ++ preadv(fd, z, 2, 0); ++ preadv(fd, t, 2, 0); ++ preadv(fd, iov, -1, 0); ++ preadv(fd, iov, c, 0); ++ preadv(fd, iov, 2, -5); ++ preadv(-1, iov, 2, -5); ++ ++ iov[1].iov_base = (void *) -1; ++ pwritev(fd, iov, 2, 0); ++ preadv(fd, iov, 2, 0); ++ free(mem); ++ } while (0); ++ ++ close(fd); ++ unlink("prwv_source"); ++ exit(EXIT_SUCCESS); ++} +diff --git a/memcheck/tests/linux/sys-preadv_pwritev.stderr.exp b/memcheck/tests/linux/sys-preadv_pwritev.stderr.exp +new file mode 100644 +index 000000000..4fede44d8 +--- /dev/null ++++ b/memcheck/tests/linux/sys-preadv_pwritev.stderr.exp +@@ -0,0 +1,52 @@ ++Syscall param pwritev(vector) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:52) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param pwritev(vector) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:53) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param pwritev(vector) points to uninitialised byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:54) ++ Address 0x........ is 0 bytes inside a block of size 16 alloc'd ++ at 0x........: malloc (vg_replace_malloc.c:...) ++ by 0x........: main (sys-preadv_pwritev.c:48) ++ ++Syscall param pwritev(count) contains uninitialised byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:56) ++ ++Syscall param preadv(vector) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:60) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param preadv(vector) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:61) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param preadv(vector) points to uninitialised byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:62) ++ Address 0x........ is 0 bytes inside a block of size 16 alloc'd ++ at 0x........: malloc (vg_replace_malloc.c:...) ++ by 0x........: main (sys-preadv_pwritev.c:48) ++ ++Syscall param preadv(count) contains uninitialised byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:64) ++ ++Syscall param pwritev(vector[1]) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:69) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ ++Syscall param preadv(vector[1]) points to unaddressable byte(s) ++ ... ++ by 0x........: main (sys-preadv_pwritev.c:70) ++ Address 0x........ is not stack'd, malloc'd or (recently) free'd ++ +diff --git a/memcheck/tests/linux/sys-preadv_pwritev.vgtest b/memcheck/tests/linux/sys-preadv_pwritev.vgtest +new file mode 100644 +index 000000000..f07dc2935 +--- /dev/null ++++ b/memcheck/tests/linux/sys-preadv_pwritev.vgtest +@@ -0,0 +1,3 @@ ++prereq: test -e sys-preadv_pwritev ++prog: sys-preadv_pwritev ++vgopts: -q + +commit 514f899388e05142513ff3f679a9e0131145e34e +Author: Mark Wielaard +Date: Wed Jul 3 10:27:17 2019 +0200 + + Hook up preadv2 and pwritev2 correctly for arm64. + + Use the correct generic linux sys wrapper. + + Followup for https://bugs.kde.org/408414 + +diff --git a/coregrind/m_syswrap/syswrap-arm64-linux.c b/coregrind/m_syswrap/syswrap-arm64-linux.c +index d12d40632..91329b682 100644 +--- a/coregrind/m_syswrap/syswrap-arm64-linux.c ++++ b/coregrind/m_syswrap/syswrap-arm64-linux.c +@@ -818,8 +818,8 @@ static SyscallTableEntry syscall_main_table[] = { + LINX_(__NR_membarrier, sys_membarrier), // 283 + // (__NR_mlock2, sys_ni_syscall), // 284 + LINX_(__NR_copy_file_range, sys_copy_file_range), // 285 +- LINX_(__NR_preadv2, sys_ni_syscall), // 286 +- LINX_(__NR_pwritev2, sys_ni_syscall), // 287 ++ LINXY(__NR_preadv2, sys_preadv2), // 286 ++ LINX_(__NR_pwritev2, sys_pwritev2), // 287 + // (__NR_pkey_mprotect, sys_ni_syscall), // 288 + // (__NR_pkey_alloc, sys_ni_syscall), // 289 + // (__NR_pkey_free, sys_ni_syscall), // 290 diff --git a/SOURCES/valgrind-3.15.0-s390x-wrap-drd.patch b/SOURCES/valgrind-3.15.0-s390x-wrap-drd.patch new file mode 100644 index 0000000..be5adb5 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-s390x-wrap-drd.patch @@ -0,0 +1,194 @@ +From bfa89eae00ba7067445bc0532e1f17405c062954 Mon Sep 17 00:00:00 2001 +From: Andreas Arnez +Date: Thu, 23 May 2019 17:17:43 +0200 +Subject: [PATCH] Bug 407764 - s390x: drd fails on z13 due to function wrapping + issue + +The s390x-specific inline assembly macros for function wrapping in +include/valgrind.h have a few issues. + +When the compiler uses vector registers, such as with "-march=z13", all +vector registers must be declared as clobbered by the callee. Because +this is missing, many drd test failures are seen with "-march=z13". + +Also, the inline assemblies write the return value into the target +register before restoring r11. If r11 is used as the target register, +this means that the restore operation corrupts the result. This bug +causes failures with memcheck's "wrap6" test case. + +These bugs are fixed. The clobber list is extended by the vector +registers (if appropriate), and the target register is now written at the +end, after restoring r11. +--- + include/valgrind.h | 38 +++++++++++++++++++++++--------------- + 1 file changed, 23 insertions(+), 15 deletions(-) + +diff --git a/include/valgrind.h b/include/valgrind.h +index f071bd392..815efa893 100644 +--- a/include/valgrind.h ++++ b/include/valgrind.h +@@ -4687,8 +4687,16 @@ typedef + r14 in s390_irgen_noredir (VEX/priv/guest_s390_irgen.c) to give the + function a proper return address. All others are ABI defined call + clobbers. */ +-#define __CALLER_SAVED_REGS "0","1","2","3","4","5","14", \ +- "f0","f1","f2","f3","f4","f5","f6","f7" ++#if defined(__VX__) || defined(__S390_VX__) ++#define __CALLER_SAVED_REGS "0", "1", "2", "3", "4", "5", "14", \ ++ "v0", "v1", "v2", "v3", "v4", "v5", "v6", "v7", \ ++ "v8", "v9", "v10", "v11", "v12", "v13", "v14", "v15", \ ++ "v16", "v17", "v18", "v19", "v20", "v21", "v22", "v23", \ ++ "v24", "v25", "v26", "v27", "v28", "v29", "v30", "v31" ++#else ++#define __CALLER_SAVED_REGS "0", "1", "2", "3", "4", "5", "14", \ ++ "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7" ++#endif + + /* Nb: Although r11 is modified in the asm snippets below (inside + VALGRIND_CFI_PROLOGUE) it is not listed in the clobber section, for +@@ -4710,9 +4718,9 @@ typedef + "aghi 15,-160\n\t" \ + "lg 1, 0(1)\n\t" /* target->r1 */ \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,160\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "d" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \ +@@ -4734,9 +4742,9 @@ typedef + "lg 2, 8(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,160\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \ +@@ -4759,9 +4767,9 @@ typedef + "lg 3,16(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,160\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \ +@@ -4786,9 +4794,9 @@ typedef + "lg 4,24(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,160\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \ +@@ -4815,9 +4823,9 @@ typedef + "lg 5,32(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,160\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"7" \ +@@ -4846,9 +4854,9 @@ typedef + "lg 6,40(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,160\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \ +@@ -4880,9 +4888,9 @@ typedef + "mvc 160(8,15), 48(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,168\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \ +@@ -4916,9 +4924,9 @@ typedef + "mvc 168(8,15), 56(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,176\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \ +@@ -4954,9 +4962,9 @@ typedef + "mvc 176(8,15), 64(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,184\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \ +@@ -4994,9 +5002,9 @@ typedef + "mvc 184(8,15), 72(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,192\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \ +@@ -5036,9 +5044,9 @@ typedef + "mvc 192(8,15), 80(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,200\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \ +@@ -5080,9 +5088,9 @@ typedef + "mvc 200(8,15), 88(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,208\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \ +@@ -5126,9 +5134,9 @@ typedef + "mvc 208(8,15), 96(1)\n\t" \ + "lg 1, 0(1)\n\t" \ + VALGRIND_CALL_NOREDIR_R1 \ +- "lgr %0, 2\n\t" \ + "aghi 15,216\n\t" \ + VALGRIND_CFI_EPILOGUE \ ++ "lgr %0, 2\n\t" \ + : /*out*/ "=d" (_res) \ + : /*in*/ "a" (&_argvec[0]) __FRAME_POINTER \ + : /*trash*/ "cc", "memory", __CALLER_SAVED_REGS,"6","7" \ +-- +2.17.0 + diff --git a/SOURCES/valgrind-3.15.0-scalar-arm64.patch b/SOURCES/valgrind-3.15.0-scalar-arm64.patch new file mode 100644 index 0000000..2fa9ca7 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-scalar-arm64.patch @@ -0,0 +1,83 @@ +commit 917e423073c5eacffbad83008c27c8e61e0e342a +Author: Mark Wielaard +Date: Mon May 20 00:09:59 2019 +0200 + + Make memcheck/tests/arm64-linux/scalar test work under root. + + Running the testsuite as root isn't really recommended. + But lets not make tests fail unnecessarily when running as root. + Pass really invalid arguments to setuid, setgid, acct and fchown. + Make setresgid, setresuid, setregid and setreuid always succeed. + +diff --git a/memcheck/tests/arm64-linux/scalar.c b/memcheck/tests/arm64-linux/scalar.c +index fd49db6..622ea1c 100644 +--- a/memcheck/tests/arm64-linux/scalar.c ++++ b/memcheck/tests/arm64-linux/scalar.c +@@ -136,7 +136,7 @@ int main(void) + + // __NR_setuid 23 + GO(__NR_setuid, "1s 0m"); +- SY(__NR_setuid, x0); FAIL; ++ SY(__NR_setuid, x0-1); FAIL; + + // __NR_getuid 24 + GO(__NR_getuid, "0s 0m"); +@@ -229,7 +229,7 @@ int main(void) + + // __NR_setgid 46 + GO(__NR_setgid, "1s 0m"); +- SY(__NR_setgid, x0); FAIL; ++ SY(__NR_setgid, x0-1); FAIL; + + // __NR_getgid 47 + GO(__NR_getgid, "0s 0m"); +@@ -249,7 +249,7 @@ int main(void) + + // __NR_acct 51 + GO(__NR_acct, "1s 1m"); +- SY(__NR_acct, x0); FAIL; ++ SY(__NR_acct, x0-1); FAIL; + + // __NR_umount2 52 + GO(__NR_umount2, "2s 1m"); +@@ -340,11 +340,11 @@ int main(void) + + // __NR_setreuid 70 + GO(__NR_setreuid, "2s 0m"); +- SY(__NR_setreuid, x0, x0); FAIL; ++ SY(__NR_setreuid, x0-1, x0-1); SUCC; + + // __NR_setregid 71 + GO(__NR_setregid, "2s 0m"); +- SY(__NR_setregid, x0, x0); FAIL; ++ SY(__NR_setregid, x0-1, x0-1); SUCC; + + // __NR_sigsuspend arm64 only has rt_sigsuspend + // XXX: how do you use this function? +@@ -447,7 +447,7 @@ int main(void) + + // __NR_fchown 95 + GO(__NR_fchown, "3s 0m"); +- SY(__NR_fchown, x0, x0, x0); FAIL; ++ SY(__NR_fchown, x0-1, x0, x0); FAIL; + + // __NR_getpriority 96 + GO(__NR_getpriority, "2s 0m"); +@@ -733,7 +733,7 @@ int main(void) + + // __NR_setresuid 164 + GO(__NR_setresuid, "3s 0m"); +- SY(__NR_setresuid, x0, x0, x0); FAIL; ++ SY(__NR_setresuid, x0-1, x0-1, x0-1); SUCC; + + // __NR_getresuid 165 + GO(__NR_getresuid, "3s 3m"); +@@ -757,7 +757,7 @@ int main(void) + + // __NR_setresgid 170 + GO(__NR_setresgid, "3s 0m"); +- SY(__NR_setresgid, x0, x0, x0); FAIL; ++ SY(__NR_setresgid, x0-1, x0-1, x0-1); SUCC; + + // __NR_getresgid 171 + GO(__NR_getresgid, "3s 3m"); diff --git a/SOURCES/valgrind-3.15.0-scalar-x86.patch b/SOURCES/valgrind-3.15.0-scalar-x86.patch new file mode 100644 index 0000000..32fd243 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-scalar-x86.patch @@ -0,0 +1,137 @@ +commit abc09f23e1ad55a07beb827aef969acfe6c496ef +Author: Mark Wielaard +Date: Mon May 20 13:08:41 2019 +0200 + + Make memcheck/tests/x86-linux/scalar test work under root. + + Running the testsuite as root isn't really recommended. + But lets not make tests fail unnecessarily when running as root. + Similar to the arm64-linux/scalar fixes. Plus 32bit variants that + don't exist on arm64. + + Pass really invalid arguments to setuid[32], setgid[32], acct, fchown[32]. + Make setresgid[32], setresuid[32], setregid[32], setreuid[32] always succeed. + +diff --git a/memcheck/tests/x86-linux/scalar.c b/memcheck/tests/x86-linux/scalar.c +index 213a5ad..52f0d4e 100644 +--- a/memcheck/tests/x86-linux/scalar.c ++++ b/memcheck/tests/x86-linux/scalar.c +@@ -145,7 +145,7 @@ int main(void) + + // __NR_setuid 23 + GO(__NR_setuid, "1s 0m"); +- SY(__NR_setuid, x0); FAIL; ++ SY(__NR_setuid, x0-1); FAIL; + + // __NR_getuid 24 + GO(__NR_getuid, "0s 0m"); +@@ -238,7 +238,7 @@ int main(void) + + // __NR_setgid 46 + GO(__NR_setgid, "1s 0m"); +- SY(__NR_setgid, x0); FAIL; ++ SY(__NR_setgid, x0-1); FAIL; + + // __NR_getgid 47 + GO(__NR_getgid, "0s 0m"); +@@ -258,7 +258,7 @@ int main(void) + + // __NR_acct 51 + GO(__NR_acct, "1s 1m"); +- SY(__NR_acct, x0); FAIL; ++ SY(__NR_acct, x0-1); FAIL; + + // __NR_umount2 52 + GO(__NR_umount2, "2s 1m"); +@@ -349,11 +349,11 @@ int main(void) + + // __NR_setreuid 70 + GO(__NR_setreuid, "2s 0m"); +- SY(__NR_setreuid, x0, x0); FAIL; ++ SY(__NR_setreuid, x0-1, x0-1); SUCC; + + // __NR_setregid 71 + GO(__NR_setregid, "2s 0m"); +- SY(__NR_setregid, x0, x0); FAIL; ++ SY(__NR_setregid, x0-1, x0-1); SUCC; + + // __NR_sigsuspend 72 + // XXX: how do you use this function? +@@ -456,7 +456,7 @@ int main(void) + + // __NR_fchown 95 + GO(__NR_fchown, "3s 0m"); +- SY(__NR_fchown, x0, x0, x0); FAIL; ++ SY(__NR_fchown, x0-1, x0, x0); FAIL; + + // __NR_getpriority 96 + GO(__NR_getpriority, "2s 0m"); +@@ -742,7 +742,7 @@ int main(void) + + // __NR_setresuid 164 + GO(__NR_setresuid, "3s 0m"); +- SY(__NR_setresuid, x0, x0, x0); FAIL; ++ SY(__NR_setresuid, x0-1, x0-1, x0-1); SUCC; + + // __NR_getresuid 165 + GO(__NR_getresuid, "3s 3m"); +@@ -766,7 +766,7 @@ int main(void) + + // __NR_setresgid 170 + GO(__NR_setresgid, "3s 0m"); +- SY(__NR_setresgid, x0, x0, x0); FAIL; ++ SY(__NR_setresgid, x0-1, x0-1, x0-1); SUCC; + + // __NR_getresgid 171 + GO(__NR_getresgid, "3s 3m"); +@@ -923,11 +923,11 @@ int main(void) + + // __NR_setreuid32 203 + GO(__NR_setreuid32, "2s 0m"); +- SY(__NR_setreuid32, x0, x0); FAIL; ++ SY(__NR_setreuid32, x0-1, x0-1); SUCC; + + // __NR_setregid32 204 + GO(__NR_setregid32, "2s 0m"); +- SY(__NR_setregid32, x0, x0); FAIL; ++ SY(__NR_setregid32, x0-1, x0-1); SUCC; + + // __NR_getgroups32 205 + GO(__NR_getgroups32, "2s 1m"); +@@ -939,11 +939,11 @@ int main(void) + + // __NR_fchown32 207 + GO(__NR_fchown32, "3s 0m"); +- SY(__NR_fchown32, x0, x0, x0); FAIL; ++ SY(__NR_fchown32, x0-1, x0, x0); FAIL; + + // __NR_setresuid32 208 + GO(__NR_setresuid32, "3s 0m"); +- SY(__NR_setresuid32, x0, x0, x0); FAIL; ++ SY(__NR_setresuid32, x0-1, x0-1, x0-1); SUCC; + + // __NR_getresuid32 209 + GO(__NR_getresuid32, "3s 3m"); +@@ -951,7 +951,7 @@ int main(void) + + // __NR_setresgid32 210 + GO(__NR_setresgid32, "3s 0m"); +- SY(__NR_setresgid32, x0, x0, x0); FAIL; ++ SY(__NR_setresgid32, x0-1, x0-1, x0-1); SUCC; + + // __NR_getresgid32 211 + GO(__NR_getresgid32, "3s 3m"); +@@ -963,11 +963,11 @@ int main(void) + + // __NR_setuid32 213 + GO(__NR_setuid32, "1s 0m"); +- SY(__NR_setuid32, x0); FAIL; ++ SY(__NR_setuid32, x0-1); FAIL; + + // __NR_setgid32 214 + GO(__NR_setgid32, "1s 0m"); +- SY(__NR_setgid32, x0); FAIL; ++ SY(__NR_setgid32, x0-1); FAIL; + + // __NR_setfsuid32 215 + GO(__NR_setfsuid32, "1s 0m"); diff --git a/SOURCES/valgrind-3.15.0-some-Wl-z-now.patch b/SOURCES/valgrind-3.15.0-some-Wl-z-now.patch new file mode 100644 index 0000000..79c3662 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-some-Wl-z-now.patch @@ -0,0 +1,72 @@ +commit d3c977726064ba09fed6dfc7daf22b16824c97b4 +Author: Mark Wielaard +Date: Fri May 24 18:24:56 2019 +0200 + + Add -Wl,-z,now to some binaries. + +diff --git a/auxprogs/Makefile.am b/auxprogs/Makefile.am +index 1b7842b..e211eec 100644 +--- a/auxprogs/Makefile.am ++++ b/auxprogs/Makefile.am +@@ -32,7 +32,7 @@ valgrind_listener_SOURCES = valgrind-listener.c + valgrind_listener_CPPFLAGS = $(AM_CPPFLAGS_PRI) -I$(top_srcdir)/coregrind + valgrind_listener_CFLAGS = $(AM_CFLAGS_PRI) -fstack-protector-strong + valgrind_listener_CCASFLAGS = $(AM_CCASFLAGS_PRI) +-valgrind_listener_LDFLAGS = $(AM_CFLAGS_PRI) ++valgrind_listener_LDFLAGS = $(AM_CFLAGS_PRI) -Wl,-z,now + if VGCONF_PLATVARIANT_IS_ANDROID + valgrind_listener_CFLAGS += -static + endif +@@ -51,7 +51,7 @@ valgrind_di_server_SOURCES = valgrind-di-server.c + valgrind_di_server_CPPFLAGS = $(AM_CPPFLAGS_PRI) -I$(top_srcdir)/coregrind + valgrind_di_server_CFLAGS = $(AM_CFLAGS_PRI) -fstack-protector-strong + valgrind_di_server_CCASFLAGS = $(AM_CCASFLAGS_PRI) +-valgrind_di_server_LDFLAGS = $(AM_CFLAGS_PRI) ++valgrind_di_server_LDFLAGS = $(AM_CFLAGS_PRI) -Wl,-z,now + if VGCONF_PLATVARIANT_IS_ANDROID + valgrind_di_server_CFLAGS += -static + endif +@@ -86,7 +86,7 @@ getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_SOURCES = getoff.c + getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_CPPFLAGS = $(AM_CPPFLAGS_@VGCONF_PLATFORM_PRI_CAPS@) + getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_CFLAGS = $(AM_CFLAGS_@VGCONF_PLATFORM_PRI_CAPS@) -fstack-protector-strong + getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_CCASFLAGS = $(AM_CCASFLAGS_PRI) +-getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_LDFLAGS = $(AM_CFLAGS_PRI) @LIB_UBSAN@ ++getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_LDFLAGS = $(AM_CFLAGS_PRI) @LIB_UBSAN@ -Wl,-z,now + if HAVE_DLINFO_RTLD_DI_TLS_MODID + getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_LDADD = $(LDADD) -ldl + endif +diff --git a/cachegrind/Makefile.am b/cachegrind/Makefile.am +index f572741..1c07e50 100644 +--- a/cachegrind/Makefile.am ++++ b/cachegrind/Makefile.am +@@ -27,7 +27,7 @@ cg_merge_SOURCES = cg_merge.c + cg_merge_CPPFLAGS = $(AM_CPPFLAGS_PRI) + cg_merge_CFLAGS = $(AM_CFLAGS_PRI) -fstack-protector-strong + cg_merge_CCASFLAGS = $(AM_CCASFLAGS_PRI) +-cg_merge_LDFLAGS = $(AM_CFLAGS_PRI) ++cg_merge_LDFLAGS = $(AM_CFLAGS_PRI) -Wl,-z,now + # If there is no secondary platform, and the platforms include x86-darwin, + # then the primary platform must be x86-darwin. Hence: + if ! VGCONF_HAVE_PLATFORM_SEC +diff --git a/coregrind/Makefile.am b/coregrind/Makefile.am +index 3c73210..fb6b7bb 100644 +--- a/coregrind/Makefile.am ++++ b/coregrind/Makefile.am +@@ -57,7 +57,7 @@ RANLIB = ${LTO_RANLIB} + valgrind_CPPFLAGS = $(AM_CPPFLAGS_PRI) + valgrind_CFLAGS = $(AM_CFLAGS_PRI) $(LTO_CFLAGS) -fstack-protector-strong + valgrind_CCASFLAGS = $(AM_CCASFLAGS_PRI) +-valgrind_LDFLAGS = $(AM_CFLAGS_PRI) @LIB_UBSAN@ ++valgrind_LDFLAGS = $(AM_CFLAGS_PRI) @LIB_UBSAN@ -Wl,-z,now + # If there is no secondary platform, and the platforms include x86-darwin, + # then the primary platform must be x86-darwin. Hence: + if ! VGCONF_HAVE_PLATFORM_SEC +@@ -96,7 +96,7 @@ endif + vgdb_CPPFLAGS = $(AM_CPPFLAGS_PRI) + vgdb_CFLAGS = $(AM_CFLAGS_PRI) $(LTO_CFLAGS) -fstack-protector-strong + vgdb_CCASFLAGS = $(AM_CCASFLAGS_PRI) +-vgdb_LDFLAGS = $(AM_CFLAGS_PRI) @LIB_UBSAN@ ++vgdb_LDFLAGS = $(AM_CFLAGS_PRI) @LIB_UBSAN@ -Wl,-z,now + if VGCONF_PLATVARIANT_IS_ANDROID + vgdb_CFLAGS += -static + endif diff --git a/SOURCES/valgrind-3.15.0-some-stack-protector.patch b/SOURCES/valgrind-3.15.0-some-stack-protector.patch new file mode 100644 index 0000000..bde2aa5 --- /dev/null +++ b/SOURCES/valgrind-3.15.0-some-stack-protector.patch @@ -0,0 +1,118 @@ +commit b73fb7a614e1b5d60af23fb0752b5cead995e02e +Author: Mark Wielaard +Date: Sun Apr 14 00:30:05 2019 +0200 + + Remove no-stack-protector, add stack-protector-strong to some. + +diff --git a/auxprogs/Makefile.am b/auxprogs/Makefile.am +index 56cc5ef..1b7842b 100644 +--- a/auxprogs/Makefile.am ++++ b/auxprogs/Makefile.am +@@ -30,7 +30,7 @@ bin_PROGRAMS = valgrind-listener valgrind-di-server + + valgrind_listener_SOURCES = valgrind-listener.c + valgrind_listener_CPPFLAGS = $(AM_CPPFLAGS_PRI) -I$(top_srcdir)/coregrind +-valgrind_listener_CFLAGS = $(AM_CFLAGS_PRI) ++valgrind_listener_CFLAGS = $(AM_CFLAGS_PRI) -fstack-protector-strong + valgrind_listener_CCASFLAGS = $(AM_CCASFLAGS_PRI) + valgrind_listener_LDFLAGS = $(AM_CFLAGS_PRI) + if VGCONF_PLATVARIANT_IS_ANDROID +@@ -49,7 +49,7 @@ endif + + valgrind_di_server_SOURCES = valgrind-di-server.c + valgrind_di_server_CPPFLAGS = $(AM_CPPFLAGS_PRI) -I$(top_srcdir)/coregrind +-valgrind_di_server_CFLAGS = $(AM_CFLAGS_PRI) ++valgrind_di_server_CFLAGS = $(AM_CFLAGS_PRI) -fstack-protector-strong + valgrind_di_server_CCASFLAGS = $(AM_CCASFLAGS_PRI) + valgrind_di_server_LDFLAGS = $(AM_CFLAGS_PRI) + if VGCONF_PLATVARIANT_IS_ANDROID +@@ -84,7 +84,7 @@ endif + + getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_SOURCES = getoff.c + getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_CPPFLAGS = $(AM_CPPFLAGS_@VGCONF_PLATFORM_PRI_CAPS@) +-getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_CFLAGS = $(AM_CFLAGS_@VGCONF_PLATFORM_PRI_CAPS@) ++getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_CFLAGS = $(AM_CFLAGS_@VGCONF_PLATFORM_PRI_CAPS@) -fstack-protector-strong + getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_CCASFLAGS = $(AM_CCASFLAGS_PRI) + getoff_@VGCONF_ARCH_PRI@_@VGCONF_OS@_LDFLAGS = $(AM_CFLAGS_PRI) @LIB_UBSAN@ + if HAVE_DLINFO_RTLD_DI_TLS_MODID +diff --git a/cachegrind/Makefile.am b/cachegrind/Makefile.am +index f8447a1..f572741 100644 +--- a/cachegrind/Makefile.am ++++ b/cachegrind/Makefile.am +@@ -25,7 +25,7 @@ bin_PROGRAMS = cg_merge + + cg_merge_SOURCES = cg_merge.c + cg_merge_CPPFLAGS = $(AM_CPPFLAGS_PRI) +-cg_merge_CFLAGS = $(AM_CFLAGS_PRI) ++cg_merge_CFLAGS = $(AM_CFLAGS_PRI) -fstack-protector-strong + cg_merge_CCASFLAGS = $(AM_CCASFLAGS_PRI) + cg_merge_LDFLAGS = $(AM_CFLAGS_PRI) + # If there is no secondary platform, and the platforms include x86-darwin, +diff --git a/configure.ac b/configure.ac +index f8c798b..ccc8f52 100755 +--- a/configure.ac ++++ b/configure.ac +@@ -2188,24 +2188,24 @@ AC_LANG(C) + AC_SUBST(FLAG_FALIGNED_NEW) + + # does this compiler support -fno-stack-protector ? +-AC_MSG_CHECKING([if gcc accepts -fno-stack-protector]) +- +-safe_CFLAGS=$CFLAGS +-CFLAGS="-fno-stack-protector -Werror" +- +-AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ +- return 0; +-]])], [ +-no_stack_protector=yes +-FLAG_FNO_STACK_PROTECTOR="-fno-stack-protector" +-AC_MSG_RESULT([yes]) +-], [ +-no_stack_protector=no ++#AC_MSG_CHECKING([if gcc accepts -fno-stack-protector]) ++# ++#safe_CFLAGS=$CFLAGS ++#CFLAGS="-fno-stack-protector -Werror" ++# ++#AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[ ++# return 0; ++#]])], [ ++#no_stack_protector=yes ++#FLAG_FNO_STACK_PROTECTOR="-fno-stack-protector" ++#AC_MSG_RESULT([yes]) ++#], [ ++#no_stack_protector=no + FLAG_FNO_STACK_PROTECTOR="" +-AC_MSG_RESULT([no]) +-]) +-CFLAGS=$safe_CFLAGS +- ++#AC_MSG_RESULT([no]) ++#]) ++#CFLAGS=$safe_CFLAGS ++# + AC_SUBST(FLAG_FNO_STACK_PROTECTOR) + + # does this compiler support -finline-functions ? +diff --git a/coregrind/Makefile.am b/coregrind/Makefile.am +index 94030fd..3c73210 100644 +--- a/coregrind/Makefile.am ++++ b/coregrind/Makefile.am +@@ -55,7 +55,7 @@ AR = ${LTO_AR} + RANLIB = ${LTO_RANLIB} + + valgrind_CPPFLAGS = $(AM_CPPFLAGS_PRI) +-valgrind_CFLAGS = $(AM_CFLAGS_PRI) $(LTO_CFLAGS) ++valgrind_CFLAGS = $(AM_CFLAGS_PRI) $(LTO_CFLAGS) -fstack-protector-strong + valgrind_CCASFLAGS = $(AM_CCASFLAGS_PRI) + valgrind_LDFLAGS = $(AM_CFLAGS_PRI) @LIB_UBSAN@ + # If there is no secondary platform, and the platforms include x86-darwin, +@@ -94,7 +94,7 @@ vgdb_SOURCES += vgdb-invoker-solaris.c + endif + + vgdb_CPPFLAGS = $(AM_CPPFLAGS_PRI) +-vgdb_CFLAGS = $(AM_CFLAGS_PRI) $(LTO_CFLAGS) ++vgdb_CFLAGS = $(AM_CFLAGS_PRI) $(LTO_CFLAGS) -fstack-protector-strong + vgdb_CCASFLAGS = $(AM_CCASFLAGS_PRI) + vgdb_LDFLAGS = $(AM_CFLAGS_PRI) @LIB_UBSAN@ + if VGCONF_PLATVARIANT_IS_ANDROID diff --git a/SOURCES/valgrind-3.15.0-z14-misc.patch b/SOURCES/valgrind-3.15.0-z14-misc.patch new file mode 100644 index 0000000..ef042de --- /dev/null +++ b/SOURCES/valgrind-3.15.0-z14-misc.patch @@ -0,0 +1,8463 @@ +commit 65d8e9ed96287235b33dfe40525a442dc978e3af +Author: Andreas Arnez +Date: Tue Oct 2 13:47:50 2018 +0200 + + s390x: Add models "z14" and "z14 ZR1" + + Add IBM z14 and IBM z14 ZR1 to the list of known machine models. Add an + expected output variant for z14 to the s390x-specific "ecag" test case. + In README.s390, refer to a current version of the z/Architecture + Principles of Operation that describes the instructions introduced with + IBM z14. + +diff --git a/README.s390 b/README.s390 +index 4679bb317..ac9485a62 100644 +--- a/README.s390 ++++ b/README.s390 +@@ -12,7 +12,6 @@ Limitations + - 31-bit client programs are not supported. + - Hexadecimal floating point is not supported. + - Transactional memory is not supported. +-- Instructions operating on vector registers are not supported. + - memcheck, cachegrind, drd, helgrind, massif, lackey, and none are + supported. + - On machine models predating z10, cachegrind will assume a z10 cache +@@ -49,6 +48,6 @@ Reading Material + (1) Linux for zSeries ELF ABI Supplement + http://refspecs.linuxfoundation.org/ELF/zSeries/index.html + (2) z/Architecture Principles of Operation +- http://publibfi.boulder.ibm.com/epubs/pdf/dz9zr010.pdf ++ http://publibfi.boulder.ibm.com/epubs/pdf/dz9zr011.pdf + (3) z/Architecture Reference Summary +- http://publibfi.boulder.ibm.com/epubs/pdf/dz9zs008.pdf ++ http://publibfi.boulder.ibm.com/epubs/pdf/dz9zs009.pdf +diff --git a/VEX/priv/main_main.c b/VEX/priv/main_main.c +index ac3006d69..97c0bacd6 100644 +--- a/VEX/priv/main_main.c ++++ b/VEX/priv/main_main.c +@@ -1719,6 +1719,8 @@ static const HChar* show_hwcaps_s390x ( UInt hwcaps ) + { VEX_HWCAPS_S390X_FPEXT, "fpext" }, + { VEX_HWCAPS_S390X_LSC, "lsc" }, + { VEX_HWCAPS_S390X_PFPO, "pfpo" }, ++ { VEX_HWCAPS_S390X_VX, "vx" }, ++ { VEX_HWCAPS_S390X_MSA5, "msa5" }, + }; + /* Allocate a large enough buffer */ + static HChar buf[sizeof prefix + +diff --git a/VEX/pub/libvex.h b/VEX/pub/libvex.h +index 1e112f509..37afd185a 100644 +--- a/VEX/pub/libvex.h ++++ b/VEX/pub/libvex.h +@@ -144,7 +144,9 @@ typedef + #define VEX_S390X_MODEL_ZBC12 11 + #define VEX_S390X_MODEL_Z13 12 + #define VEX_S390X_MODEL_Z13S 13 +-#define VEX_S390X_MODEL_UNKNOWN 14 /* always last in list */ ++#define VEX_S390X_MODEL_Z14 14 ++#define VEX_S390X_MODEL_Z14_ZR1 15 ++#define VEX_S390X_MODEL_UNKNOWN 16 /* always last in list */ + #define VEX_S390X_MODEL_MASK 0x3F + + #define VEX_HWCAPS_S390X_LDISP (1<<6) /* Long-displacement facility */ +diff --git a/coregrind/m_machine.c b/coregrind/m_machine.c +index 56a28d108..cbb88472d 100644 +--- a/coregrind/m_machine.c ++++ b/coregrind/m_machine.c +@@ -578,6 +578,8 @@ static UInt VG_(get_machine_model)(void) + { "2828", VEX_S390X_MODEL_ZBC12 }, + { "2964", VEX_S390X_MODEL_Z13 }, + { "2965", VEX_S390X_MODEL_Z13S }, ++ { "3906", VEX_S390X_MODEL_Z14 }, ++ { "3907", VEX_S390X_MODEL_Z14_ZR1 }, + }; + + Int model, n, fh; +diff --git a/none/tests/s390x/ecag.stdout.exp-z14 b/none/tests/s390x/ecag.stdout.exp-z14 +new file mode 100644 +index 000000000..98f53280c +--- /dev/null ++++ b/none/tests/s390x/ecag.stdout.exp-z14 +@@ -0,0 +1,28 @@ ++L1 topology: separate data and instruction; private ++L1 cache line size data: 256 ++L1 cache line size insn: 256 ++L1 total cachesize data: 131072 ++L1 total cachesize insn: 131072 ++L1 set. assoc. data: 8 ++L1 set. assoc. insn: 8 ++L2 topology: separate data and instruction; private ++L2 cache line size data: 256 ++L2 cache line size insn: 256 ++L2 total cachesize data: 4194304 ++L2 total cachesize insn: 2097152 ++L2 set. assoc. data: 8 ++L2 set. assoc. insn: 8 ++L3 topology: unified data and instruction; shared ++L3 cache line size data: 256 ++L3 cache line size insn: 256 ++L3 total cachesize data: 134217728 ++L3 total cachesize insn: 134217728 ++L3 set. assoc. data: 32 ++L3 set. assoc. insn: 32 ++L4 topology: unified data and instruction; shared ++L4 cache line size data: 256 ++L4 cache line size insn: 256 ++L4 total cachesize data: 704643072 ++L4 total cachesize insn: 704643072 ++L4 set. assoc. data: 42 ++L4 set. assoc. insn: 42 +diff --git a/tests/s390x_features.c b/tests/s390x_features.c +index 25734abb1..301785fac 100644 +--- a/tests/s390x_features.c ++++ b/tests/s390x_features.c +@@ -98,6 +98,8 @@ model_info models[] = { + { "2828", "zBC12" }, + { "2964", "z13" }, + { "2965", "z13s" }, ++ { "3906", "z14" }, ++ { "3907", "z14 ZR1"}, + }; + + + +commit e63f93a970b8eb83d83dfb8bb39d578229fa3496 +Author: Andreas Arnez +Date: Tue May 14 17:19:34 2019 +0200 + + s390x: Clean up s390-check-opcodes.pl + + Fix false positives when invoking s390-check-opcodes.pl. Also clean up + some code formatting issues in that script. Add the instructions TPEI and + IRBM to guest_s390_toIR.c and s390-opcodes.csv, so they are not longer + warned about. + +diff --git a/VEX/priv/guest_s390_toIR.c b/VEX/priv/guest_s390_toIR.c +index 515b6dba3..076a4211f 100644 +--- a/VEX/priv/guest_s390_toIR.c ++++ b/VEX/priv/guest_s390_toIR.c +@@ -19613,8 +19613,10 @@ s390_decode_4byte_and_irgen(const UChar *bytes) + case 0xb99d: /* ESEA */ goto unimplemented; + case 0xb99e: /* PTI */ goto unimplemented; + case 0xb99f: /* SSAIR */ goto unimplemented; ++ case 0xb9a1: /* TPEI */ goto unimplemented; + case 0xb9a2: /* PTF */ goto unimplemented; + case 0xb9aa: /* LPTEA */ goto unimplemented; ++ case 0xb9ac: /* IRBM */ goto unimplemented; + case 0xb9ae: /* RRBM */ goto unimplemented; + case 0xb9af: /* PFMF */ goto unimplemented; + case 0xb9b0: s390_format_RRF_M0RERE(s390_irgen_CU14, RRF3_r3(ovl), + +commit 50b20aa244c1fddd9b9e872526d4daad49ddd7a5 +Author: Ilya Leoshkevich +Date: Thu May 16 12:34:37 2019 +0200 + + Bug 404406 - s390x: implement z14 miscellaneous instructions + + (from bug 404406 comment 0): + Valgrind on s390x currently lacks support for the miscellaneous + instruction extensions facility 2. + + Signed-off-by: Ilya Leoshkevich + +diff --git a/VEX/priv/guest_s390_defs.h b/VEX/priv/guest_s390_defs.h +index 0185de5fd..1470558ce 100644 +--- a/VEX/priv/guest_s390_defs.h ++++ b/VEX/priv/guest_s390_defs.h +@@ -158,7 +158,9 @@ enum { + S390_CC_OP_DFP_128_TO_INT_64 = 57, + S390_CC_OP_PFPO_32 = 58, + S390_CC_OP_PFPO_64 = 59, +- S390_CC_OP_PFPO_128 = 60 ++ S390_CC_OP_PFPO_128 = 60, ++ S390_CC_OP_MUL_32 = 61, ++ S390_CC_OP_MUL_64 = 62 + }; + + /*------------------------------------------------------------*/ +diff --git a/VEX/priv/guest_s390_helpers.c b/VEX/priv/guest_s390_helpers.c +index 63ee68b24..525e7000c 100644 +--- a/VEX/priv/guest_s390_helpers.c ++++ b/VEX/priv/guest_s390_helpers.c +@@ -990,6 +990,16 @@ decode_bfp_rounding_mode(UInt irrm) + psw >> 28; /* cc */ \ + }) + ++#define S390_CC_FOR_TERNARY(opcode,cc_dep1,cc_dep2) \ ++({ \ ++ __asm__ volatile ( \ ++ opcode ",%[op1],%[op1],%[op2],0\n\t" \ ++ "ipm %[psw]\n\t" : [psw] "=d"(psw), [op1] "+d"(cc_dep1) \ ++ : [op2] "d"(cc_dep2) \ ++ : "cc");\ ++ psw >> 28; /* cc */ \ ++}) ++ + #define S390_CC_FOR_TERNARY_SUBB(opcode,cc_dep1,cc_dep2,cc_ndep) \ + ({ \ + /* Recover the original DEP2 value. See comment near s390_cc_thunk_put3 \ +@@ -1802,6 +1812,12 @@ s390_calculate_cc(ULong cc_op, ULong cc_dep1, ULong cc_dep2, ULong cc_ndep) + return psw >> 28; /* cc */ + } + ++ case S390_CC_OP_MUL_32: ++ return S390_CC_FOR_TERNARY(".insn rrf,0xb9fd0000", cc_dep1, cc_dep2); ++ ++ case S390_CC_OP_MUL_64: ++ return S390_CC_FOR_TERNARY(".insn rrf,0xb9ed0000", cc_dep1, cc_dep2); ++ + default: + break; + } +diff --git a/VEX/priv/guest_s390_toIR.c b/VEX/priv/guest_s390_toIR.c +index 076a4211f..06ec27fae 100644 +--- a/VEX/priv/guest_s390_toIR.c ++++ b/VEX/priv/guest_s390_toIR.c +@@ -49,7 +49,7 @@ + static UInt s390_decode_and_irgen(const UChar *, UInt, DisResult *); + static void s390_irgen_xonc(IROp, IRTemp, IRTemp, IRTemp); + static void s390_irgen_CLC_EX(IRTemp, IRTemp, IRTemp); +- ++static const HChar *s390_irgen_BIC(UChar r1, IRTemp op2addr); + + /*------------------------------------------------------------*/ + /*--- Globals ---*/ +@@ -3314,8 +3314,12 @@ s390_format_RXY_RRRD(const HChar *(*irgen)(UChar r1, IRTemp op2addr), + + mnm = irgen(r1, op2addr); + +- if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) +- s390_disasm(ENC3(MNM, GPR, SDXB), mnm, r1, dh2, dl2, x2, b2); ++ if (UNLIKELY(vex_traceflags & VEX_TRACE_FE)) { ++ if (irgen == s390_irgen_BIC) ++ s390_disasm(ENC2(XMNM, SDXB), S390_XMNM_BIC, r1, dh2, dl2, x2, b2); ++ else ++ s390_disasm(ENC3(MNM, GPR, SDXB), mnm, r1, dh2, dl2, x2, b2); ++ } + } + + static void +@@ -4280,6 +4284,22 @@ s390_irgen_AHIK(UChar r1, UChar r3, UShort i2) + return "ahik"; + } + ++static const HChar * ++s390_irgen_AGH(UChar r1, IRTemp op2addr) ++{ ++ IRTemp op1 = newTemp(Ity_I64); ++ IRTemp op2 = newTemp(Ity_I64); ++ IRTemp result = newTemp(Ity_I64); ++ ++ assign(op1, get_gpr_dw0(r1)); ++ assign(op2, unop(Iop_16Sto64, load(Ity_I16, mkexpr(op2addr)))); ++ assign(result, binop(Iop_Add64, mkexpr(op1), mkexpr(op2))); ++ s390_cc_thunk_putSS(S390_CC_OP_SIGNED_ADD_64, op1, op2); ++ put_gpr_dw0(r1, mkexpr(result)); ++ ++ return "agh"; ++} ++ + static const HChar * + s390_irgen_AGHIK(UChar r1, UChar r3, UShort i2) + { +@@ -5197,6 +5217,24 @@ s390_irgen_BCTG(UChar r1, IRTemp op2addr) + return "bctg"; + } + ++static const HChar * ++s390_irgen_BIC(UChar r1, IRTemp op2addr) ++{ ++ IRTemp cond = newTemp(Ity_I32); ++ ++ if (r1 == 0) { ++ /* nothing */ ++ } else if (r1 == 15) { ++ always_goto(load(Ity_I64, mkexpr(op2addr))); ++ } else { ++ assign(cond, s390_call_calculate_cond(r1)); ++ if_condition_goto_computed(binop(Iop_CmpNE32, mkexpr(cond), mkU32(0)), ++ load(Ity_I64, mkexpr(op2addr))); ++ } ++ ++ return "bic"; ++} ++ + static const HChar * + s390_irgen_BXH(UChar r1, UChar r3, IRTemp op2addr) + { +@@ -8333,6 +8371,54 @@ s390_irgen_MFY(UChar r1, IRTemp op2addr) + return "mfy"; + } + ++static const HChar * ++s390_irgen_MG(UChar r1, IRTemp op2addr) ++{ ++ IRTemp op1 = newTemp(Ity_I64); ++ IRTemp op2 = newTemp(Ity_I64); ++ IRTemp result = newTemp(Ity_I128); ++ ++ assign(op1, get_gpr_dw0(r1 + 1)); ++ assign(op2, load(Ity_I64, mkexpr(op2addr))); ++ assign(result, binop(Iop_MullS64, mkexpr(op1), mkexpr(op2))); ++ put_gpr_dw0(r1, unop(Iop_128HIto64, mkexpr(result))); ++ put_gpr_dw0(r1 + 1, unop(Iop_128to64, mkexpr(result))); ++ ++ return "mg"; ++} ++ ++static const HChar * ++s390_irgen_MGH(UChar r1, IRTemp op2addr) ++{ ++ IRTemp op1 = newTemp(Ity_I64); ++ IRTemp op2 = newTemp(Ity_I16); ++ IRTemp result = newTemp(Ity_I128); ++ ++ assign(op1, get_gpr_dw0(r1)); ++ assign(op2, load(Ity_I16, mkexpr(op2addr))); ++ assign(result, binop(Iop_MullS64, mkexpr(op1), unop(Iop_16Sto64, mkexpr(op2)) ++ )); ++ put_gpr_dw0(r1, unop(Iop_128to64, mkexpr(result))); ++ ++ return "mgh"; ++} ++ ++static const HChar * ++s390_irgen_MGRK(UChar r3, UChar r1, UChar r2) ++{ ++ IRTemp op2 = newTemp(Ity_I64); ++ IRTemp op3 = newTemp(Ity_I64); ++ IRTemp result = newTemp(Ity_I128); ++ ++ assign(op2, get_gpr_dw0(r2)); ++ assign(op3, get_gpr_dw0(r3)); ++ assign(result, binop(Iop_MullS64, mkexpr(op2), mkexpr(op3))); ++ put_gpr_dw0(r1, unop(Iop_128HIto64, mkexpr(result))); ++ put_gpr_dw0(r1 + 1, unop(Iop_128to64, mkexpr(result))); ++ ++ return "mgrk"; ++} ++ + static const HChar * + s390_irgen_MH(UChar r1, IRTemp op2addr) + { +@@ -8522,6 +8608,38 @@ s390_irgen_MS(UChar r1, IRTemp op2addr) + return "ms"; + } + ++static const HChar * ++s390_irgen_MSC(UChar r1, IRTemp op2addr) ++{ ++ IRTemp op1 = newTemp(Ity_I32); ++ IRTemp op2 = newTemp(Ity_I32); ++ IRTemp result = newTemp(Ity_I64); ++ ++ assign(op1, get_gpr_w1(r1)); ++ assign(op2, load(Ity_I32, mkexpr(op2addr))); ++ assign(result, binop(Iop_MullS32, mkexpr(op1), mkexpr(op2))); ++ s390_cc_thunk_putSS(S390_CC_OP_MUL_32, op1, op2); ++ put_gpr_w1(r1, unop(Iop_64to32, mkexpr(result))); ++ ++ return "msc"; ++} ++ ++static const HChar * ++s390_irgen_MSRKC(UChar r3, UChar r1, UChar r2) ++{ ++ IRTemp op2 = newTemp(Ity_I32); ++ IRTemp op3 = newTemp(Ity_I32); ++ IRTemp result = newTemp(Ity_I64); ++ ++ assign(op2, get_gpr_w1(r2)); ++ assign(op3, get_gpr_w1(r3)); ++ assign(result, binop(Iop_MullS32, mkexpr(op2), mkexpr(op3))); ++ s390_cc_thunk_putSS(S390_CC_OP_MUL_32, op2, op3); ++ put_gpr_w1(r1, unop(Iop_64to32, mkexpr(result))); ++ ++ return "msrkc"; ++} ++ + static const HChar * + s390_irgen_MSY(UChar r1, IRTemp op2addr) + { +@@ -8552,6 +8670,22 @@ s390_irgen_MSG(UChar r1, IRTemp op2addr) + return "msg"; + } + ++static const HChar * ++s390_irgen_MSGC(UChar r1, IRTemp op2addr) ++{ ++ IRTemp op1 = newTemp(Ity_I64); ++ IRTemp op2 = newTemp(Ity_I64); ++ IRTemp result = newTemp(Ity_I128); ++ ++ assign(op1, get_gpr_dw0(r1)); ++ assign(op2, load(Ity_I64, mkexpr(op2addr))); ++ assign(result, binop(Iop_MullS64, mkexpr(op1), mkexpr(op2))); ++ s390_cc_thunk_putSS(S390_CC_OP_MUL_64, op1, op2); ++ put_gpr_dw0(r1, unop(Iop_128to64, mkexpr(result))); ++ ++ return "msgc"; ++} ++ + static const HChar * + s390_irgen_MSGF(UChar r1, IRTemp op2addr) + { +@@ -8599,6 +8733,22 @@ s390_irgen_MSGFI(UChar r1, UInt i2) + return "msgfi"; + } + ++static const HChar * ++s390_irgen_MSGRKC(UChar r3, UChar r1, UChar r2) ++{ ++ IRTemp op2 = newTemp(Ity_I64); ++ IRTemp op3 = newTemp(Ity_I64); ++ IRTemp result = newTemp(Ity_I128); ++ ++ assign(op2, get_gpr_dw0(r2)); ++ assign(op3, get_gpr_dw0(r3)); ++ assign(result, binop(Iop_MullS64, mkexpr(op2), mkexpr(op3))); ++ s390_cc_thunk_putSS(S390_CC_OP_MUL_64, op2, op3); ++ put_gpr_dw0(r1, unop(Iop_128to64, mkexpr(result))); ++ ++ return "msgrkc"; ++} ++ + static const HChar * + s390_irgen_OR(UChar r1, UChar r2) + { +@@ -10060,6 +10210,22 @@ s390_irgen_SGF(UChar r1, IRTemp op2addr) + return "sgf"; + } + ++static const HChar * ++s390_irgen_SGH(UChar r1, IRTemp op2addr) ++{ ++ IRTemp op1 = newTemp(Ity_I64); ++ IRTemp op2 = newTemp(Ity_I64); ++ IRTemp result = newTemp(Ity_I64); ++ ++ assign(op1, get_gpr_dw0(r1)); ++ assign(op2, unop(Iop_16Sto64, load(Ity_I16, mkexpr(op2addr)))); ++ assign(result, binop(Iop_Sub64, mkexpr(op1), mkexpr(op2))); ++ s390_cc_thunk_putSS(S390_CC_OP_SIGNED_SUB_64, op1, op2); ++ put_gpr_dw0(r1, mkexpr(result)); ++ ++ return "sgh"; ++} ++ + static const HChar * + s390_irgen_SH(UChar r1, IRTemp op2addr) + { +@@ -19693,8 +19859,12 @@ s390_decode_4byte_and_irgen(const UChar *bytes) + case 0xb9eb: s390_format_RRF_R0RR2(s390_irgen_SLGRK, RRF4_r3(ovl), + RRF4_r1(ovl), RRF4_r2(ovl)); + goto ok; +- case 0xb9ec: /* MGRK */ goto unimplemented; +- case 0xb9ed: /* MSGRKC */ goto unimplemented; ++ case 0xb9ec: s390_format_RRF_R0RR2(s390_irgen_MGRK, RRF4_r3(ovl), ++ RRF4_r1(ovl), RRF4_r2(ovl)); ++ goto ok; ++ case 0xb9ed: s390_format_RRF_R0RR2(s390_irgen_MSGRKC, RRF4_r3(ovl), ++ RRF4_r1(ovl), RRF4_r2(ovl)); ++ goto ok; + case 0xb9f2: s390_format_RRF_U0RR(s390_irgen_LOCR, RRF3_r3(ovl), + RRF3_r1(ovl), RRF3_r2(ovl), + S390_XMNM_LOCR); goto ok; +@@ -19719,7 +19889,9 @@ s390_decode_4byte_and_irgen(const UChar *bytes) + case 0xb9fb: s390_format_RRF_R0RR2(s390_irgen_SLRK, RRF4_r3(ovl), + RRF4_r1(ovl), RRF4_r2(ovl)); + goto ok; +- case 0xb9fd: /* MSRKC */ goto unimplemented; ++ case 0xb9fd: s390_format_RRF_R0RR2(s390_irgen_MSRKC, RRF4_r3(ovl), ++ RRF4_r1(ovl), RRF4_r2(ovl)); ++ goto ok; + } + + switch ((ovl & 0xff000000) >> 24) { +@@ -20036,8 +20208,14 @@ s390_decode_6byte_and_irgen(const UChar *bytes) + RXY_x2(ovl), RXY_b2(ovl), + RXY_dl2(ovl), + RXY_dh2(ovl)); goto ok; +- case 0xe30000000038ULL: /* AGH */ goto unimplemented; +- case 0xe30000000039ULL: /* SGH */ goto unimplemented; ++ case 0xe30000000038ULL: s390_format_RXY_RRRD(s390_irgen_AGH, RXY_r1(ovl), ++ RXY_x2(ovl), RXY_b2(ovl), ++ RXY_dl2(ovl), ++ RXY_dh2(ovl)); goto ok; ++ case 0xe30000000039ULL: s390_format_RXY_RRRD(s390_irgen_SGH, RXY_r1(ovl), ++ RXY_x2(ovl), RXY_b2(ovl), ++ RXY_dl2(ovl), ++ RXY_dh2(ovl)); goto ok; + case 0xe3000000003aULL: s390_format_RXY_RRRD(s390_irgen_LLZRGF, RXY_r1(ovl), + RXY_x2(ovl), RXY_b2(ovl), + RXY_dl2(ovl), +@@ -20046,7 +20224,10 @@ s390_decode_6byte_and_irgen(const UChar *bytes) + RXY_x2(ovl), RXY_b2(ovl), + RXY_dl2(ovl), + RXY_dh2(ovl)); goto ok; +- case 0xe3000000003cULL: /* MGH */ goto unimplemented; ++ case 0xe3000000003cULL: s390_format_RXY_RRRD(s390_irgen_MGH, RXY_r1(ovl), ++ RXY_x2(ovl), RXY_b2(ovl), ++ RXY_dl2(ovl), ++ RXY_dh2(ovl)); goto ok; + case 0xe3000000003eULL: s390_format_RXY_RRRD(s390_irgen_STRV, RXY_r1(ovl), + RXY_x2(ovl), RXY_b2(ovl), + RXY_dl2(ovl), +@@ -20059,7 +20240,10 @@ s390_decode_6byte_and_irgen(const UChar *bytes) + RXY_x2(ovl), RXY_b2(ovl), + RXY_dl2(ovl), + RXY_dh2(ovl)); goto ok; +- case 0xe30000000047ULL: /* BIC */ goto unimplemented; ++ case 0xe30000000047ULL: s390_format_RXY_RRRD(s390_irgen_BIC, RXY_r1(ovl), ++ RXY_x2(ovl), RXY_b2(ovl), ++ RXY_dl2(ovl), ++ RXY_dh2(ovl)); goto ok; + case 0xe30000000048ULL: /* LLGFSG */ goto unimplemented; + case 0xe30000000049ULL: /* STGSC */ goto unimplemented; + case 0xe3000000004cULL: /* LGG */ goto unimplemented; +@@ -20072,7 +20256,10 @@ s390_decode_6byte_and_irgen(const UChar *bytes) + RXY_x2(ovl), RXY_b2(ovl), + RXY_dl2(ovl), + RXY_dh2(ovl)); goto ok; +- case 0xe30000000053ULL: /* MSC */ goto unimplemented; ++ case 0xe30000000053ULL: s390_format_RXY_RRRD(s390_irgen_MSC, RXY_r1(ovl), ++ RXY_x2(ovl), RXY_b2(ovl), ++ RXY_dl2(ovl), ++ RXY_dh2(ovl)); goto ok; + case 0xe30000000054ULL: s390_format_RXY_RRRD(s390_irgen_NY, RXY_r1(ovl), + RXY_x2(ovl), RXY_b2(ovl), + RXY_dl2(ovl), +@@ -20177,8 +20364,14 @@ s390_decode_6byte_and_irgen(const UChar *bytes) + RXY_x2(ovl), RXY_b2(ovl), + RXY_dl2(ovl), + RXY_dh2(ovl)); goto ok; +- case 0xe30000000083ULL: /* MSGC */ goto unimplemented; +- case 0xe30000000084ULL: /* MG */ goto unimplemented; ++ case 0xe30000000083ULL: s390_format_RXY_RRRD(s390_irgen_MSGC, RXY_r1(ovl), ++ RXY_x2(ovl), RXY_b2(ovl), ++ RXY_dl2(ovl), ++ RXY_dh2(ovl)); goto ok; ++ case 0xe30000000084ULL: s390_format_RXY_RRRD(s390_irgen_MG, RXY_r1(ovl), ++ RXY_x2(ovl), RXY_b2(ovl), ++ RXY_dl2(ovl), ++ RXY_dh2(ovl)); goto ok; + case 0xe30000000085ULL: s390_format_RXY_RRRD(s390_irgen_LGAT, RXY_r1(ovl), + RXY_x2(ovl), RXY_b2(ovl), + RXY_dl2(ovl), +diff --git a/VEX/priv/host_s390_defs.c b/VEX/priv/host_s390_defs.c +index 8aa2ba67f..162550fd7 100644 +--- a/VEX/priv/host_s390_defs.c ++++ b/VEX/priv/host_s390_defs.c +@@ -3023,6 +3023,26 @@ s390_emit_MFY(UChar *p, UChar r1, UChar x2, UChar b2, UShort dl2, UChar dh2) + } + + ++static UChar * ++s390_emit_MG(UChar *p, UChar r1, UChar x2, UChar b2, UShort dl2, UChar dh2) ++{ ++ if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) ++ s390_disasm(ENC3(MNM, GPR, SDXB), "mg", r1, dh2, dl2, x2, b2); ++ ++ return emit_RXY(p, 0xe30000000084ULL, r1, x2, b2, dl2, dh2); ++} ++ ++ ++static UChar * ++s390_emit_MGRK(UChar *p, UChar r3, UChar r1, UChar r2) ++{ ++ if (UNLIKELY(vex_traceflags & VEX_TRACE_ASM)) ++ s390_disasm(ENC4(MNM, GPR, GPR, GPR), "mgrk", r1, r2, r3); ++ ++ return emit_RRF3(p, 0xb9ec0000, r3, r1, r2); ++} ++ ++ + static UChar * + s390_emit_MH(UChar *p, UChar r1, UChar x2, UChar b2, UShort d2) + { +@@ -9595,7 +9615,7 @@ s390_insn_mul_emit(UChar *buf, const s390_insn *insn) + + case 8: + if (signed_multiply) +- vpanic("s390_insn_mul_emit"); ++ return s390_emit_MGRK(buf, r1 + 1, r1, r2); + else + return s390_emit_MLGR(buf, r1, r2); + +@@ -9640,7 +9660,7 @@ s390_insn_mul_emit(UChar *buf, const s390_insn *insn) + + case 8: + if (signed_multiply) +- vpanic("s390_insn_mul_emit"); ++ return s390_emit_MG(buf, r1, x, b, DISP20(d)); + else + return s390_emit_MLG(buf, r1, x, b, DISP20(d)); + +@@ -9665,7 +9685,7 @@ s390_insn_mul_emit(UChar *buf, const s390_insn *insn) + case 8: + buf = s390_emit_load_64imm(buf, R0, value); + if (signed_multiply) +- vpanic("s390_insn_mul_emit"); ++ return s390_emit_MGRK(buf, r1 + 1, r1, R0); + else + return s390_emit_MLGR(buf, r1, R0); + +diff --git a/VEX/priv/main_main.c b/VEX/priv/main_main.c +index 97c0bacd6..3cfe8c1cb 100644 +--- a/VEX/priv/main_main.c ++++ b/VEX/priv/main_main.c +@@ -1721,6 +1721,7 @@ static const HChar* show_hwcaps_s390x ( UInt hwcaps ) + { VEX_HWCAPS_S390X_PFPO, "pfpo" }, + { VEX_HWCAPS_S390X_VX, "vx" }, + { VEX_HWCAPS_S390X_MSA5, "msa5" }, ++ { VEX_HWCAPS_S390X_MI2, "mi2" }, + }; + /* Allocate a large enough buffer */ + static HChar buf[sizeof prefix + +diff --git a/VEX/priv/s390_disasm.c b/VEX/priv/s390_disasm.c +index 4d3fec544..e3fbc11af 100644 +--- a/VEX/priv/s390_disasm.c ++++ b/VEX/priv/s390_disasm.c +@@ -433,6 +433,16 @@ s390_disasm(UInt command, ...) + the integer mask is appended as the final operand */ + if (mask == 0 || mask == 15) mask_suffix = mask; + break; ++ case S390_XMNM_BIC: ++ mask = va_arg(args, UInt); ++ if (mask == 0) { ++ /* There is no special opcode when mask == 0. */ ++ p += vex_sprintf(p, "bic"); ++ mask_suffix = mask; ++ } else { ++ p += vex_sprintf(p, "%s", construct_mnemonic("bi", "", mask)); ++ } ++ break; + } + } + continue; +diff --git a/VEX/priv/s390_disasm.h b/VEX/priv/s390_disasm.h +index 8469f72ab..eec41f8ac 100644 +--- a/VEX/priv/s390_disasm.h ++++ b/VEX/priv/s390_disasm.h +@@ -91,7 +91,8 @@ enum { + S390_XMNM_LOCFHR = 13, + S390_XMNM_LOCHI = 14, + S390_XMNM_LOCGHI = 15, +- S390_XMNM_LOCHHI = 16 ++ S390_XMNM_LOCHHI = 16, ++ S390_XMNM_BIC = 17 + }; + + void s390_disasm(UInt command, ...); +diff --git a/VEX/pub/libvex.h b/VEX/pub/libvex.h +index 37afd185a..9337a7c32 100644 +--- a/VEX/pub/libvex.h ++++ b/VEX/pub/libvex.h +@@ -163,6 +163,7 @@ typedef + #define VEX_HWCAPS_S390X_PFPO (1<<17) /* Perform floating point ops facility */ + #define VEX_HWCAPS_S390X_VX (1<<18) /* Vector facility */ + #define VEX_HWCAPS_S390X_MSA5 (1<<19) /* message security assistance facility */ ++#define VEX_HWCAPS_S390X_MI2 (1<<20) /* miscellaneous-instruction-extensions facility 2 */ + + + /* Special value representing all available s390x hwcaps */ +@@ -179,7 +180,8 @@ typedef + VEX_HWCAPS_S390X_ETF2 | \ + VEX_HWCAPS_S390X_PFPO | \ + VEX_HWCAPS_S390X_VX | \ +- VEX_HWCAPS_S390X_MSA5) ++ VEX_HWCAPS_S390X_MSA5 | \ ++ VEX_HWCAPS_S390X_MI2) + + #define VEX_HWCAPS_S390X(x) ((x) & ~VEX_S390X_MODEL_MASK) + #define VEX_S390X_MODEL(x) ((x) & VEX_S390X_MODEL_MASK) +diff --git a/VEX/pub/libvex_s390x_common.h b/VEX/pub/libvex_s390x_common.h +index c976395fc..d945a4472 100644 +--- a/VEX/pub/libvex_s390x_common.h ++++ b/VEX/pub/libvex_s390x_common.h +@@ -99,6 +99,7 @@ + #define S390_FAC_CTREXE 50 // constrained transactional execution + #define S390_FAC_LSC2 53 // load/store on condition 2 and load and zero rightmost byte + #define S390_FAC_MSA5 57 // message-security-assist 5 ++#define S390_FAC_MI2 58 // miscellaneous-instruction-extensions 2 + #define S390_FAC_TREXE 73 // transactional execution + #define S390_FAC_MSA4 77 // message-security-assist 4 + #define S390_FAC_VX 129 // vector facility +diff --git a/coregrind/m_machine.c b/coregrind/m_machine.c +index cbb88472d..9eab9000f 100644 +--- a/coregrind/m_machine.c ++++ b/coregrind/m_machine.c +@@ -1534,7 +1534,8 @@ Bool VG_(machine_get_hwcaps)( void ) + { False, S390_FAC_LSC, VEX_HWCAPS_S390X_LSC, "LSC" }, + { False, S390_FAC_PFPO, VEX_HWCAPS_S390X_PFPO, "PFPO" }, + { False, S390_FAC_VX, VEX_HWCAPS_S390X_VX, "VX" }, +- { False, S390_FAC_MSA5, VEX_HWCAPS_S390X_MSA5, "MSA5" } ++ { False, S390_FAC_MSA5, VEX_HWCAPS_S390X_MSA5, "MSA5" }, ++ { False, S390_FAC_MI2, VEX_HWCAPS_S390X_MI2, "MI2" }, + }; + + /* Set hwcaps according to the detected facilities */ + +commit 91d53d11671a07269846b189fcb2c5f2194d1da4 +Author: Ilya Leoshkevich +Date: Thu May 16 12:34:38 2019 +0200 + + Bug 404406 - s390x: test z14 miscellaneous instructions + + Reuse the existing infrastructure for add, sub and mul. + Add cc checks to all mul tests. + Write a new test for bic. + + Signed-off-by: Ilya Leoshkevich + +diff --git a/none/tests/s390x/Makefile.am b/none/tests/s390x/Makefile.am +index 097c85ac1..a5fbffd1e 100644 +--- a/none/tests/s390x/Makefile.am ++++ b/none/tests/s390x/Makefile.am +@@ -19,7 +19,7 @@ INSN_TESTS = clc clcle cvb cvd icm lpr tcxb lam_stam xc mvst add sub mul \ + spechelper-ltr spechelper-or \ + spechelper-icm-1 spechelper-icm-2 spechelper-tmll \ + spechelper-tm laa vector lsc2 ppno vector_string vector_integer \ +- vector_float ++ vector_float add-z14 sub-z14 mul-z14 bic + + if BUILD_DFP_TESTS + INSN_TESTS += dfp-1 dfp-2 dfp-3 dfp-4 dfptest dfpext dfpconv srnmt pfpo +diff --git a/none/tests/s390x/add-z14.c b/none/tests/s390x/add-z14.c +new file mode 100644 +index 000000000..0f433980d +--- /dev/null ++++ b/none/tests/s390x/add-z14.c +@@ -0,0 +1,13 @@ ++#include "add.h" ++ ++#define agh(x, y) ".insn rxy,0xe30000000038, " x ", " y "\n" ++ ++static void do_regmem_insns(unsigned long m2) ++{ ++ memsweep(agh, m2, 0); ++} ++ ++int main() ++{ ++ for_each_m2(do_regmem_insns); ++} +diff --git a/none/tests/s390x/add-z14.stderr.exp b/none/tests/s390x/add-z14.stderr.exp +new file mode 100644 +index 000000000..139597f9c +--- /dev/null ++++ b/none/tests/s390x/add-z14.stderr.exp +@@ -0,0 +1,2 @@ ++ ++ +diff --git a/none/tests/s390x/add-z14.stdout.exp b/none/tests/s390x/add-z14.stdout.exp +new file mode 100644 +index 000000000..d1b2c261f +--- /dev/null ++++ b/none/tests/s390x/add-z14.stdout.exp +@@ -0,0 +1,154 @@ ++agh 0 + 0000000000000000 + 0000000000000000 = 0000000000000000 (cc=0) ++agh 0 + 0000000000000001 + 0000000000000000 = 0000000000000001 (cc=2) ++agh 0 + 000000000000FFFF + 0000000000000000 = 000000000000FFFF (cc=2) ++agh 0 + 0000000000007FFF + 0000000000000000 = 0000000000007FFF (cc=2) ++agh 0 + 0000000000008000 + 0000000000000000 = 0000000000008000 (cc=2) ++agh 0 + 00000000FFFFFFFF + 0000000000000000 = 00000000FFFFFFFF (cc=2) ++agh 0 + 0000000080000000 + 0000000000000000 = 0000000080000000 (cc=2) ++agh 0 + 000000007FFFFFFF + 0000000000000000 = 000000007FFFFFFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 0000000000000000 = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 8000000000000000 + 0000000000000000 = 8000000000000000 (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 0000000000000000 = 7FFFFFFFFFFFFFFF (cc=2) ++agh 0 + 0000000000000000 + 7FFFFFFFFFFFFFFF = 0000000000007FFF (cc=2) ++agh 0 + 0000000000000001 + 7FFFFFFFFFFFFFFF = 0000000000008000 (cc=2) ++agh 0 + 000000000000FFFF + 7FFFFFFFFFFFFFFF = 0000000000017FFE (cc=2) ++agh 0 + 0000000000007FFF + 7FFFFFFFFFFFFFFF = 000000000000FFFE (cc=2) ++agh 0 + 0000000000008000 + 7FFFFFFFFFFFFFFF = 000000000000FFFF (cc=2) ++agh 0 + 00000000FFFFFFFF + 7FFFFFFFFFFFFFFF = 0000000100007FFE (cc=2) ++agh 0 + 0000000080000000 + 7FFFFFFFFFFFFFFF = 0000000080007FFF (cc=2) ++agh 0 + 000000007FFFFFFF + 7FFFFFFFFFFFFFFF = 0000000080007FFE (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 7FFFFFFFFFFFFFFF = 0000000000007FFE (cc=2) ++agh 0 + 8000000000000000 + 7FFFFFFFFFFFFFFF = 8000000000007FFF (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 7FFFFFFFFFFFFFFF = 8000000000007FFE (cc=3) ++agh 0 + 0000000000000000 + 8000000000000000 = FFFFFFFFFFFF8000 (cc=1) ++agh 0 + 0000000000000001 + 8000000000000000 = FFFFFFFFFFFF8001 (cc=1) ++agh 0 + 000000000000FFFF + 8000000000000000 = 0000000000007FFF (cc=2) ++agh 0 + 0000000000007FFF + 8000000000000000 = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 0000000000008000 + 8000000000000000 = 0000000000000000 (cc=0) ++agh 0 + 00000000FFFFFFFF + 8000000000000000 = 00000000FFFF7FFF (cc=2) ++agh 0 + 0000000080000000 + 8000000000000000 = 000000007FFF8000 (cc=2) ++agh 0 + 000000007FFFFFFF + 8000000000000000 = 000000007FFF7FFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 8000000000000000 = FFFFFFFFFFFF7FFF (cc=1) ++agh 0 + 8000000000000000 + 8000000000000000 = 7FFFFFFFFFFF8000 (cc=3) ++agh 0 + 7FFFFFFFFFFFFFFF + 8000000000000000 = 7FFFFFFFFFFF7FFF (cc=2) ++agh 0 + 0000000000000000 + FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 0000000000000001 + FFFFFFFFFFFFFFFF = 0000000000000000 (cc=0) ++agh 0 + 000000000000FFFF + FFFFFFFFFFFFFFFF = 000000000000FFFE (cc=2) ++agh 0 + 0000000000007FFF + FFFFFFFFFFFFFFFF = 0000000000007FFE (cc=2) ++agh 0 + 0000000000008000 + FFFFFFFFFFFFFFFF = 0000000000007FFF (cc=2) ++agh 0 + 00000000FFFFFFFF + FFFFFFFFFFFFFFFF = 00000000FFFFFFFE (cc=2) ++agh 0 + 0000000080000000 + FFFFFFFFFFFFFFFF = 000000007FFFFFFF (cc=2) ++agh 0 + 000000007FFFFFFF + FFFFFFFFFFFFFFFF = 000000007FFFFFFE (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFE (cc=1) ++agh 0 + 8000000000000000 + FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF (cc=3) ++agh 0 + 7FFFFFFFFFFFFFFF + FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE (cc=2) ++agh 0 + 0000000000000000 + 7FFFFFFF00000000 = 0000000000007FFF (cc=2) ++agh 0 + 0000000000000001 + 7FFFFFFF00000000 = 0000000000008000 (cc=2) ++agh 0 + 000000000000FFFF + 7FFFFFFF00000000 = 0000000000017FFE (cc=2) ++agh 0 + 0000000000007FFF + 7FFFFFFF00000000 = 000000000000FFFE (cc=2) ++agh 0 + 0000000000008000 + 7FFFFFFF00000000 = 000000000000FFFF (cc=2) ++agh 0 + 00000000FFFFFFFF + 7FFFFFFF00000000 = 0000000100007FFE (cc=2) ++agh 0 + 0000000080000000 + 7FFFFFFF00000000 = 0000000080007FFF (cc=2) ++agh 0 + 000000007FFFFFFF + 7FFFFFFF00000000 = 0000000080007FFE (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 7FFFFFFF00000000 = 0000000000007FFE (cc=2) ++agh 0 + 8000000000000000 + 7FFFFFFF00000000 = 8000000000007FFF (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 7FFFFFFF00000000 = 8000000000007FFE (cc=3) ++agh 0 + 0000000000000000 + 8000000000000000 = FFFFFFFFFFFF8000 (cc=1) ++agh 0 + 0000000000000001 + 8000000000000000 = FFFFFFFFFFFF8001 (cc=1) ++agh 0 + 000000000000FFFF + 8000000000000000 = 0000000000007FFF (cc=2) ++agh 0 + 0000000000007FFF + 8000000000000000 = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 0000000000008000 + 8000000000000000 = 0000000000000000 (cc=0) ++agh 0 + 00000000FFFFFFFF + 8000000000000000 = 00000000FFFF7FFF (cc=2) ++agh 0 + 0000000080000000 + 8000000000000000 = 000000007FFF8000 (cc=2) ++agh 0 + 000000007FFFFFFF + 8000000000000000 = 000000007FFF7FFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 8000000000000000 = FFFFFFFFFFFF7FFF (cc=1) ++agh 0 + 8000000000000000 + 8000000000000000 = 7FFFFFFFFFFF8000 (cc=3) ++agh 0 + 7FFFFFFFFFFFFFFF + 8000000000000000 = 7FFFFFFFFFFF7FFF (cc=2) ++agh 0 + 0000000000000000 + FFFFFFFF00000000 = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 0000000000000001 + FFFFFFFF00000000 = 0000000000000000 (cc=0) ++agh 0 + 000000000000FFFF + FFFFFFFF00000000 = 000000000000FFFE (cc=2) ++agh 0 + 0000000000007FFF + FFFFFFFF00000000 = 0000000000007FFE (cc=2) ++agh 0 + 0000000000008000 + FFFFFFFF00000000 = 0000000000007FFF (cc=2) ++agh 0 + 00000000FFFFFFFF + FFFFFFFF00000000 = 00000000FFFFFFFE (cc=2) ++agh 0 + 0000000080000000 + FFFFFFFF00000000 = 000000007FFFFFFF (cc=2) ++agh 0 + 000000007FFFFFFF + FFFFFFFF00000000 = 000000007FFFFFFE (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + FFFFFFFF00000000 = FFFFFFFFFFFFFFFE (cc=1) ++agh 0 + 8000000000000000 + FFFFFFFF00000000 = 7FFFFFFFFFFFFFFF (cc=3) ++agh 0 + 7FFFFFFFFFFFFFFF + FFFFFFFF00000000 = 7FFFFFFFFFFFFFFE (cc=2) ++agh 0 + 0000000000000000 + 000000007FFFFFFF = 0000000000000000 (cc=0) ++agh 0 + 0000000000000001 + 000000007FFFFFFF = 0000000000000001 (cc=2) ++agh 0 + 000000000000FFFF + 000000007FFFFFFF = 000000000000FFFF (cc=2) ++agh 0 + 0000000000007FFF + 000000007FFFFFFF = 0000000000007FFF (cc=2) ++agh 0 + 0000000000008000 + 000000007FFFFFFF = 0000000000008000 (cc=2) ++agh 0 + 00000000FFFFFFFF + 000000007FFFFFFF = 00000000FFFFFFFF (cc=2) ++agh 0 + 0000000080000000 + 000000007FFFFFFF = 0000000080000000 (cc=2) ++agh 0 + 000000007FFFFFFF + 000000007FFFFFFF = 000000007FFFFFFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 000000007FFFFFFF = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 8000000000000000 + 000000007FFFFFFF = 8000000000000000 (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 000000007FFFFFFF = 7FFFFFFFFFFFFFFF (cc=2) ++agh 0 + 0000000000000000 + 0000000080000000 = 0000000000000000 (cc=0) ++agh 0 + 0000000000000001 + 0000000080000000 = 0000000000000001 (cc=2) ++agh 0 + 000000000000FFFF + 0000000080000000 = 000000000000FFFF (cc=2) ++agh 0 + 0000000000007FFF + 0000000080000000 = 0000000000007FFF (cc=2) ++agh 0 + 0000000000008000 + 0000000080000000 = 0000000000008000 (cc=2) ++agh 0 + 00000000FFFFFFFF + 0000000080000000 = 00000000FFFFFFFF (cc=2) ++agh 0 + 0000000080000000 + 0000000080000000 = 0000000080000000 (cc=2) ++agh 0 + 000000007FFFFFFF + 0000000080000000 = 000000007FFFFFFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 0000000080000000 = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 8000000000000000 + 0000000080000000 = 8000000000000000 (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 0000000080000000 = 7FFFFFFFFFFFFFFF (cc=2) ++agh 0 + 0000000000000000 + 00000000FFFFFFFF = 0000000000000000 (cc=0) ++agh 0 + 0000000000000001 + 00000000FFFFFFFF = 0000000000000001 (cc=2) ++agh 0 + 000000000000FFFF + 00000000FFFFFFFF = 000000000000FFFF (cc=2) ++agh 0 + 0000000000007FFF + 00000000FFFFFFFF = 0000000000007FFF (cc=2) ++agh 0 + 0000000000008000 + 00000000FFFFFFFF = 0000000000008000 (cc=2) ++agh 0 + 00000000FFFFFFFF + 00000000FFFFFFFF = 00000000FFFFFFFF (cc=2) ++agh 0 + 0000000080000000 + 00000000FFFFFFFF = 0000000080000000 (cc=2) ++agh 0 + 000000007FFFFFFF + 00000000FFFFFFFF = 000000007FFFFFFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 00000000FFFFFFFF = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 8000000000000000 + 00000000FFFFFFFF = 8000000000000000 (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 00000000FFFFFFFF = 7FFFFFFFFFFFFFFF (cc=2) ++agh 0 + 0000000000000000 + 000000000000FFFF = 0000000000000000 (cc=0) ++agh 0 + 0000000000000001 + 000000000000FFFF = 0000000000000001 (cc=2) ++agh 0 + 000000000000FFFF + 000000000000FFFF = 000000000000FFFF (cc=2) ++agh 0 + 0000000000007FFF + 000000000000FFFF = 0000000000007FFF (cc=2) ++agh 0 + 0000000000008000 + 000000000000FFFF = 0000000000008000 (cc=2) ++agh 0 + 00000000FFFFFFFF + 000000000000FFFF = 00000000FFFFFFFF (cc=2) ++agh 0 + 0000000080000000 + 000000000000FFFF = 0000000080000000 (cc=2) ++agh 0 + 000000007FFFFFFF + 000000000000FFFF = 000000007FFFFFFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 000000000000FFFF = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 8000000000000000 + 000000000000FFFF = 8000000000000000 (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 000000000000FFFF = 7FFFFFFFFFFFFFFF (cc=2) ++agh 0 + 0000000000000000 + 0000000000007FFF = 0000000000000000 (cc=0) ++agh 0 + 0000000000000001 + 0000000000007FFF = 0000000000000001 (cc=2) ++agh 0 + 000000000000FFFF + 0000000000007FFF = 000000000000FFFF (cc=2) ++agh 0 + 0000000000007FFF + 0000000000007FFF = 0000000000007FFF (cc=2) ++agh 0 + 0000000000008000 + 0000000000007FFF = 0000000000008000 (cc=2) ++agh 0 + 00000000FFFFFFFF + 0000000000007FFF = 00000000FFFFFFFF (cc=2) ++agh 0 + 0000000080000000 + 0000000000007FFF = 0000000080000000 (cc=2) ++agh 0 + 000000007FFFFFFF + 0000000000007FFF = 000000007FFFFFFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 0000000000007FFF = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 8000000000000000 + 0000000000007FFF = 8000000000000000 (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 0000000000007FFF = 7FFFFFFFFFFFFFFF (cc=2) ++agh 0 + 0000000000000000 + 0000000000008000 = 0000000000000000 (cc=0) ++agh 0 + 0000000000000001 + 0000000000008000 = 0000000000000001 (cc=2) ++agh 0 + 000000000000FFFF + 0000000000008000 = 000000000000FFFF (cc=2) ++agh 0 + 0000000000007FFF + 0000000000008000 = 0000000000007FFF (cc=2) ++agh 0 + 0000000000008000 + 0000000000008000 = 0000000000008000 (cc=2) ++agh 0 + 00000000FFFFFFFF + 0000000000008000 = 00000000FFFFFFFF (cc=2) ++agh 0 + 0000000080000000 + 0000000000008000 = 0000000080000000 (cc=2) ++agh 0 + 000000007FFFFFFF + 0000000000008000 = 000000007FFFFFFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 0000000000008000 = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 8000000000000000 + 0000000000008000 = 8000000000000000 (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 0000000000008000 = 7FFFFFFFFFFFFFFF (cc=2) ++agh 0 + 0000000000000000 + 000000000000FFFF = 0000000000000000 (cc=0) ++agh 0 + 0000000000000001 + 000000000000FFFF = 0000000000000001 (cc=2) ++agh 0 + 000000000000FFFF + 000000000000FFFF = 000000000000FFFF (cc=2) ++agh 0 + 0000000000007FFF + 000000000000FFFF = 0000000000007FFF (cc=2) ++agh 0 + 0000000000008000 + 000000000000FFFF = 0000000000008000 (cc=2) ++agh 0 + 00000000FFFFFFFF + 000000000000FFFF = 00000000FFFFFFFF (cc=2) ++agh 0 + 0000000080000000 + 000000000000FFFF = 0000000080000000 (cc=2) ++agh 0 + 000000007FFFFFFF + 000000000000FFFF = 000000007FFFFFFF (cc=2) ++agh 0 + FFFFFFFFFFFFFFFF + 000000000000FFFF = FFFFFFFFFFFFFFFF (cc=1) ++agh 0 + 8000000000000000 + 000000000000FFFF = 8000000000000000 (cc=1) ++agh 0 + 7FFFFFFFFFFFFFFF + 000000000000FFFF = 7FFFFFFFFFFFFFFF (cc=2) +diff --git a/none/tests/s390x/add-z14.vgtest b/none/tests/s390x/add-z14.vgtest +new file mode 100644 +index 000000000..531b58f4f +--- /dev/null ++++ b/none/tests/s390x/add-z14.vgtest +@@ -0,0 +1,2 @@ ++prog: add-z14 ++prereq: ../../../tests/s390x_features s390x-mi2 +diff --git a/none/tests/s390x/add.c b/none/tests/s390x/add.c +index 0041ed207..4f2f9be15 100644 +--- a/none/tests/s390x/add.c ++++ b/none/tests/s390x/add.c +@@ -1,7 +1,9 @@ +-#include + #include "add.h" + #include "opcodes.h" + ++#define ahi(x, y) "ahi " x ", " y "\n" ++#define aghi(x, y) "aghi " x ", " y "\n" ++ + static void do_imm_insns(void) + { + immsweep(ahi, 0, 0); +@@ -14,6 +16,24 @@ static void do_imm_insns(void) + immsweep(aghi, 32767, 0); + } + ++#define a(x, y) "a " x ", " y "\n" ++#define ah(x, y) "ah " x ", " y "\n" ++#define ag(x, y) "ag " x ", " y "\n" ++#define agf(x, y) "agf " x ", " y "\n" ++#define al(x, y) "al " x ", " y "\n" ++#define alg(x, y) "alg " x ", " y "\n" ++#define agf(x, y) "agf " x ", " y "\n" ++#define algf(x, y) "algf " x ", " y "\n" ++#define ar(x, y) "ar " x ", " y "\n" ++#define agr(x, y) "agr " x ", " y "\n" ++#define agfr(x, y) "agfr " x ", " y "\n" ++#define alr(x, y) "alr " x ", " y "\n" ++#define algr(x, y) "algr " x ", " y "\n" ++#define algfr(x, y) "algfr " x ", " y "\n" ++#define alc(x, y) "alc " x ", " y "\n" ++#define alcg(x, y) "alcg " x ", " y "\n" ++#define alcr(x, y) "alcr " x ", " y "\n" ++#define alcgr(x, y) "alcgr " x ", " y "\n" + + static void do_regmem_insns(unsigned long s2) + { +@@ -46,22 +66,7 @@ static void do_regmem_insns(unsigned long s2) + + int main() + { +- do_regmem_insns(0x0ul); +- do_regmem_insns(0x7ffffffffffffffful); +- do_regmem_insns(0x8000000000000000ul); +- do_regmem_insns(0xfffffffffffffffful); +- do_regmem_insns(0x7fffffff00000000ul); +- do_regmem_insns(0x8000000000000000ul); +- do_regmem_insns(0xffffffff00000000ul); +- do_regmem_insns(0x000000007ffffffful); +- do_regmem_insns(0x0000000080000000ul); +- do_regmem_insns(0x00000000fffffffful); +- do_regmem_insns(0x000000000000fffful); +- do_regmem_insns(0x0000000000007ffful); +- do_regmem_insns(0x0000000000008000ul); +- do_regmem_insns(0x000000000000fffful); ++ for_each_m2(do_regmem_insns); + + do_imm_insns(); +- +- return 0; + } +diff --git a/none/tests/s390x/add.h b/none/tests/s390x/add.h +index 53111617a..a5051cf11 100644 +--- a/none/tests/s390x/add.h ++++ b/none/tests/s390x/add.h +@@ -9,7 +9,7 @@ volatile long v; + int cc; \ + asm volatile( "lghi 0," #CARRY "\n" \ + "aghi 0, 0\n" \ +- #insn " %0, %3\n" \ ++ insn("%0", "%3") \ + "ipm %1\n" \ + "srl %1,28\n" \ + : "+d" (tmp), "=d" (cc) \ +@@ -24,7 +24,7 @@ volatile long v; + int cc; \ + asm volatile( "lghi 0," #CARRY "\n" \ + "aghi 0, 0\n" \ +- #insn " %0, %3\n" \ ++ insn("%0", "%3") \ + "ipm %1\n" \ + "srl %1,28\n" \ + : "+d" (tmp), "=d" (cc) \ +@@ -39,7 +39,7 @@ volatile long v; + int cc; \ + asm volatile( "lghi 0," #CARRY "\n" \ + "aghi 0, 0\n" \ +- #insn " %0," #s2 "\n" \ ++ insn("%0", #s2) \ + "ipm %1\n" \ + "srl %1,28\n" \ + : "+d" (tmp), "=d" (cc) \ +@@ -204,3 +204,20 @@ volatile long v; + ADD_REG_XIMM(i, 0x7ffffffffffffffful, us2, s2, carryset); \ + }) + ++#define for_each_m2(f) \ ++({ \ ++ f(0x0ul); \ ++ f(0x7ffffffffffffffful); \ ++ f(0x8000000000000000ul); \ ++ f(0xfffffffffffffffful); \ ++ f(0x7fffffff00000000ul); \ ++ f(0x8000000000000000ul); \ ++ f(0xffffffff00000000ul); \ ++ f(0x000000007ffffffful); \ ++ f(0x0000000080000000ul); \ ++ f(0x00000000fffffffful); \ ++ f(0x000000000000fffful); \ ++ f(0x0000000000007ffful); \ ++ f(0x0000000000008000ul); \ ++ f(0x000000000000fffful); \ ++}) +diff --git a/none/tests/s390x/bic.c b/none/tests/s390x/bic.c +new file mode 100644 +index 000000000..a8d28d9d6 +--- /dev/null ++++ b/none/tests/s390x/bic.c +@@ -0,0 +1,78 @@ ++#include ++ ++#define HEAD "agfi %[i], -8\n" \ ++ "jl 1f\n" \ ++ "larl %[table], 6f\n" \ ++ "sllg %[i], %[i], 3(0)\n" \ ++ "clgfi %[i], 4*8\n" ++ ++#define TAIL "0: lghi %[i], 200\n" \ ++ "j 7f\n" \ ++ "1: lghi %[i], 100\n" \ ++ "j 7f\n" \ ++ "2: lghi %[i], 111\n" \ ++ "j 7f\n" \ ++ "3: lghi %[i], 122\n" \ ++ "j 7f\n" \ ++ "4: lghi %[i], 133\n" \ ++ "j 7f\n" \ ++ "5: lghi %[i], 144\n" \ ++ "j 7f\n" \ ++ "6:\n" \ ++ ".quad 2b\n" \ ++ ".quad 3b\n" \ ++ ".quad 4b\n" \ ++ ".quad 5b\n" \ ++ ".quad 5b\n" \ ++ "7:\n" ++ ++static int bic0(int i) ++{ ++ void *table; ++ asm volatile(HEAD ++ "brcl 10, 0f\n" ++ ".insn rxy, 0xe30000000047, 0, 8(%[i],%[table])\n" ++ "lg %[table],0(%[i],%[table])\n" ++ "br %[table]\n" ++ TAIL ++ : [i] "+d" (i) ++ , [table] "=d" (table) ++ :: "cc"); ++ return i; ++} ++ ++static int bic4(int i) ++{ ++ void *table; ++ asm volatile(HEAD ++ ".insn rxy, 0xe30000000047, 4, 0(%[i],%[table])\n" ++ TAIL ++ : [i] "+d" (i) ++ , [table] "=d" (table) ++ :: "cc"); ++ return i; ++} ++ ++static int bic15(int i) ++{ ++ void *table; ++ asm volatile(HEAD ++ "brcl 10, 0f\n" ++ ".insn rxy, 0xe30000000047, 15, 0(%[i],%[table])\n" ++ TAIL ++ : [i] "+d" (i) ++ , [table] "=d" (table) ++ :: "cc"); ++ return i; ++} ++ ++int main() ++{ ++ int i; ++ ++ for (i = 0; i < 16; i++) { ++ printf("bic0: %d -> %d\n", i, bic0(i)); ++ printf("bic4: %d -> %d\n", i, bic4(i)); ++ printf("bic15: %d -> %d\n", i, bic15(i)); ++ } ++} +diff --git a/none/tests/s390x/bic.stderr.exp b/none/tests/s390x/bic.stderr.exp +new file mode 100644 +index 000000000..139597f9c +--- /dev/null ++++ b/none/tests/s390x/bic.stderr.exp +@@ -0,0 +1,2 @@ ++ ++ +diff --git a/none/tests/s390x/bic.stdout.exp b/none/tests/s390x/bic.stdout.exp +new file mode 100644 +index 000000000..64dcac49e +--- /dev/null ++++ b/none/tests/s390x/bic.stdout.exp +@@ -0,0 +1,48 @@ ++bic0: 0 -> 100 ++bic4: 0 -> 100 ++bic15: 0 -> 100 ++bic0: 1 -> 100 ++bic4: 1 -> 100 ++bic15: 1 -> 100 ++bic0: 2 -> 100 ++bic4: 2 -> 100 ++bic15: 2 -> 100 ++bic0: 3 -> 100 ++bic4: 3 -> 100 ++bic15: 3 -> 100 ++bic0: 4 -> 100 ++bic4: 4 -> 100 ++bic15: 4 -> 100 ++bic0: 5 -> 100 ++bic4: 5 -> 100 ++bic15: 5 -> 100 ++bic0: 6 -> 100 ++bic4: 6 -> 100 ++bic15: 6 -> 100 ++bic0: 7 -> 100 ++bic4: 7 -> 100 ++bic15: 7 -> 100 ++bic0: 8 -> 111 ++bic4: 8 -> 111 ++bic15: 8 -> 111 ++bic0: 9 -> 122 ++bic4: 9 -> 122 ++bic15: 9 -> 122 ++bic0: 10 -> 133 ++bic4: 10 -> 133 ++bic15: 10 -> 133 ++bic0: 11 -> 144 ++bic4: 11 -> 144 ++bic15: 11 -> 144 ++bic0: 12 -> 200 ++bic4: 12 -> 200 ++bic15: 12 -> 200 ++bic0: 13 -> 200 ++bic4: 13 -> 200 ++bic15: 13 -> 200 ++bic0: 14 -> 200 ++bic4: 14 -> 200 ++bic15: 14 -> 200 ++bic0: 15 -> 200 ++bic4: 15 -> 200 ++bic15: 15 -> 200 +diff --git a/none/tests/s390x/bic.vgtest b/none/tests/s390x/bic.vgtest +new file mode 100644 +index 000000000..dfb8c2331 +--- /dev/null ++++ b/none/tests/s390x/bic.vgtest +@@ -0,0 +1,2 @@ ++prog: bic ++prereq: ../../../tests/s390x_features s390x-mi2 +diff --git a/none/tests/s390x/mul-z14.c b/none/tests/s390x/mul-z14.c +new file mode 100644 +index 000000000..1a28af89a +--- /dev/null ++++ b/none/tests/s390x/mul-z14.c +@@ -0,0 +1,25 @@ ++#include "mul.h" ++ ++#define mg(x, y) ".insn rxy,0xe30000000084, " x ", " y "\n" ++#define mgh(x, y) ".insn rxy,0xe3000000003c, " x ", " y "\n" ++#define mgrk(x, y, z) ".insn rrf,0xb9ec0000, " x ", " y ", " z ", 0\n" ++#define msc(x, y) ".insn rxy,0xe30000000053, " x ", " y "\n" ++#define msrkc(x, y, z) ".insn rrf,0xb9fd0000, " x ", " y ", " z ", 0\n" ++#define msgc(x, y) ".insn rxy,0xe30000000083, " x ", " y "\n" ++#define msgrkc(x, y, z) ".insn rrf,0xb9ed0000, " x ", " y ", " z ", 0\n" ++ ++static void do_regmem_insns(unsigned long m2) ++{ ++ memsweep(mg, m2); ++ memsweep(mgh, m2); ++ regregsweep(mgrk, m2); ++ memsweep(msc, m2); ++ regregsweep(msrkc, m2); ++ memsweep(msgc, m2); ++ regregsweep(msgrkc, m2); ++} ++ ++int main() ++{ ++ for_each_m2(do_regmem_insns); ++} +diff --git a/none/tests/s390x/mul-z14.stderr.exp b/none/tests/s390x/mul-z14.stderr.exp +new file mode 100644 +index 000000000..139597f9c +--- /dev/null ++++ b/none/tests/s390x/mul-z14.stderr.exp +@@ -0,0 +1,2 @@ ++ ++ +diff --git a/none/tests/s390x/mul-z14.stdout.exp b/none/tests/s390x/mul-z14.stdout.exp +new file mode 100644 +index 000000000..da22b5795 +--- /dev/null ++++ b/none/tests/s390x/mul-z14.stdout.exp +@@ -0,0 +1,1078 @@ ++mg 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg FFFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 8000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++mgh 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++mgh 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 8000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++msc 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msc 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msc 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++msc 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msc 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++msc 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msc FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msc 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msrkc 0000000000000000 * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000008000 * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000080000000 * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF000000000000000000000002 (cc=0) ++msrkc 8000000000000000 * 0000000000000000 = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000000000000000000002 (cc=0) ++msgc 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++msgc 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msgc 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msgc 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++msgc 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgc 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++msgc 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgc FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgc 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgc 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgrkc 0000000000000000 * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000008000 * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000080000000 * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc FFFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 8000000000000000 * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000002 (cc=0) ++mg 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mg 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++mg 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF7FFFFFFFFFFF8001 (cc=0) ++mg 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFFFFFFFFFFFFFF8000 (cc=0) ++mg 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 (cc=0) ++mg 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000003FFFFFFFFFFFFFFF80000000 (cc=0) ++mg 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 (cc=0) ++mg FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF8000000000000001 (cc=0) ++mg 8000000000000000 * 7FFFFFFFFFFFFFFF = C0000000000000008000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF0000000000000001 (cc=0) ++mgh 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000007FFF0000000000000001 (cc=0) ++mgh 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFE8001000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000003FFF00010000000000007FFF (cc=0) ++mgh 0000000000008000 * 7FFFFFFFFFFFFFFF = 000000003FFF80000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00007FFEFFFF800100000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 7FFFFFFFFFFFFFFF = 00003FFF800000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 00003FFF7FFF8001000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mgrk 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++mgrk 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF7FFFFFFFFFFF8001 (cc=0) ++mgrk 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFFFFFFFFFFFFFF8000 (cc=0) ++mgrk 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 (cc=0) ++mgrk 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000003FFFFFFFFFFFFFFF80000000 (cc=0) ++mgrk 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF8000000000000001 (cc=0) ++mgrk 8000000000000000 * 7FFFFFFFFFFFFFFF = C0000000000000008000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msc 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF0000000000000001 (cc=2) ++msc 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFF0001000000000000FFFF (cc=3) ++msc 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000007FFF80010000000000007FFF (cc=3) ++msc 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=3) ++msc 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000008000000100000000FFFFFFFF (cc=1) ++msc 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=3) ++msc 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 0000000000000001000000007FFFFFFF (cc=3) ++msc FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=1) ++msc 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=1) ++msrkc 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000002 (cc=1) ++msrkc 000000000000FFFF * 7FFFFFFFFFFFFFFF = 00000000FFFF00010000000000000002 (cc=1) ++msrkc 0000000000007FFF * 7FFFFFFFFFFFFFFF = 00000000FFFF80010000000000000002 (cc=1) ++msrkc 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFF80000000000000000002 (cc=1) ++msrkc 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000000000010000000000000002 (cc=2) ++msrkc 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000000000002 (cc=3) ++msrkc 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 00000000800000010000000000000002 (cc=1) ++msrkc FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF000000010000000000000002 (cc=2) ++msrkc 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF000000010000000000000002 (cc=2) ++msgc 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF0000000000000001 (cc=2) ++msgc 000000000000FFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF0001000000000000FFFF (cc=3) ++msgc 0000000000007FFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80010000000000007FFF (cc=3) ++msgc 0000000000008000 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=3) ++msgc 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF0000000100000000FFFFFFFF (cc=3) ++msgc 0000000080000000 * 7FFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=3) ++msgc 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF80000001000000007FFFFFFF (cc=3) ++msgc FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 8000000000000001FFFFFFFFFFFFFFFF (cc=1) ++msgc 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000000000017FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF0000000000000002 (cc=2) ++msgrkc 000000000000FFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF00010000000000000002 (cc=3) ++msgrkc 0000000000007FFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80010000000000000002 (cc=3) ++msgrkc 0000000000008000 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000000002 (cc=3) ++msgrkc 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF000000010000000000000002 (cc=3) ++msgrkc 0000000080000000 * 7FFFFFFFFFFFFFFF = FFFFFFFF800000000000000000000002 (cc=3) ++msgrkc 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF800000010000000000000002 (cc=3) ++msgrkc FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 80000000000000010000000000000002 (cc=1) ++msgrkc 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000000000010000000000000002 (cc=3) ++mg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 8000000000000000 = FFFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mg 000000000000FFFF * 8000000000000000 = FFFFFFFFFFFF80008000000000000000 (cc=0) ++mg 0000000000007FFF * 8000000000000000 = FFFFFFFFFFFFC0008000000000000000 (cc=0) ++mg 0000000000008000 * 8000000000000000 = FFFFFFFFFFFFC0000000000000000000 (cc=0) ++mg 00000000FFFFFFFF * 8000000000000000 = FFFFFFFF800000008000000000000000 (cc=0) ++mg 0000000080000000 * 8000000000000000 = FFFFFFFFC00000000000000000000000 (cc=0) ++mg 000000007FFFFFFF * 8000000000000000 = FFFFFFFFC00000008000000000000000 (cc=0) ++mg FFFFFFFFFFFFFFFF * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mg 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 8000000000000000 = C0000000000000008000000000000000 (cc=0) ++mgh 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 8000000000000000 = FFFFFFFFFFFF80000000000000000001 (cc=0) ++mgh 000000000000FFFF * 8000000000000000 = FFFFFFFF80008000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 8000000000000000 = FFFFFFFFC00080000000000000007FFF (cc=0) ++mgh 0000000000008000 * 8000000000000000 = FFFFFFFFC00000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 8000000000000000 = FFFF80000000800000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 8000000000000000 = FFFFC000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 8000000000000000 = FFFFC00000008000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000000008000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000000080007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 8000000000000000 = FFFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mgrk 000000000000FFFF * 8000000000000000 = FFFFFFFFFFFF80008000000000000000 (cc=0) ++mgrk 0000000000007FFF * 8000000000000000 = FFFFFFFFFFFFC0008000000000000000 (cc=0) ++mgrk 0000000000008000 * 8000000000000000 = FFFFFFFFFFFFC0000000000000000000 (cc=0) ++mgrk 00000000FFFFFFFF * 8000000000000000 = FFFFFFFF800000008000000000000000 (cc=0) ++mgrk 0000000080000000 * 8000000000000000 = FFFFFFFFC00000000000000000000000 (cc=0) ++mgrk 000000007FFFFFFF * 8000000000000000 = FFFFFFFFC00000008000000000000000 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mgrk 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 8000000000000000 = C0000000000000008000000000000000 (cc=0) ++msc 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 (cc=1) ++msc 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF (cc=3) ++msc 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF (cc=3) ++msc 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=3) ++msc 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF (cc=3) ++msc 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=3) ++msc 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF (cc=3) ++msc FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=3) ++msc 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF (cc=3) ++msrkc 0000000000000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000008000 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000080000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF000000000000000000000002 (cc=0) ++msrkc 8000000000000000 * 8000000000000000 = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000000000000000000002 (cc=0) ++msgc 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 (cc=1) ++msgc 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF (cc=3) ++msgc 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF (cc=3) ++msgc 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=3) ++msgc 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF (cc=3) ++msgc 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=3) ++msgc 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF (cc=3) ++msgc FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF (cc=3) ++msgc 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 8000000000000000 = 80000000000000000000000000000002 (cc=1) ++msgrkc 000000000000FFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc 0000000000007FFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc 0000000000008000 * 8000000000000000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 00000000FFFFFFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc 0000000080000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 000000007FFFFFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc FFFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc 8000000000000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++mg 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF (cc=0) ++mg 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 (cc=0) ++mg 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8001 (cc=0) ++mg 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8000 (cc=0) ++mg 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF00000001 (cc=0) ++mg 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000000 (cc=0) ++mg 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 (cc=0) ++mg FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000000000000000000001 (cc=0) ++mg 8000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000008000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF8000000000000001 (cc=0) ++mgh 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++mgh 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++mgh 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++mgh 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF (cc=0) ++mgrk 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 (cc=0) ++mgrk 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8001 (cc=0) ++mgrk 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8000 (cc=0) ++mgrk 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF00000001 (cc=0) ++mgrk 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000000 (cc=0) ++mgrk 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000000000000000000001 (cc=0) ++mgrk 8000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000008000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF8000000000000001 (cc=0) ++msc 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=1) ++msc 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=1) ++msc 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF (cc=1) ++msc 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=1) ++msc 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF (cc=2) ++msc 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=3) ++msc 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF (cc=1) ++msc FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=2) ++msc 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=2) ++msrkc 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000002 (cc=1) ++msrkc 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF00010000000000000002 (cc=1) ++msrkc 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000000002 (cc=1) ++msrkc 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000000002 (cc=1) ++msrkc 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000010000000000000002 (cc=2) ++msrkc 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000000000002 (cc=3) ++msrkc 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 00000000800000010000000000000002 (cc=1) ++msrkc FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF000000010000000000000002 (cc=2) ++msrkc 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000010000000000000002 (cc=2) ++msgc 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=1) ++msgc 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=1) ++msgc 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=1) ++msgc 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=1) ++msgc 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=1) ++msgc 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=1) ++msgc 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=1) ++msgc FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=2) ++msgc 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=1) ++msgrkc 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000002 (cc=1) ++msgrkc 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF00010000000000000002 (cc=1) ++msgrkc 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000000002 (cc=1) ++msgrkc 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000000002 (cc=1) ++msgrkc 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF000000010000000000000002 (cc=1) ++msgrkc 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000000000002 (cc=1) ++msgrkc 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF800000010000000000000002 (cc=1) ++msgrkc FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000010000000000000002 (cc=2) ++msgrkc 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000010000000000000002 (cc=1) ++mg 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 7FFFFFFF00000000 = 00000000000000007FFFFFFF00000000 (cc=0) ++mg 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF7FFF000100000000 (cc=0) ++mg 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF7FFF800100000000 (cc=0) ++mg 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFFFFFF800000000000 (cc=0) ++mg 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000007FFFFFFE8000000100000000 (cc=0) ++mg 0000000080000000 * 7FFFFFFF00000000 = 000000003FFFFFFF8000000000000000 (cc=0) ++mg 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000100000000 (cc=0) ++mg FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFFFFFF8000000100000000 (cc=0) ++mg 8000000000000000 * 7FFFFFFF00000000 = C0000000800000000000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 3FFFFFFF7FFFFFFF8000000100000000 (cc=0) ++mgh 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 7FFFFFFF00000000 = 0000000000007FFF0000000000000001 (cc=0) ++mgh 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFE8001000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 7FFFFFFF00000000 = 000000003FFF00010000000000007FFF (cc=0) ++mgh 0000000000008000 * 7FFFFFFF00000000 = 000000003FFF80000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 7FFFFFFF00000000 = 00007FFEFFFF800100000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 7FFFFFFF00000000 = 00003FFF800000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 7FFFFFFF00000000 = 00003FFF7FFF8001000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 7FFFFFFF00000000 = 00000000000000007FFFFFFF00000000 (cc=0) ++mgrk 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF7FFF000100000000 (cc=0) ++mgrk 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF7FFF800100000000 (cc=0) ++mgrk 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFFFFFF800000000000 (cc=0) ++mgrk 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000007FFFFFFE8000000100000000 (cc=0) ++mgrk 0000000080000000 * 7FFFFFFF00000000 = 000000003FFFFFFF8000000000000000 (cc=0) ++mgrk 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000100000000 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFFFFFF8000000100000000 (cc=0) ++mgrk 8000000000000000 * 7FFFFFFF00000000 = C0000000800000000000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 3FFFFFFF7FFFFFFF8000000100000000 (cc=0) ++msc 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 7FFFFFFF00000000 = 000000007FFFFFFF0000000000000001 (cc=2) ++msc 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFF0001000000000000FFFF (cc=3) ++msc 0000000000007FFF * 7FFFFFFF00000000 = 000000007FFF80010000000000007FFF (cc=3) ++msc 0000000000008000 * 7FFFFFFF00000000 = 00000000FFFF80000000000000008000 (cc=3) ++msc 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000008000000100000000FFFFFFFF (cc=1) ++msc 0000000080000000 * 7FFFFFFF00000000 = 00000000800000000000000080000000 (cc=3) ++msc 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000000000001000000007FFFFFFF (cc=3) ++msc FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=1) ++msc 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=1) ++msrkc 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000000000FFFF * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000007FFF * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000008000 * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000080000000 * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000007FFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF000000000000000000000002 (cc=0) ++msrkc 8000000000000000 * 7FFFFFFF00000000 = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF000000000000000000000002 (cc=0) ++msgc 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 7FFFFFFF00000000 = 7FFFFFFF000000000000000000000001 (cc=2) ++msgc 000000000000FFFF * 7FFFFFFF00000000 = 7FFF000100000000000000000000FFFF (cc=3) ++msgc 0000000000007FFF * 7FFFFFFF00000000 = 7FFF8001000000000000000000007FFF (cc=3) ++msgc 0000000000008000 * 7FFFFFFF00000000 = FFFF8000000000000000000000008000 (cc=3) ++msgc 00000000FFFFFFFF * 7FFFFFFF00000000 = 800000010000000000000000FFFFFFFF (cc=3) ++msgc 0000000080000000 * 7FFFFFFF00000000 = 80000000000000000000000080000000 (cc=3) ++msgc 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000100000000000000007FFFFFFF (cc=3) ++msgc FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 8000000100000000FFFFFFFFFFFFFFFF (cc=1) ++msgc 8000000000000000 * 7FFFFFFF00000000 = 00000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 80000001000000007FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 7FFFFFFF00000000 = 7FFFFFFF000000000000000000000002 (cc=2) ++msgrkc 000000000000FFFF * 7FFFFFFF00000000 = 7FFF0001000000000000000000000002 (cc=3) ++msgrkc 0000000000007FFF * 7FFFFFFF00000000 = 7FFF8001000000000000000000000002 (cc=3) ++msgrkc 0000000000008000 * 7FFFFFFF00000000 = FFFF8000000000000000000000000002 (cc=3) ++msgrkc 00000000FFFFFFFF * 7FFFFFFF00000000 = 80000001000000000000000000000002 (cc=3) ++msgrkc 0000000080000000 * 7FFFFFFF00000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc 000000007FFFFFFF * 7FFFFFFF00000000 = 00000001000000000000000000000002 (cc=3) ++msgrkc FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 80000001000000000000000000000002 (cc=1) ++msgrkc 8000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 80000001000000000000000000000002 (cc=3) ++mg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 8000000000000000 = FFFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mg 000000000000FFFF * 8000000000000000 = FFFFFFFFFFFF80008000000000000000 (cc=0) ++mg 0000000000007FFF * 8000000000000000 = FFFFFFFFFFFFC0008000000000000000 (cc=0) ++mg 0000000000008000 * 8000000000000000 = FFFFFFFFFFFFC0000000000000000000 (cc=0) ++mg 00000000FFFFFFFF * 8000000000000000 = FFFFFFFF800000008000000000000000 (cc=0) ++mg 0000000080000000 * 8000000000000000 = FFFFFFFFC00000000000000000000000 (cc=0) ++mg 000000007FFFFFFF * 8000000000000000 = FFFFFFFFC00000008000000000000000 (cc=0) ++mg FFFFFFFFFFFFFFFF * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mg 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 8000000000000000 = C0000000000000008000000000000000 (cc=0) ++mgh 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 8000000000000000 = FFFFFFFFFFFF80000000000000000001 (cc=0) ++mgh 000000000000FFFF * 8000000000000000 = FFFFFFFF80008000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 8000000000000000 = FFFFFFFFC00080000000000000007FFF (cc=0) ++mgh 0000000000008000 * 8000000000000000 = FFFFFFFFC00000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 8000000000000000 = FFFF80000000800000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 8000000000000000 = FFFFC000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 8000000000000000 = FFFFC00000008000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000000008000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000000080007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 8000000000000000 = FFFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mgrk 000000000000FFFF * 8000000000000000 = FFFFFFFFFFFF80008000000000000000 (cc=0) ++mgrk 0000000000007FFF * 8000000000000000 = FFFFFFFFFFFFC0008000000000000000 (cc=0) ++mgrk 0000000000008000 * 8000000000000000 = FFFFFFFFFFFFC0000000000000000000 (cc=0) ++mgrk 00000000FFFFFFFF * 8000000000000000 = FFFFFFFF800000008000000000000000 (cc=0) ++mgrk 0000000080000000 * 8000000000000000 = FFFFFFFFC00000000000000000000000 (cc=0) ++mgrk 000000007FFFFFFF * 8000000000000000 = FFFFFFFFC00000008000000000000000 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mgrk 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 8000000000000000 = C0000000000000008000000000000000 (cc=0) ++msc 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 (cc=1) ++msc 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF (cc=3) ++msc 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF (cc=3) ++msc 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=3) ++msc 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF (cc=3) ++msc 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=3) ++msc 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF (cc=3) ++msc FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=3) ++msc 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF (cc=3) ++msrkc 0000000000000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000008000 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000080000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msrkc FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF000000000000000000000002 (cc=0) ++msrkc 8000000000000000 * 8000000000000000 = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000000000000000000002 (cc=0) ++msgc 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 (cc=1) ++msgc 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF (cc=3) ++msgc 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF (cc=3) ++msgc 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=3) ++msgc 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF (cc=3) ++msgc 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=3) ++msgc 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF (cc=3) ++msgc FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF (cc=3) ++msgc 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 8000000000000000 = 80000000000000000000000000000002 (cc=1) ++msgrkc 000000000000FFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc 0000000000007FFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc 0000000000008000 * 8000000000000000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 00000000FFFFFFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc 0000000080000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 000000007FFFFFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc FFFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++msgrkc 8000000000000000 * 8000000000000000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000000000000000000002 (cc=3) ++mg 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * FFFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFFFFFF00000000 (cc=0) ++mg 000000000000FFFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFF000100000000 (cc=0) ++mg 0000000000007FFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFF800100000000 (cc=0) ++mg 0000000000008000 * FFFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFF800000000000 (cc=0) ++mg 00000000FFFFFFFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFF0000000100000000 (cc=0) ++mg 0000000080000000 * FFFFFFFF00000000 = FFFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mg 000000007FFFFFFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFF8000000100000000 (cc=0) ++mg FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000100000000 (cc=0) ++mg 8000000000000000 * FFFFFFFF00000000 = 00000000800000000000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF800000000000000100000000 (cc=0) ++mgh 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * FFFFFFFF00000000 = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++mgh 000000000000FFFF * FFFFFFFF00000000 = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++mgh 0000000000007FFF * FFFFFFFF00000000 = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++mgh 0000000000008000 * FFFFFFFF00000000 = FFFFFFFFFFFF80000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * FFFFFFFF00000000 = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * FFFFFFFF00000000 = FFFFFFFF800000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * FFFFFFFF00000000 = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * FFFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFFFFFF00000000 (cc=0) ++mgrk 000000000000FFFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFF000100000000 (cc=0) ++mgrk 0000000000007FFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFF800100000000 (cc=0) ++mgrk 0000000000008000 * FFFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFF800000000000 (cc=0) ++mgrk 00000000FFFFFFFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFF0000000100000000 (cc=0) ++mgrk 0000000080000000 * FFFFFFFF00000000 = FFFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mgrk 000000007FFFFFFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFF8000000100000000 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000100000000 (cc=0) ++mgrk 8000000000000000 * FFFFFFFF00000000 = 00000000800000000000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF800000000000000100000000 (cc=0) ++msc 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF0000000000000001 (cc=1) ++msc 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFF0001000000000000FFFF (cc=1) ++msc 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFF80010000000000007FFF (cc=1) ++msc 0000000000008000 * FFFFFFFF00000000 = 00000000FFFF80000000000000008000 (cc=1) ++msc 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000100000000FFFFFFFF (cc=2) ++msc 0000000080000000 * FFFFFFFF00000000 = 00000000800000000000000080000000 (cc=3) ++msc 000000007FFFFFFF * FFFFFFFF00000000 = 0000000080000001000000007FFFFFFF (cc=1) ++msc FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=2) ++msc 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=2) ++msrkc 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000000000FFFF * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000007FFF * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000008000 * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 000000007FFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msrkc FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF000000000000000000000002 (cc=0) ++msrkc 8000000000000000 * FFFFFFFF00000000 = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000000000000000000002 (cc=0) ++msgc 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * FFFFFFFF00000000 = FFFFFFFF000000000000000000000001 (cc=1) ++msgc 000000000000FFFF * FFFFFFFF00000000 = FFFF000100000000000000000000FFFF (cc=1) ++msgc 0000000000007FFF * FFFFFFFF00000000 = FFFF8001000000000000000000007FFF (cc=1) ++msgc 0000000000008000 * FFFFFFFF00000000 = FFFF8000000000000000000000008000 (cc=1) ++msgc 00000000FFFFFFFF * FFFFFFFF00000000 = 000000010000000000000000FFFFFFFF (cc=3) ++msgc 0000000080000000 * FFFFFFFF00000000 = 80000000000000000000000080000000 (cc=1) ++msgc 000000007FFFFFFF * FFFFFFFF00000000 = 8000000100000000000000007FFFFFFF (cc=1) ++msgc FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000100000000FFFFFFFFFFFFFFFF (cc=2) ++msgc 8000000000000000 * FFFFFFFF00000000 = 00000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000001000000007FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * FFFFFFFF00000000 = FFFFFFFF000000000000000000000002 (cc=1) ++msgrkc 000000000000FFFF * FFFFFFFF00000000 = FFFF0001000000000000000000000002 (cc=1) ++msgrkc 0000000000007FFF * FFFFFFFF00000000 = FFFF8001000000000000000000000002 (cc=1) ++msgrkc 0000000000008000 * FFFFFFFF00000000 = FFFF8000000000000000000000000002 (cc=1) ++msgrkc 00000000FFFFFFFF * FFFFFFFF00000000 = 00000001000000000000000000000002 (cc=3) ++msgrkc 0000000080000000 * FFFFFFFF00000000 = 80000000000000000000000000000002 (cc=1) ++msgrkc 000000007FFFFFFF * FFFFFFFF00000000 = 80000001000000000000000000000002 (cc=1) ++msgrkc FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000001000000000000000000000002 (cc=2) ++msgrkc 8000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000001000000000000000000000002 (cc=3) ++mg 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mg 000000000000FFFF * 000000007FFFFFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mg 0000000000007FFF * 000000007FFFFFFF = 000000000000000000003FFF7FFF8001 (cc=0) ++mg 0000000000008000 * 000000007FFFFFFF = 000000000000000000003FFFFFFF8000 (cc=0) ++mg 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000007FFFFFFE80000001 (cc=0) ++mg 0000000080000000 * 000000007FFFFFFF = 00000000000000003FFFFFFF80000000 (cc=0) ++mg 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000003FFFFFFF00000001 (cc=0) ++mg FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 (cc=0) ++mg 8000000000000000 * 000000007FFFFFFF = FFFFFFFFC00000008000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 (cc=0) ++mgh 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 (cc=0) ++mgh 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF (cc=0) ++mgh 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 000000007FFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 000000007FFFFFFF = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mgrk 000000000000FFFF * 000000007FFFFFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mgrk 0000000000007FFF * 000000007FFFFFFF = 000000000000000000003FFF7FFF8001 (cc=0) ++mgrk 0000000000008000 * 000000007FFFFFFF = 000000000000000000003FFFFFFF8000 (cc=0) ++mgrk 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000007FFFFFFE80000001 (cc=0) ++mgrk 0000000080000000 * 000000007FFFFFFF = 00000000000000003FFFFFFF80000000 (cc=0) ++mgrk 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000003FFFFFFF00000001 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 (cc=0) ++mgrk 8000000000000000 * 000000007FFFFFFF = FFFFFFFFC00000008000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 (cc=0) ++msc 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 (cc=0) ++msc 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++msc 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF (cc=0) ++msc 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 (cc=0) ++msc 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msc 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 (cc=0) ++msc 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msc FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msc 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msrkc 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000002 (cc=2) ++msrkc 000000000000FFFF * 000000007FFFFFFF = 000000007FFF00010000000000000002 (cc=3) ++msrkc 0000000000007FFF * 000000007FFFFFFF = 000000007FFF80010000000000000002 (cc=3) ++msrkc 0000000000008000 * 000000007FFFFFFF = 00000000FFFF80000000000000000002 (cc=3) ++msrkc 00000000FFFFFFFF * 000000007FFFFFFF = 00000000800000010000000000000002 (cc=1) ++msrkc 0000000080000000 * 000000007FFFFFFF = 00000000800000000000000000000002 (cc=3) ++msrkc 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000010000000000000002 (cc=3) ++msrkc FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF800000010000000000000002 (cc=1) ++msrkc 8000000000000000 * 000000007FFFFFFF = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000010000000000000002 (cc=1) ++msgc 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 (cc=2) ++msgc 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF0001000000000000FFFF (cc=2) ++msgc 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000007FFF (cc=2) ++msgc 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000008000 (cc=2) ++msgc 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF (cc=2) ++msgc 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000080000000 (cc=2) ++msgc 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF00000001000000007FFFFFFF (cc=2) ++msgc FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=1) ++msgc 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000002 (cc=2) ++msgrkc 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF00010000000000000002 (cc=2) ++msgrkc 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000000002 (cc=2) ++msgrkc 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000000002 (cc=2) ++msgrkc 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE800000010000000000000002 (cc=2) ++msgrkc 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000000000002 (cc=2) ++msgrkc 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF000000010000000000000002 (cc=2) ++msgrkc FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF800000010000000000000002 (cc=1) ++msgrkc 8000000000000000 * 000000007FFFFFFF = 80000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000010000000000000002 (cc=3) ++mg 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++mg 000000000000FFFF * 0000000080000000 = 000000000000000000007FFF80000000 (cc=0) ++mg 0000000000007FFF * 0000000080000000 = 000000000000000000003FFF80000000 (cc=0) ++mg 0000000000008000 * 0000000080000000 = 00000000000000000000400000000000 (cc=0) ++mg 00000000FFFFFFFF * 0000000080000000 = 00000000000000007FFFFFFF80000000 (cc=0) ++mg 0000000080000000 * 0000000080000000 = 00000000000000004000000000000000 (cc=0) ++mg 000000007FFFFFFF * 0000000080000000 = 00000000000000003FFFFFFF80000000 (cc=0) ++mg FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFFFFFFFFFFFFFFFFFF80000000 (cc=0) ++mg 8000000000000000 * 0000000080000000 = FFFFFFFFC00000000000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 0000000080000000 = 000000003FFFFFFFFFFFFFFF80000000 (cc=0) ++mgh 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 (cc=0) ++mgh 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF (cc=0) ++mgh 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 0000000080000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 0000000080000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++mgrk 000000000000FFFF * 0000000080000000 = 000000000000000000007FFF80000000 (cc=0) ++mgrk 0000000000007FFF * 0000000080000000 = 000000000000000000003FFF80000000 (cc=0) ++mgrk 0000000000008000 * 0000000080000000 = 00000000000000000000400000000000 (cc=0) ++mgrk 00000000FFFFFFFF * 0000000080000000 = 00000000000000007FFFFFFF80000000 (cc=0) ++mgrk 0000000080000000 * 0000000080000000 = 00000000000000004000000000000000 (cc=0) ++mgrk 000000007FFFFFFF * 0000000080000000 = 00000000000000003FFFFFFF80000000 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFFFFFFFFFFFFFFFFFF80000000 (cc=0) ++mgrk 8000000000000000 * 0000000080000000 = FFFFFFFFC00000000000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 0000000080000000 = 000000003FFFFFFFFFFFFFFF80000000 (cc=0) ++msc 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 (cc=0) ++msc 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF (cc=0) ++msc 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF (cc=0) ++msc 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 (cc=0) ++msc 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msc 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++msc 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msc FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msc 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msrkc 0000000000000000 * 0000000080000000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 0000000080000000 = 00000000800000000000000000000002 (cc=1) ++msrkc 000000000000FFFF * 0000000080000000 = 00000000800000000000000000000002 (cc=3) ++msrkc 0000000000007FFF * 0000000080000000 = 00000000800000000000000000000002 (cc=3) ++msrkc 0000000000008000 * 0000000080000000 = 00000000000000000000000000000002 (cc=3) ++msrkc 00000000FFFFFFFF * 0000000080000000 = 00000000800000000000000000000002 (cc=3) ++msrkc 0000000080000000 * 0000000080000000 = 00000000000000000000000000000002 (cc=3) ++msrkc 000000007FFFFFFF * 0000000080000000 = 00000000800000000000000000000002 (cc=3) ++msrkc FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF800000000000000000000002 (cc=3) ++msrkc 8000000000000000 * 0000000080000000 = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF800000000000000000000002 (cc=3) ++msgc 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 0000000080000000 = 00000000800000000000000000000001 (cc=2) ++msgc 000000000000FFFF * 0000000080000000 = 00007FFF80000000000000000000FFFF (cc=2) ++msgc 0000000000007FFF * 0000000080000000 = 00003FFF800000000000000000007FFF (cc=2) ++msgc 0000000000008000 * 0000000080000000 = 00004000000000000000000000008000 (cc=2) ++msgc 00000000FFFFFFFF * 0000000080000000 = 7FFFFFFF8000000000000000FFFFFFFF (cc=2) ++msgc 0000000080000000 * 0000000080000000 = 40000000000000000000000080000000 (cc=2) ++msgc 000000007FFFFFFF * 0000000080000000 = 3FFFFFFF80000000000000007FFFFFFF (cc=2) ++msgc FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=1) ++msgc 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF800000007FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 0000000080000000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 0000000080000000 = 00000000800000000000000000000002 (cc=2) ++msgrkc 000000000000FFFF * 0000000080000000 = 00007FFF800000000000000000000002 (cc=2) ++msgrkc 0000000000007FFF * 0000000080000000 = 00003FFF800000000000000000000002 (cc=2) ++msgrkc 0000000000008000 * 0000000080000000 = 00004000000000000000000000000002 (cc=2) ++msgrkc 00000000FFFFFFFF * 0000000080000000 = 7FFFFFFF800000000000000000000002 (cc=2) ++msgrkc 0000000080000000 * 0000000080000000 = 40000000000000000000000000000002 (cc=2) ++msgrkc 000000007FFFFFFF * 0000000080000000 = 3FFFFFFF800000000000000000000002 (cc=2) ++msgrkc FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF800000000000000000000002 (cc=1) ++msgrkc 8000000000000000 * 0000000080000000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF800000000000000000000002 (cc=3) ++mg 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mg 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mg 0000000000007FFF * 00000000FFFFFFFF = 000000000000000000007FFEFFFF8001 (cc=0) ++mg 0000000000008000 * 00000000FFFFFFFF = 000000000000000000007FFFFFFF8000 (cc=0) ++mg 00000000FFFFFFFF * 00000000FFFFFFFF = 0000000000000000FFFFFFFE00000001 (cc=0) ++mg 0000000080000000 * 00000000FFFFFFFF = 00000000000000007FFFFFFF80000000 (cc=0) ++mg 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000007FFFFFFE80000001 (cc=0) ++mg FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF00000001 (cc=0) ++mg 8000000000000000 * 00000000FFFFFFFF = FFFFFFFF800000008000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 (cc=0) ++mgh 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 (cc=0) ++mgh 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF (cc=0) ++mgh 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 00000000FFFFFFFF = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mgrk 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mgrk 0000000000007FFF * 00000000FFFFFFFF = 000000000000000000007FFEFFFF8001 (cc=0) ++mgrk 0000000000008000 * 00000000FFFFFFFF = 000000000000000000007FFFFFFF8000 (cc=0) ++mgrk 00000000FFFFFFFF * 00000000FFFFFFFF = 0000000000000000FFFFFFFE00000001 (cc=0) ++mgrk 0000000080000000 * 00000000FFFFFFFF = 00000000000000007FFFFFFF80000000 (cc=0) ++mgrk 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000007FFFFFFE80000001 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF00000001 (cc=0) ++mgrk 8000000000000000 * 00000000FFFFFFFF = FFFFFFFF800000008000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 (cc=0) ++msc 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 (cc=0) ++msc 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++msc 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF (cc=0) ++msc 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 (cc=0) ++msc 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msc 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 (cc=0) ++msc 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msc FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msc 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msrkc 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF0000000000000002 (cc=1) ++msrkc 000000000000FFFF * 00000000FFFFFFFF = 00000000FFFF00010000000000000002 (cc=1) ++msrkc 0000000000007FFF * 00000000FFFFFFFF = 00000000FFFF80010000000000000002 (cc=1) ++msrkc 0000000000008000 * 00000000FFFFFFFF = 00000000FFFF80000000000000000002 (cc=1) ++msrkc 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000000000010000000000000002 (cc=2) ++msrkc 0000000080000000 * 00000000FFFFFFFF = 00000000800000000000000000000002 (cc=3) ++msrkc 000000007FFFFFFF * 00000000FFFFFFFF = 00000000800000010000000000000002 (cc=1) ++msrkc FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF000000010000000000000002 (cc=2) ++msrkc 8000000000000000 * 00000000FFFFFFFF = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000010000000000000002 (cc=2) ++msgc 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=2) ++msgc 000000000000FFFF * 00000000FFFFFFFF = 0000FFFEFFFF0001000000000000FFFF (cc=2) ++msgc 0000000000007FFF * 00000000FFFFFFFF = 00007FFEFFFF80010000000000007FFF (cc=2) ++msgc 0000000000008000 * 00000000FFFFFFFF = 00007FFFFFFF80000000000000008000 (cc=2) ++msgc 00000000FFFFFFFF * 00000000FFFFFFFF = FFFFFFFE0000000100000000FFFFFFFF (cc=3) ++msgc 0000000080000000 * 00000000FFFFFFFF = 7FFFFFFF800000000000000080000000 (cc=2) ++msgc 000000007FFFFFFF * 00000000FFFFFFFF = 7FFFFFFE80000001000000007FFFFFFF (cc=2) ++msgc FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=1) ++msgc 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF0000000000000002 (cc=2) ++msgrkc 000000000000FFFF * 00000000FFFFFFFF = 0000FFFEFFFF00010000000000000002 (cc=2) ++msgrkc 0000000000007FFF * 00000000FFFFFFFF = 00007FFEFFFF80010000000000000002 (cc=2) ++msgrkc 0000000000008000 * 00000000FFFFFFFF = 00007FFFFFFF80000000000000000002 (cc=2) ++msgrkc 00000000FFFFFFFF * 00000000FFFFFFFF = FFFFFFFE000000010000000000000002 (cc=3) ++msgrkc 0000000080000000 * 00000000FFFFFFFF = 7FFFFFFF800000000000000000000002 (cc=2) ++msgrkc 000000007FFFFFFF * 00000000FFFFFFFF = 7FFFFFFE800000010000000000000002 (cc=2) ++msgrkc FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF000000010000000000000002 (cc=1) ++msgrkc 8000000000000000 * 00000000FFFFFFFF = 80000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000010000000000000002 (cc=3) ++mg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mg 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mg 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mg 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mg 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mg 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 (cc=0) ++mg 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mg FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 (cc=0) ++mg 8000000000000000 * 000000000000FFFF = FFFFFFFFFFFF80008000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++mgh 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++mgh 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++mgh 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 000000000000FFFF = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 000000000000FFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mgrk 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mgrk 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mgrk 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mgrk 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mgrk 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 (cc=0) ++mgrk 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 (cc=0) ++mgrk 8000000000000000 * 000000000000FFFF = FFFFFFFFFFFF80008000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++msc 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++msc 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++msc 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++msc 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++msc 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msc 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++msc 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msc FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msc 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msrkc 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000002 (cc=2) ++msrkc 000000000000FFFF * 000000000000FFFF = 00000000FFFE00010000000000000002 (cc=3) ++msrkc 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000000002 (cc=2) ++msrkc 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000000002 (cc=2) ++msrkc 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFF00010000000000000002 (cc=1) ++msrkc 0000000080000000 * 000000000000FFFF = 00000000800000000000000000000002 (cc=3) ++msrkc 000000007FFFFFFF * 000000000000FFFF = 000000007FFF00010000000000000002 (cc=3) ++msrkc FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF00010000000000000002 (cc=1) ++msrkc 8000000000000000 * 000000000000FFFF = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00010000000000000002 (cc=1) ++msgc 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=2) ++msgc 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=2) ++msgc 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=2) ++msgc 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=2) ++msgc 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF (cc=2) ++msgc 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 (cc=2) ++msgc 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF (cc=2) ++msgc FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=1) ++msgc 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000002 (cc=2) ++msgrkc 000000000000FFFF * 000000000000FFFF = 00000000FFFE00010000000000000002 (cc=2) ++msgrkc 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000000002 (cc=2) ++msgrkc 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000000002 (cc=2) ++msgrkc 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF00010000000000000002 (cc=2) ++msgrkc 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000000000002 (cc=2) ++msgrkc 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF00010000000000000002 (cc=2) ++msgrkc FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF00010000000000000002 (cc=1) ++msgrkc 8000000000000000 * 000000000000FFFF = 80000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00010000000000000002 (cc=3) ++mg 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++mg 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 (cc=0) ++mg 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 (cc=0) ++mg 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 (cc=0) ++mg 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000007FFEFFFF8001 (cc=0) ++mg 0000000080000000 * 0000000000007FFF = 000000000000000000003FFF80000000 (cc=0) ++mg 000000007FFFFFFF * 0000000000007FFF = 000000000000000000003FFF7FFF8001 (cc=0) ++mg FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8001 (cc=0) ++mg 8000000000000000 * 0000000000007FFF = FFFFFFFFFFFFC0008000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000003FFF7FFFFFFFFFFF8001 (cc=0) ++mgh 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 (cc=0) ++mgh 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++mgh 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 0000000000007FFF = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 0000000000007FFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++mgrk 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 (cc=0) ++mgrk 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 (cc=0) ++mgrk 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 (cc=0) ++mgrk 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000007FFEFFFF8001 (cc=0) ++mgrk 0000000080000000 * 0000000000007FFF = 000000000000000000003FFF80000000 (cc=0) ++mgrk 000000007FFFFFFF * 0000000000007FFF = 000000000000000000003FFF7FFF8001 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8001 (cc=0) ++mgrk 8000000000000000 * 0000000000007FFF = FFFFFFFFFFFFC0008000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000003FFF7FFFFFFFFFFF8001 (cc=0) ++msc 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 (cc=0) ++msc 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF (cc=0) ++msc 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++msc 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 (cc=0) ++msc 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF (cc=0) ++msc 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 (cc=0) ++msc 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF (cc=0) ++msc FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msc 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msrkc 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000002 (cc=2) ++msrkc 000000000000FFFF * 0000000000007FFF = 000000007FFE80010000000000000002 (cc=2) ++msrkc 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000000002 (cc=2) ++msrkc 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000000002 (cc=2) ++msrkc 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF80010000000000000002 (cc=1) ++msrkc 0000000080000000 * 0000000000007FFF = 00000000800000000000000000000002 (cc=3) ++msrkc 000000007FFFFFFF * 0000000000007FFF = 000000007FFF80010000000000000002 (cc=3) ++msrkc FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF80010000000000000002 (cc=1) ++msrkc 8000000000000000 * 0000000000007FFF = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80010000000000000002 (cc=1) ++msgc 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=2) ++msgc 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=2) ++msgc 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=2) ++msgc 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=2) ++msgc 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF (cc=2) ++msgc 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 (cc=2) ++msgc 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF (cc=2) ++msgc FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=1) ++msgc 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000002 (cc=2) ++msgrkc 000000000000FFFF * 0000000000007FFF = 000000007FFE80010000000000000002 (cc=2) ++msgrkc 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000000002 (cc=2) ++msgrkc 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000000002 (cc=2) ++msgrkc 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF80010000000000000002 (cc=2) ++msgrkc 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000000000002 (cc=2) ++msgrkc 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF80010000000000000002 (cc=2) ++msgrkc FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF80010000000000000002 (cc=1) ++msgrkc 8000000000000000 * 0000000000007FFF = 80000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80010000000000000002 (cc=3) ++mg 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++mg 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 (cc=0) ++mg 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 (cc=0) ++mg 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 (cc=0) ++mg 00000000FFFFFFFF * 0000000000008000 = 000000000000000000007FFFFFFF8000 (cc=0) ++mg 0000000080000000 * 0000000000008000 = 00000000000000000000400000000000 (cc=0) ++mg 000000007FFFFFFF * 0000000000008000 = 000000000000000000003FFFFFFF8000 (cc=0) ++mg FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8000 (cc=0) ++mg 8000000000000000 * 0000000000008000 = FFFFFFFFFFFFC0000000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 0000000000008000 = 0000000000003FFFFFFFFFFFFFFF8000 (cc=0) ++mgh 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 (cc=0) ++mgh 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF (cc=0) ++mgh 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 0000000000008000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 0000000000008000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++mgrk 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 (cc=0) ++mgrk 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 (cc=0) ++mgrk 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 (cc=0) ++mgrk 00000000FFFFFFFF * 0000000000008000 = 000000000000000000007FFFFFFF8000 (cc=0) ++mgrk 0000000080000000 * 0000000000008000 = 00000000000000000000400000000000 (cc=0) ++mgrk 000000007FFFFFFF * 0000000000008000 = 000000000000000000003FFFFFFF8000 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8000 (cc=0) ++mgrk 8000000000000000 * 0000000000008000 = FFFFFFFFFFFFC0000000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 0000000000008000 = 0000000000003FFFFFFFFFFFFFFF8000 (cc=0) ++msc 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 (cc=0) ++msc 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF (cc=0) ++msc 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF (cc=0) ++msc 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++msc 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF (cc=0) ++msc 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 (cc=0) ++msc 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF (cc=0) ++msc FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msc 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msrkc 0000000000000000 * 0000000000008000 = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 0000000000008000 = 00000000000080000000000000000002 (cc=2) ++msrkc 000000000000FFFF * 0000000000008000 = 000000007FFF80000000000000000002 (cc=2) ++msrkc 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000000002 (cc=2) ++msrkc 0000000000008000 * 0000000000008000 = 00000000400000000000000000000002 (cc=2) ++msrkc 00000000FFFFFFFF * 0000000000008000 = 00000000FFFF80000000000000000002 (cc=1) ++msrkc 0000000080000000 * 0000000000008000 = 00000000000000000000000000000002 (cc=3) ++msrkc 000000007FFFFFFF * 0000000000008000 = 00000000FFFF80000000000000000002 (cc=3) ++msrkc FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80000000000000000002 (cc=1) ++msrkc 8000000000000000 * 0000000000008000 = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFFFFFF80000000000000000002 (cc=1) ++msgc 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 0000000000008000 = 00000000000080000000000000000001 (cc=2) ++msgc 000000000000FFFF * 0000000000008000 = 000000007FFF8000000000000000FFFF (cc=2) ++msgc 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000007FFF (cc=2) ++msgc 0000000000008000 * 0000000000008000 = 00000000400000000000000000008000 (cc=2) ++msgc 00000000FFFFFFFF * 0000000000008000 = 00007FFFFFFF800000000000FFFFFFFF (cc=2) ++msgc 0000000080000000 * 0000000000008000 = 00004000000000000000000080000000 (cc=2) ++msgc 000000007FFFFFFF * 0000000000008000 = 00003FFFFFFF8000000000007FFFFFFF (cc=2) ++msgc FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF8000FFFFFFFFFFFFFFFF (cc=1) ++msgc 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80007FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 0000000000008000 = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 0000000000008000 = 00000000000080000000000000000002 (cc=2) ++msgrkc 000000000000FFFF * 0000000000008000 = 000000007FFF80000000000000000002 (cc=2) ++msgrkc 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000000002 (cc=2) ++msgrkc 0000000000008000 * 0000000000008000 = 00000000400000000000000000000002 (cc=2) ++msgrkc 00000000FFFFFFFF * 0000000000008000 = 00007FFFFFFF80000000000000000002 (cc=2) ++msgrkc 0000000080000000 * 0000000000008000 = 00004000000000000000000000000002 (cc=2) ++msgrkc 000000007FFFFFFF * 0000000000008000 = 00003FFFFFFF80000000000000000002 (cc=2) ++msgrkc FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80000000000000000002 (cc=1) ++msgrkc 8000000000000000 * 0000000000008000 = 00000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80000000000000000002 (cc=3) ++mg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mg 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mg 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mg 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mg 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mg 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mg 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 (cc=0) ++mg 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mg FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 (cc=0) ++mg 8000000000000000 * 000000000000FFFF = FFFFFFFFFFFF80008000000000000000 (cc=0) ++mg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++mgh 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mgh 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++mgh 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mgh 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++mgh 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++mgh 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mgh 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++mgh 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mgh FFFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mgh 8000000000000000 * 000000000000FFFF = 00000000000000008000000000000000 (cc=0) ++mgh 7FFFFFFFFFFFFFFF * 000000000000FFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mgrk 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mgrk 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mgrk 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mgrk 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mgrk 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mgrk 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mgrk 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 (cc=0) ++mgrk 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mgrk FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 (cc=0) ++mgrk 8000000000000000 * 000000000000FFFF = FFFFFFFFFFFF80008000000000000000 (cc=0) ++mgrk 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++msc 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msc 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++msc 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++msc 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++msc 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++msc 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msc 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++msc 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msc FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msc 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msc 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msrkc 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000002 (cc=0) ++msrkc 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000002 (cc=2) ++msrkc 000000000000FFFF * 000000000000FFFF = 00000000FFFE00010000000000000002 (cc=3) ++msrkc 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000000002 (cc=2) ++msrkc 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000000002 (cc=2) ++msrkc 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFF00010000000000000002 (cc=1) ++msrkc 0000000080000000 * 000000000000FFFF = 00000000800000000000000000000002 (cc=3) ++msrkc 000000007FFFFFFF * 000000000000FFFF = 000000007FFF00010000000000000002 (cc=3) ++msrkc FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF00010000000000000002 (cc=1) ++msrkc 8000000000000000 * 000000000000FFFF = 80000000000000000000000000000002 (cc=0) ++msrkc 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00010000000000000002 (cc=1) ++msgc 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msgc 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=2) ++msgc 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=2) ++msgc 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=2) ++msgc 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=2) ++msgc 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF (cc=2) ++msgc 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 (cc=2) ++msgc 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF (cc=2) ++msgc FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=1) ++msgc 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=3) ++msgc 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=3) ++msgrkc 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000002 (cc=0) ++msgrkc 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000002 (cc=2) ++msgrkc 000000000000FFFF * 000000000000FFFF = 00000000FFFE00010000000000000002 (cc=2) ++msgrkc 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000000002 (cc=2) ++msgrkc 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000000002 (cc=2) ++msgrkc 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF00010000000000000002 (cc=2) ++msgrkc 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000000000002 (cc=2) ++msgrkc 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF00010000000000000002 (cc=2) ++msgrkc FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF00010000000000000002 (cc=1) ++msgrkc 8000000000000000 * 000000000000FFFF = 80000000000000000000000000000002 (cc=3) ++msgrkc 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00010000000000000002 (cc=3) +diff --git a/none/tests/s390x/mul-z14.vgtest b/none/tests/s390x/mul-z14.vgtest +new file mode 100644 +index 000000000..2836e9113 +--- /dev/null ++++ b/none/tests/s390x/mul-z14.vgtest +@@ -0,0 +1,2 @@ ++prog: mul-z14 ++prereq: ../../../tests/s390x_features s390x-mi2 +diff --git a/none/tests/s390x/mul.c b/none/tests/s390x/mul.c +index 95a11dc23..1604c8ad7 100644 +--- a/none/tests/s390x/mul.c ++++ b/none/tests/s390x/mul.c +@@ -1,7 +1,9 @@ +-#include + #include "mul.h" + #include "opcodes.h" + ++#define mhi(x, y) "mhi " x ", " y "\n" ++#define mghi(x, y) "mghi " x ", " y "\n" ++ + static void do_imm_insns(void) + { + immsweep(mhi, 0); +@@ -14,6 +16,19 @@ static void do_imm_insns(void) + immsweep(mghi, 32767); + } + ++#define m(x, y) "m " x ", " y "\n" ++#define mr(x, y) "mr " x ", " y "\n" ++#define mh(x, y) "mh " x ", " y "\n" ++#define mlg(x, y) "mlg " x ", " y "\n" ++#define mlgr(x, y) "mlgr " x ", " y "\n" ++#define ml(x, y) "ml " x ", " y "\n" ++#define mlr(x, y) "mlr " x ", " y "\n" ++#define ms(x, y) "ms " x ", " y "\n" ++#define msr(x, y) "msr " x ", " y "\n" ++#define msg(x, y) "msg " x ", " y "\n" ++#define msgr(x, y) "msgr " x ", " y "\n" ++#define msgf(x, y) "msgf " x ", " y "\n" ++#define msgfr(x, y) "msgfr " x ", " y "\n" + + static void do_regmem_insns(unsigned long m2) + { +@@ -35,20 +50,6 @@ static void do_regmem_insns(unsigned long m2) + + int main() + { +- do_regmem_insns(0x0ul); +- do_regmem_insns(0x7ffffffffffffffful); +- do_regmem_insns(0x8000000000000000ul); +- do_regmem_insns(0xfffffffffffffffful); +- do_regmem_insns(0x7fffffff00000000ul); +- do_regmem_insns(0x8000000000000000ul); +- do_regmem_insns(0xffffffff00000000ul); +- do_regmem_insns(0x000000007ffffffful); +- do_regmem_insns(0x0000000080000000ul); +- do_regmem_insns(0x00000000fffffffful); +- do_regmem_insns(0x000000000000fffful); +- do_regmem_insns(0x0000000000007ffful); +- do_regmem_insns(0x0000000000008000ul); +- do_regmem_insns(0x000000000000fffful); ++ for_each_m2(do_regmem_insns); + do_imm_insns(); +- return 0; + } +diff --git a/none/tests/s390x/mul.h b/none/tests/s390x/mul.h +index edb2aa876..27290b572 100644 +--- a/none/tests/s390x/mul.h ++++ b/none/tests/s390x/mul.h +@@ -4,58 +4,101 @@ + ({ \ + unsigned long tmp1 = m1; \ + unsigned long tmp2 = m1; \ +- asm volatile( "lgr 2, %0\n" \ +- "lgr 3, %1\n" \ +- #insn " 2, %2\n" \ +- "lgr %0,2\n" \ +- "lgr %1,3\n" \ +- : "+d" (tmp1), "+d" (tmp2) \ +- : "Q" (m2) \ +- : "2","3"); \ +- printf(#insn " %16.16lX * %16.16lX = %16.16lX%16.16lX\n", m1, m2, tmp1, tmp2); \ ++ int cc; \ ++ asm volatile( "lgr 2, %[tmp1]\n" \ ++ "lgr 3, %[tmp2]\n" \ ++ "xr %[cc],%[cc]\n" \ ++ insn("2", "%[m2]") \ ++ "ipm %[cc]\n" \ ++ "srl %[cc],28\n" \ ++ "lgr %[tmp1],2\n" \ ++ "lgr %[tmp2],3\n" \ ++ : [tmp1] "+d" (tmp1) \ ++ , [tmp2] "+d" (tmp2) \ ++ , [cc] "=&d" (cc) \ ++ : [m2] "Q" (m2) \ ++ : "2","3","cc"); \ ++ printf(#insn " %16.16lX * %16.16lX = %16.16lX%16.16lX (cc=%d)\n", m1, m2, tmp1, tmp2, cc); \ + }) + + #define MUL_REG_REG(insn, m1, m2) \ + ({ \ + unsigned long tmp1 = m1; \ + unsigned long tmp2 = m1; \ +- asm volatile( "lgr 2, %0\n" \ +- "lgr 3, %1\n" \ +- #insn " 2, %2\n" \ +- "lgr %0,2\n" \ +- "lgr %1,3\n" \ +- : "+d" (tmp1), "+d" (tmp2) \ +- : "d" (m2) \ +- : "2","3"); \ +- printf(#insn " %16.16lX * %16.16lX = %16.16lX%16.16lX\n", m1, m2, tmp1, tmp2); \ ++ int cc; \ ++ asm volatile( "lgr 2, %[tmp1]\n" \ ++ "lgr 3, %[tmp2]\n" \ ++ "xr %[cc],%[cc]\n" \ ++ insn("2", "%[m2]") \ ++ "ipm %[cc]\n" \ ++ "srl %[cc],28\n" \ ++ "lgr %[tmp1],2\n" \ ++ "lgr %[tmp2],3\n" \ ++ : [tmp1] "+d" (tmp1) \ ++ , [tmp2] "+d" (tmp2) \ ++ , [cc] "=&d" (cc) \ ++ : [m2] "d" (m2) \ ++ : "2","3","cc"); \ ++ printf(#insn " %16.16lX * %16.16lX = %16.16lX%16.16lX (cc=%d)\n", m1, m2, tmp1, tmp2, cc); \ ++}) ++ ++#define MUL_REG_REG_REG(insn, m1, m2) \ ++({ \ ++ unsigned long tmp1 = m1; \ ++ unsigned long tmp2 = m1; \ ++ int cc; \ ++ asm volatile( "xr %[cc],%[cc]\n" \ ++ insn("2", "%[tmp1]", "%[m2]") \ ++ "ipm %[cc]\n" \ ++ "srl %[cc],28\n" \ ++ "lgr %[tmp1],2\n" \ ++ "lgr %[tmp2],3\n" \ ++ : [tmp1] "+d" (tmp1) \ ++ , [tmp2] "+d" (tmp2) \ ++ , [cc] "=&d" (cc) \ ++ : [m2] "d" (m2) \ ++ : "2","3","cc"); \ ++ printf(#insn " %16.16lX * %16.16lX = %16.16lX%16.16lX (cc=%d)\n", m1, m2, tmp1, tmp2, cc); \ + }) + + #define MUL_REG_IMM(insn, m1, m2) \ + ({ \ + unsigned long tmp1 = m1; \ + unsigned long tmp2 = m1; \ +- asm volatile( "lgr 2, %0\n" \ +- "lgr 3, %1\n" \ +- #insn " 2, " #m2 "\n" \ +- "lgr %0,2\n" \ +- "lgr %1,3\n" \ +- : "+d" (tmp1), "+d" (tmp2) \ +- :: "2","3"); \ +- printf(#insn " %16.16lX * %16.16lX = %16.16lX%16.16lX\n", m1, (unsigned long) m2, tmp1, tmp2); \ ++ int cc; \ ++ asm volatile( "lgr 2, %[tmp1]\n" \ ++ "lgr 3, %[tmp2]\n" \ ++ "xr %[cc],%[cc]\n" \ ++ insn("2", #m2) \ ++ "ipm %[cc]\n" \ ++ "srl %[cc],28\n" \ ++ "lgr %[tmp1],2\n" \ ++ "lgr %[tmp2],3\n" \ ++ : [tmp1] "+d" (tmp1) \ ++ , [tmp2] "+d" (tmp2) \ ++ , [cc] "=&d" (cc) \ ++ :: "2","3","cc"); \ ++ printf(#insn " %16.16lX * %16.16lX = %16.16lX%16.16lX (cc=%d)\n", m1, (unsigned long) m2, tmp1, tmp2, cc); \ + }) + + #define MUL_REG_XIMM(insn, m1, um2, m2) \ + ({ \ + unsigned long tmp1 = m1; \ + unsigned long tmp2 = m1; \ +- asm volatile( "lgr 2, %0\n" \ +- "lgr 3, %1\n" \ ++ int cc; \ ++ asm volatile( "lgr 2, %[tmp1]\n" \ ++ "lgr 3, %[tmp2]\n" \ ++ "xr %[cc],%[cc]\n" \ + insn(2,m2) \ +- "lgr %0,2\n" \ +- "lgr %1,3\n" \ +- : "+d" (tmp1), "+d" (tmp2) \ +- :: "2","3"); \ +- printf(#insn " %16.16lX * %16.16lX = %16.16lX%16.16lX\n", m1, (unsigned long) 0x##um2##m2, tmp1, tmp2); \ ++ "ipm %[cc]\n" \ ++ "srl %[cc],28\n" \ ++ "lgr %[tmp1],2\n" \ ++ "lgr %[tmp2],3\n" \ ++ : [tmp1] "+d" (tmp1) \ ++ , [tmp2] "+d" (tmp2) \ ++ , [cc] "=&d" (cc) \ ++ :: "2","3","cc"); \ ++ printf(#insn " %16.16lX * %16.16lX = %16.16lX%16.16lX (cc=%d)\n", m1, (unsigned long) 0x##um2##m2, tmp1, tmp2, cc); \ + }) + + +@@ -89,6 +132,21 @@ + MUL_REG_REG(i, 0x7ffffffffffffffful, m2); \ + }) + ++#define regregsweep(i, m2) \ ++({ \ ++ MUL_REG_REG_REG(i, 0ul, m2); \ ++ MUL_REG_REG_REG(i, 1ul, m2); \ ++ MUL_REG_REG_REG(i, 0xfffful, m2); \ ++ MUL_REG_REG_REG(i, 0x7ffful, m2); \ ++ MUL_REG_REG_REG(i, 0x8000ul, m2); \ ++ MUL_REG_REG_REG(i, 0xfffffffful, m2); \ ++ MUL_REG_REG_REG(i, 0x80000000ul, m2); \ ++ MUL_REG_REG_REG(i, 0x7ffffffful, m2); \ ++ MUL_REG_REG_REG(i, 0xfffffffffffffffful, m2); \ ++ MUL_REG_REG_REG(i, 0x8000000000000000ul, m2); \ ++ MUL_REG_REG_REG(i, 0x7ffffffffffffffful, m2); \ ++}) ++ + #define immsweep(i, m2) \ + ({ \ + MUL_REG_IMM(i, 0ul, m2); \ +@@ -123,16 +181,23 @@ + ({ \ + unsigned long tmp1 = m1; \ + unsigned long tmp2 = m1; \ ++ int cc; \ + register unsigned long *addr asm("5") = &m2; \ +- asm volatile( "lgr 2, %0\n" \ +- "lgr 3, %1\n" \ ++ asm volatile( "lgr 2, %[tmp1]\n" \ ++ "lgr 3, %[tmp2]\n" \ ++ "xr %[cc],%[cc]\n" \ + MSY(2,0,5,000,00) \ +- "lgr %0,2\n" \ +- "lgr %1,3\n" \ +- : "+d" (tmp1), "+d" (tmp2) \ +- : "Q" (m2), "d" (addr) \ +- : "2","3"); \ +- printf("msy %16.16lX * %16.16lX = %16.16lX%16.16lX\n", m1, m2, tmp1, tmp2); \ ++ "ipm %[cc]\n" \ ++ "srl %[cc],28\n" \ ++ "lgr %[tmp1],2\n" \ ++ "lgr %[tmp2],3\n" \ ++ : [tmp1] "+d" (tmp1) \ ++ , [tmp2] "+d" (tmp2) \ ++ , [cc] "=&d" (cc) \ ++ : [m2] "Q" (m2) \ ++ , [addr] "d" (addr) \ ++ : "2","3","cc"); \ ++ printf("msy %16.16lX * %16.16lX = %16.16lX%16.16lX (cc=%d)\n", m1, m2, tmp1, tmp2, cc); \ + }) + + #define msysweep(s2) \ +@@ -154,16 +219,23 @@ + ({ \ + unsigned long tmp1 = m1; \ + unsigned long tmp2 = m1; \ ++ int cc; \ + register unsigned long *addr asm("5") = &m2; \ +- asm volatile( "lgr 2, %0\n" \ +- "lgr 3, %1\n" \ ++ asm volatile( "lgr 2, %[tmp1]\n" \ ++ "lgr 3, %[tmp2]\n" \ ++ "xr %[cc],%[cc]\n" \ + MHY(2,0,5,000,00) \ +- "lgr %0,2\n" \ +- "lgr %1,3\n" \ +- : "+d" (tmp1), "+d" (tmp2) \ +- : "Q" (m2), "d" (addr) \ +- : "2","3"); \ +- printf("mhy %16.16lX * %16.16lX = %16.16lX%16.16lX\n", m1, m2, tmp1, tmp2); \ ++ "ipm %[cc]\n" \ ++ "srl %[cc],28\n" \ ++ "lgr %[tmp1],2\n" \ ++ "lgr %[tmp2],3\n" \ ++ : [tmp1] "+d" (tmp1) \ ++ , [tmp2] "+d" (tmp2) \ ++ , [cc] "=&d" (cc) \ ++ : [m2] "Q" (m2) \ ++ , [addr] "d" (addr) \ ++ : "2","3","cc"); \ ++ printf("mhy %16.16lX * %16.16lX = %16.16lX%16.16lX (cc=%d)\n", m1, m2, tmp1, tmp2, cc); \ + }) + + #define mhysweep(s2) \ +@@ -185,16 +257,23 @@ + ({ \ + unsigned long tmp1 = m1; \ + unsigned long tmp2 = m1; \ ++ int cc; \ + register unsigned long *addr asm("5") = &m2; \ +- asm volatile( "lgr 2, %0\n" \ +- "lgr 3, %1\n" \ ++ asm volatile( "lgr 2, %[tmp1]\n" \ ++ "lgr 3, %[tmp2]\n" \ ++ "xr %[cc],%[cc]\n" \ + MFY(2,0,5,000,00) \ +- "lgr %0,2\n" \ +- "lgr %1,3\n" \ +- : "+d" (tmp1), "+d" (tmp2) \ +- : "Q" (m2), "d" (addr) \ ++ "ipm %[cc]\n" \ ++ "srl %[cc],28\n" \ ++ "lgr %[tmp1],2\n" \ ++ "lgr %[tmp2],3\n" \ ++ : [tmp1] "+d" (tmp1) \ ++ , [tmp2]"+d" (tmp2) \ ++ , [cc] "=&d" (cc) \ ++ : [m2] "Q" (m2) \ ++ , [addr] "d" (addr) \ + : "2","3"); \ +- printf("mfy %16.16lX * %16.16lX = %16.16lX%16.16lX\n", m1, m2, tmp1, tmp2); \ ++ printf("mfy %16.16lX * %16.16lX = %16.16lX%16.16lX (cc=%d)\n", m1, m2, tmp1, tmp2, cc); \ + }) + + #define mfysweep(s2) \ +@@ -211,3 +290,21 @@ + MUL_MFY(0x8000000000000000ul, s2); \ + MUL_MFY(0x7ffffffffffffffful, s2); \ + }) ++ ++#define for_each_m2(f) \ ++({ \ ++ do_regmem_insns(0x0ul); \ ++ do_regmem_insns(0x7ffffffffffffffful); \ ++ do_regmem_insns(0x8000000000000000ul); \ ++ do_regmem_insns(0xfffffffffffffffful); \ ++ do_regmem_insns(0x7fffffff00000000ul); \ ++ do_regmem_insns(0x8000000000000000ul); \ ++ do_regmem_insns(0xffffffff00000000ul); \ ++ do_regmem_insns(0x000000007ffffffful); \ ++ do_regmem_insns(0x0000000080000000ul); \ ++ do_regmem_insns(0x00000000fffffffful); \ ++ do_regmem_insns(0x000000000000fffful); \ ++ do_regmem_insns(0x0000000000007ffful); \ ++ do_regmem_insns(0x0000000000008000ul); \ ++ do_regmem_insns(0x000000000000fffful); \ ++}) +diff --git a/none/tests/s390x/mul.stdout.exp b/none/tests/s390x/mul.stdout.exp +index 0c4a5c519..2be53240f 100644 +--- a/none/tests/s390x/mul.stdout.exp ++++ b/none/tests/s390x/mul.stdout.exp +@@ -1,2244 +1,2244 @@ +-m 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-m 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 +-m 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 +-m 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 +-m 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 +-m 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-m 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 +-m 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-m FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 +-m 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 +-mr 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 +-mr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 +-mr 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 +-mr 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mr 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 +-mr 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mr FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mr 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mh 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mh 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-mh 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-mh 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-mh 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-mh 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-mh 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mlg 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 +-mlg 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlg 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 +-mlg 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 +-mlg 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlg 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 +-mlg 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlg FFFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlg 8000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlgr FFFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 8000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-ml 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-ml 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 +-ml 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 +-ml 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 +-ml 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 +-ml 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-ml 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 +-ml 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-ml FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 +-ml 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mlr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mlr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 +-mlr 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 +-mlr 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 +-mlr 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlr 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 +-mlr 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mlr FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mlr 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 +-ms 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-ms 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-ms 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-ms 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-ms 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-ms 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-msr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-msr 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-msr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-msr 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-msr 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-msr 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-msr 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msg 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-msg 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-msg 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-msg 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-msg 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-msg 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-msg 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-msg 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-msgr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-msgr 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-msgr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-msgr 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-msgr 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-msgr 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-msgr 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-msgf 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-msgf 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-msgf 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-msgf 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-msgf 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-msgf 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-msgf 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-msgfr 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-msgfr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-msgfr 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-msgfr 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-msgfr 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-msgfr 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF +-msy 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-msy 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-msy 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-msy 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-msy 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-msy 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-m 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-m 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000000000000000007FFFFFFF +-m 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF000000007FFF0001 +-m 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF000000007FFF8001 +-m 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFF00000000FFFF8000 +-m 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 +-m 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000C00000000000000080000000 +-m 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF0000000000000001 +-m FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 +-m 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 +-mr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mr 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF +-mr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 +-mr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 +-mr 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 +-mr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000001 +-mr 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000080000000 +-mr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 +-mr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 +-mr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 +-mh 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mh 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000007FFF0000000000000001 +-mh 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFE8001000000000000FFFF +-mh 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000003FFF00010000000000007FFF +-mh 0000000000008000 * 7FFFFFFFFFFFFFFF = 000000003FFF80000000000000008000 +-mh 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFF800100000000FFFFFFFF +-mh 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-mh 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFF8001000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mlg 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000000000007FFFFFFFFFFFFFFF +-mlg 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF7FFFFFFFFFFF0001 +-mlg 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF7FFFFFFFFFFF8001 +-mlg 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFFFFFFFFFFFFFF8000 +-mlg 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 +-mlg 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000003FFFFFFFFFFFFFFF80000000 +-mlg 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 +-mlg FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE8000000000000001 +-mlg 8000000000000000 * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF8000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF0000000000000001 +-mlgr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000000000007FFFFFFFFFFFFFFF +-mlgr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF7FFFFFFFFFFF0001 +-mlgr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF7FFFFFFFFFFF8001 +-mlgr 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFFFFFFFFFFFFFF8000 +-mlgr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 +-mlgr 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000003FFFFFFFFFFFFFFF80000000 +-mlgr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 +-mlgr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE8000000000000001 +-mlgr 8000000000000000 * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF8000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF0000000000000001 +-ml 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-ml 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000000000000000007FFFFFFF +-ml 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF000000007FFF0001 +-ml 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF000000007FFF8001 +-ml 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFF00000000FFFF8000 +-ml 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFE0000000080000001 +-ml 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF0000000080000000 +-ml 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF0000000000000001 +-ml FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF7FFFFFFEFFFFFFFF80000001 +-ml 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF7FFFFFFE7FFFFFFF80000001 +-mlr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mlr 0000000000000001 * 7FFFFFFFFFFFFFFF = 000000000000000000000000FFFFFFFF +-mlr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000000000FFFE00000000FFFF0001 +-mlr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000007FFE00000000FFFF8001 +-mlr 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000007FFF00000000FFFF8000 +-mlr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFE0000000000000001 +-mlr 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF0000000080000000 +-mlr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFE0000000080000001 +-mlr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFEFFFFFFFF00000001 +-mlr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 +-ms 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-ms 0000000000000001 * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF0000000000000001 +-ms 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFF0001000000000000FFFF +-ms 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000007FFF80010000000000007FFF +-ms 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-ms 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000008000000100000000FFFFFFFF +-ms 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-ms 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 0000000000000001000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-msr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msr 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 +-msr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF +-msr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF +-msr 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-msr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF +-msr 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-msr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-msg 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msg 0000000000000001 * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF0000000000000001 +-msg 000000000000FFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF0001000000000000FFFF +-msg 0000000000007FFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80010000000000007FFF +-msg 0000000000008000 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-msg 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF0000000100000000FFFFFFFF +-msg 0000000080000000 * 7FFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 +-msg 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF80000001000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 8000000000000001FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000000000017FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msgr 0000000000000001 * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF0000000000000001 +-msgr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF0001000000000000FFFF +-msgr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80010000000000007FFF +-msgr 0000000000008000 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-msgr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF0000000100000000FFFFFFFF +-msgr 0000000080000000 * 7FFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 +-msgr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF80000001000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 8000000000000001FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000000000017FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msgf 0000000000000001 * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF0000000000000001 +-msgf 000000000000FFFF * 7FFFFFFFFFFFFFFF = 00007FFF7FFF0001000000000000FFFF +-msgf 0000000000007FFF * 7FFFFFFFFFFFFFFF = 00003FFF7FFF80010000000000007FFF +-msgf 0000000000008000 * 7FFFFFFFFFFFFFFF = 00003FFFFFFF80000000000000008000 +-msgf 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF +-msgf 0000000080000000 * 7FFFFFFFFFFFFFFF = 3FFFFFFF800000000000000080000000 +-msgf 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 3FFFFFFF00000001000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 +-msgfr 000000000000FFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF +-msgfr 0000000000007FFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF +-msgfr 0000000000008000 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-msgfr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF +-msgfr 0000000080000000 * 7FFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 +-msgfr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF +-msy 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msy 0000000000000001 * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF0000000000000001 +-msy 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFF0001000000000000FFFF +-msy 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000007FFF80010000000000007FFF +-msy 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-msy 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000008000000100000000FFFFFFFF +-msy 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-msy 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 0000000000000001000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-m 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-m 0000000000000001 * 8000000000000000 = 00000000FFFFFFFF0000000080000000 +-m 000000000000FFFF * 8000000000000000 = 00000000FFFF80000000000080000000 +-m 0000000000007FFF * 8000000000000000 = 00000000FFFFC0000000000080000000 +-m 0000000000008000 * 8000000000000000 = 00000000FFFFC0000000000000000000 +-m 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000080000000 +-m 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-m 000000007FFFFFFF * 8000000000000000 = 00000000C00000000000000080000000 +-m FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF80000000 +-m 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF80000000 +-mr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000000 +-mr 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000000 +-mr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000000 +-mr 0000000000008000 * 8000000000000000 = 00000000000000000000000000000000 +-mr 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000000 +-mr 0000000080000000 * 8000000000000000 = 00000000000000000000000000000000 +-mr 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000000 +-mr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mh 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mh 0000000000000001 * 8000000000000000 = 00000000FFFF80000000000000000001 +-mh 000000000000FFFF * 8000000000000000 = 0000000080008000000000000000FFFF +-mh 0000000000007FFF * 8000000000000000 = 00000000C00080000000000000007FFF +-mh 0000000000008000 * 8000000000000000 = 00000000C00000000000000000008000 +-mh 00000000FFFFFFFF * 8000000000000000 = 000000000000800000000000FFFFFFFF +-mh 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 8000000000000000 = 0000000000008000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mlg 0000000000000001 * 8000000000000000 = 00000000000000008000000000000000 +-mlg 000000000000FFFF * 8000000000000000 = 0000000000007FFF8000000000000000 +-mlg 0000000000007FFF * 8000000000000000 = 0000000000003FFF8000000000000000 +-mlg 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 +-mlg 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF8000000000000000 +-mlg 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-mlg 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF8000000000000000 +-mlg FFFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFFFFFFFFFF8000000000000000 +-mlg 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 8000000000000000 = 3FFFFFFFFFFFFFFF8000000000000000 +-mlgr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 8000000000000000 = 00000000000000008000000000000000 +-mlgr 000000000000FFFF * 8000000000000000 = 0000000000007FFF8000000000000000 +-mlgr 0000000000007FFF * 8000000000000000 = 0000000000003FFF8000000000000000 +-mlgr 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 +-mlgr 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF8000000000000000 +-mlgr 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-mlgr 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF8000000000000000 +-mlgr FFFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFFFFFFFFFF8000000000000000 +-mlgr 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 8000000000000000 = 3FFFFFFFFFFFFFFF8000000000000000 +-ml 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-ml 0000000000000001 * 8000000000000000 = 00000000000000000000000080000000 +-ml 000000000000FFFF * 8000000000000000 = 0000000000007FFF0000000080000000 +-ml 0000000000007FFF * 8000000000000000 = 0000000000003FFF0000000080000000 +-ml 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 +-ml 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF0000000080000000 +-ml 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-ml 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF0000000080000000 +-ml FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF7FFFFFFFFFFFFFFF80000000 +-ml 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF7FFFFFFF7FFFFFFF80000000 +-mlr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mlr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000000 +-mlr 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000000 +-mlr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000000 +-mlr 0000000000008000 * 8000000000000000 = 00000000000000000000000000000000 +-mlr 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000000 +-mlr 0000000080000000 * 8000000000000000 = 00000000000000000000000000000000 +-mlr 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000000 +-mlr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mlr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 +-ms 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-ms 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 +-ms 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF +-ms 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF +-ms 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF +-ms 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000001 +-msr 000000000000FFFF * 8000000000000000 = 0000000000000000000000000000FFFF +-msr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000007FFF +-msr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msr 00000000FFFFFFFF * 8000000000000000 = 000000000000000000000000FFFFFFFF +-msr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msr 000000007FFFFFFF * 8000000000000000 = 0000000000000000000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msg 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 +-msg 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF +-msg 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF +-msg 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msg 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF +-msg 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msg 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msgr 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 +-msgr 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF +-msgr 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF +-msgr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msgr 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF +-msgr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msgr 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msgf 0000000000000001 * 8000000000000000 = FFFFFFFF800000000000000000000001 +-msgf 000000000000FFFF * 8000000000000000 = FFFF800080000000000000000000FFFF +-msgf 0000000000007FFF * 8000000000000000 = FFFFC000800000000000000000007FFF +-msgf 0000000000008000 * 8000000000000000 = FFFFC000000000000000000000008000 +-msgf 00000000FFFFFFFF * 8000000000000000 = 800000008000000000000000FFFFFFFF +-msgf 0000000080000000 * 8000000000000000 = C0000000000000000000000080000000 +-msgf 000000007FFFFFFF * 8000000000000000 = C000000080000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000080000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000800000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000001 +-msgfr 000000000000FFFF * 8000000000000000 = 0000000000000000000000000000FFFF +-msgfr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000007FFF +-msgfr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msgfr 00000000FFFFFFFF * 8000000000000000 = 000000000000000000000000FFFFFFFF +-msgfr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msgfr 000000007FFFFFFF * 8000000000000000 = 0000000000000000000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000000000007FFFFFFFFFFFFFFF +-msy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msy 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 +-msy 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF +-msy 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF +-msy 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF +-msy 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF +-m 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-m 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF +-m 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 +-m 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 +-m 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 +-m 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000000000000000000001 +-m 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000080000000 +-m 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 +-m FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 +-m 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 +-mr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mr 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF +-mr 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 +-mr 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 +-mr 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 +-mr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000000000000000000001 +-mr 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000080000000 +-mr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 +-mr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 +-mr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 +-mh 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mh 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 +-mh 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF +-mh 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF +-mh 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-mh 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF +-mh 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-mh 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-mh 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-mlg 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mlg 0000000000000001 * FFFFFFFFFFFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF +-mlg 000000000000FFFF * FFFFFFFFFFFFFFFF = 000000000000FFFEFFFFFFFFFFFF0001 +-mlg 0000000000007FFF * FFFFFFFFFFFFFFFF = 0000000000007FFEFFFFFFFFFFFF8001 +-mlg 0000000000008000 * FFFFFFFFFFFFFFFF = 0000000000007FFFFFFFFFFFFFFF8000 +-mlg 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFEFFFFFFFF00000001 +-mlg 0000000080000000 * FFFFFFFFFFFFFFFF = 000000007FFFFFFFFFFFFFFF80000000 +-mlg 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 000000007FFFFFFEFFFFFFFF80000001 +-mlg FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFE0000000000000001 +-mlg 8000000000000000 * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF8000000000000000 +-mlg 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE8000000000000001 +-mlgr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mlgr 0000000000000001 * FFFFFFFFFFFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF +-mlgr 000000000000FFFF * FFFFFFFFFFFFFFFF = 000000000000FFFEFFFFFFFFFFFF0001 +-mlgr 0000000000007FFF * FFFFFFFFFFFFFFFF = 0000000000007FFEFFFFFFFFFFFF8001 +-mlgr 0000000000008000 * FFFFFFFFFFFFFFFF = 0000000000007FFFFFFFFFFFFFFF8000 +-mlgr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFEFFFFFFFF00000001 +-mlgr 0000000080000000 * FFFFFFFFFFFFFFFF = 000000007FFFFFFFFFFFFFFF80000000 +-mlgr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 000000007FFFFFFEFFFFFFFF80000001 +-mlgr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFE0000000000000001 +-mlgr 8000000000000000 * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF8000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE8000000000000001 +-ml 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-ml 0000000000000001 * FFFFFFFFFFFFFFFF = 000000000000000000000000FFFFFFFF +-ml 000000000000FFFF * FFFFFFFFFFFFFFFF = 000000000000FFFE00000000FFFF0001 +-ml 0000000000007FFF * FFFFFFFFFFFFFFFF = 0000000000007FFE00000000FFFF8001 +-ml 0000000000008000 * FFFFFFFFFFFFFFFF = 0000000000007FFF00000000FFFF8000 +-ml 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFE0000000000000001 +-ml 0000000080000000 * FFFFFFFFFFFFFFFF = 000000007FFFFFFF0000000080000000 +-ml 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 000000007FFFFFFE0000000080000001 +-ml FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFEFFFFFFFF00000001 +-ml 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 +-mlr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mlr 0000000000000001 * FFFFFFFFFFFFFFFF = 000000000000000000000000FFFFFFFF +-mlr 000000000000FFFF * FFFFFFFFFFFFFFFF = 000000000000FFFE00000000FFFF0001 +-mlr 0000000000007FFF * FFFFFFFFFFFFFFFF = 0000000000007FFE00000000FFFF8001 +-mlr 0000000000008000 * FFFFFFFFFFFFFFFF = 0000000000007FFF00000000FFFF8000 +-mlr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFE0000000000000001 +-mlr 0000000080000000 * FFFFFFFFFFFFFFFF = 000000007FFFFFFF0000000080000000 +-mlr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 000000007FFFFFFE0000000080000001 +-mlr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFEFFFFFFFF00000001 +-mlr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 +-ms 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-ms 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 +-ms 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF +-ms 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF +-ms 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-ms 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF +-ms 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-ms 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-ms 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-msr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msr 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 +-msr 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF +-msr 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF +-msr 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-msr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF +-msr 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-msr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-msr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-msg 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msg 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 +-msg 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF +-msg 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF +-msg 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-msg 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF +-msg 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 +-msg 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF +-msg 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF +-msgr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msgr 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 +-msgr 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF +-msgr 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF +-msgr 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-msgr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF +-msgr 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 +-msgr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF +-msgf 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msgf 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 +-msgf 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF +-msgf 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF +-msgf 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-msgf 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF +-msgf 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 +-msgf 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msgfr 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 +-msgfr 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF +-msgfr 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF +-msgfr 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-msgfr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF +-msgfr 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 +-msgfr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF +-msy 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-msy 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 +-msy 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF +-msy 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF +-msy 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-msy 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF +-msy 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-msy 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-msy 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-m 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-m 0000000000000001 * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF +-m 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF000000007FFF0001 +-m 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF000000007FFF8001 +-m 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFF00000000FFFF8000 +-m 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000FFFFFFFF0000000080000001 +-m 0000000080000000 * 7FFFFFFF00000000 = 00000000C00000000000000080000000 +-m 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000000000001 +-m FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFFFFFF80000001 +-m 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 +-mr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mr 000000000000FFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mr 0000000000007FFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mr 0000000000008000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mr 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mr 0000000080000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mr 000000007FFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mr 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mh 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mh 0000000000000001 * 7FFFFFFF00000000 = 0000000000007FFF0000000000000001 +-mh 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFE8001000000000000FFFF +-mh 0000000000007FFF * 7FFFFFFF00000000 = 000000003FFF00010000000000007FFF +-mh 0000000000008000 * 7FFFFFFF00000000 = 000000003FFF80000000000000008000 +-mh 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000FFFF800100000000FFFFFFFF +-mh 0000000080000000 * 7FFFFFFF00000000 = 00000000800000000000000080000000 +-mh 000000007FFFFFFF * 7FFFFFFF00000000 = 000000007FFF8001000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlg 0000000000000001 * 7FFFFFFF00000000 = 00000000000000007FFFFFFF00000000 +-mlg 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF7FFF000100000000 +-mlg 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF7FFF800100000000 +-mlg 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFFFFFF800000000000 +-mlg 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000007FFFFFFE8000000100000000 +-mlg 0000000080000000 * 7FFFFFFF00000000 = 000000003FFFFFFF8000000000000000 +-mlg 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000100000000 +-mlg FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFEFFFFFFFF8000000100000000 +-mlg 8000000000000000 * 7FFFFFFF00000000 = 3FFFFFFF800000000000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 3FFFFFFF7FFFFFFF8000000100000000 +-mlgr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000007FFFFFFF00000000 +-mlgr 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF7FFF000100000000 +-mlgr 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF7FFF800100000000 +-mlgr 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFFFFFF800000000000 +-mlgr 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000007FFFFFFE8000000100000000 +-mlgr 0000000080000000 * 7FFFFFFF00000000 = 000000003FFFFFFF8000000000000000 +-mlgr 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000100000000 +-mlgr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFEFFFFFFFF8000000100000000 +-mlgr 8000000000000000 * 7FFFFFFF00000000 = 3FFFFFFF800000000000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 3FFFFFFF7FFFFFFF8000000100000000 +-ml 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-ml 0000000000000001 * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF +-ml 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF000000007FFF0001 +-ml 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF000000007FFF8001 +-ml 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFF00000000FFFF8000 +-ml 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000007FFFFFFE0000000080000001 +-ml 0000000080000000 * 7FFFFFFF00000000 = 000000003FFFFFFF0000000080000000 +-ml 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000000000001 +-ml FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF7FFFFFFEFFFFFFFF80000001 +-ml 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF7FFFFFFE7FFFFFFF80000001 +-mlr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 000000000000FFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 0000000000007FFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 0000000000008000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 0000000080000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 000000007FFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mlr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mlr 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000000 +-ms 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-ms 0000000000000001 * 7FFFFFFF00000000 = 000000007FFFFFFF0000000000000001 +-ms 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFF0001000000000000FFFF +-ms 0000000000007FFF * 7FFFFFFF00000000 = 000000007FFF80010000000000007FFF +-ms 0000000000008000 * 7FFFFFFF00000000 = 00000000FFFF80000000000000008000 +-ms 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000008000000100000000FFFFFFFF +-ms 0000000080000000 * 7FFFFFFF00000000 = 00000000800000000000000080000000 +-ms 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000000000001000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-msr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-msr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000000000000000000001 +-msr 000000000000FFFF * 7FFFFFFF00000000 = 0000000000000000000000000000FFFF +-msr 0000000000007FFF * 7FFFFFFF00000000 = 00000000000000000000000000007FFF +-msr 0000000000008000 * 7FFFFFFF00000000 = 00000000000000000000000000008000 +-msr 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000000000000000000000FFFFFFFF +-msr 0000000080000000 * 7FFFFFFF00000000 = 00000000000000000000000080000000 +-msr 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msg 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-msg 0000000000000001 * 7FFFFFFF00000000 = 7FFFFFFF000000000000000000000001 +-msg 000000000000FFFF * 7FFFFFFF00000000 = 7FFF000100000000000000000000FFFF +-msg 0000000000007FFF * 7FFFFFFF00000000 = 7FFF8001000000000000000000007FFF +-msg 0000000000008000 * 7FFFFFFF00000000 = FFFF8000000000000000000000008000 +-msg 00000000FFFFFFFF * 7FFFFFFF00000000 = 800000010000000000000000FFFFFFFF +-msg 0000000080000000 * 7FFFFFFF00000000 = 80000000000000000000000080000000 +-msg 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000100000000000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 8000000100000000FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 7FFFFFFF00000000 = 00000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 80000001000000007FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-msgr 0000000000000001 * 7FFFFFFF00000000 = 7FFFFFFF000000000000000000000001 +-msgr 000000000000FFFF * 7FFFFFFF00000000 = 7FFF000100000000000000000000FFFF +-msgr 0000000000007FFF * 7FFFFFFF00000000 = 7FFF8001000000000000000000007FFF +-msgr 0000000000008000 * 7FFFFFFF00000000 = FFFF8000000000000000000000008000 +-msgr 00000000FFFFFFFF * 7FFFFFFF00000000 = 800000010000000000000000FFFFFFFF +-msgr 0000000080000000 * 7FFFFFFF00000000 = 80000000000000000000000080000000 +-msgr 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000100000000000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 8000000100000000FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 7FFFFFFF00000000 = 00000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 80000001000000007FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-msgf 0000000000000001 * 7FFFFFFF00000000 = 000000007FFFFFFF0000000000000001 +-msgf 000000000000FFFF * 7FFFFFFF00000000 = 00007FFF7FFF0001000000000000FFFF +-msgf 0000000000007FFF * 7FFFFFFF00000000 = 00003FFF7FFF80010000000000007FFF +-msgf 0000000000008000 * 7FFFFFFF00000000 = 00003FFFFFFF80000000000000008000 +-msgf 00000000FFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFE8000000100000000FFFFFFFF +-msgf 0000000080000000 * 7FFFFFFF00000000 = 3FFFFFFF800000000000000080000000 +-msgf 000000007FFFFFFF * 7FFFFFFF00000000 = 3FFFFFFF00000001000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000000000000000000001 +-msgfr 000000000000FFFF * 7FFFFFFF00000000 = 0000000000000000000000000000FFFF +-msgfr 0000000000007FFF * 7FFFFFFF00000000 = 00000000000000000000000000007FFF +-msgfr 0000000000008000 * 7FFFFFFF00000000 = 00000000000000000000000000008000 +-msgfr 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000000000000000000000FFFFFFFF +-msgfr 0000000080000000 * 7FFFFFFF00000000 = 00000000000000000000000080000000 +-msgfr 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 0000000000000000FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 7FFFFFFF00000000 = 00000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 00000000000000007FFFFFFFFFFFFFFF +-msy 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-msy 0000000000000001 * 7FFFFFFF00000000 = 000000007FFFFFFF0000000000000001 +-msy 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFF0001000000000000FFFF +-msy 0000000000007FFF * 7FFFFFFF00000000 = 000000007FFF80010000000000007FFF +-msy 0000000000008000 * 7FFFFFFF00000000 = 00000000FFFF80000000000000008000 +-msy 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000008000000100000000FFFFFFFF +-msy 0000000080000000 * 7FFFFFFF00000000 = 00000000800000000000000080000000 +-msy 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000000000001000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-m 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-m 0000000000000001 * 8000000000000000 = 00000000FFFFFFFF0000000080000000 +-m 000000000000FFFF * 8000000000000000 = 00000000FFFF80000000000080000000 +-m 0000000000007FFF * 8000000000000000 = 00000000FFFFC0000000000080000000 +-m 0000000000008000 * 8000000000000000 = 00000000FFFFC0000000000000000000 +-m 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000080000000 +-m 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-m 000000007FFFFFFF * 8000000000000000 = 00000000C00000000000000080000000 +-m FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF80000000 +-m 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF80000000 +-mr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000000 +-mr 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000000 +-mr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000000 +-mr 0000000000008000 * 8000000000000000 = 00000000000000000000000000000000 +-mr 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000000 +-mr 0000000080000000 * 8000000000000000 = 00000000000000000000000000000000 +-mr 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000000 +-mr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mh 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mh 0000000000000001 * 8000000000000000 = 00000000FFFF80000000000000000001 +-mh 000000000000FFFF * 8000000000000000 = 0000000080008000000000000000FFFF +-mh 0000000000007FFF * 8000000000000000 = 00000000C00080000000000000007FFF +-mh 0000000000008000 * 8000000000000000 = 00000000C00000000000000000008000 +-mh 00000000FFFFFFFF * 8000000000000000 = 000000000000800000000000FFFFFFFF +-mh 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 8000000000000000 = 0000000000008000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mlg 0000000000000001 * 8000000000000000 = 00000000000000008000000000000000 +-mlg 000000000000FFFF * 8000000000000000 = 0000000000007FFF8000000000000000 +-mlg 0000000000007FFF * 8000000000000000 = 0000000000003FFF8000000000000000 +-mlg 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 +-mlg 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF8000000000000000 +-mlg 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-mlg 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF8000000000000000 +-mlg FFFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFFFFFFFFFF8000000000000000 +-mlg 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 8000000000000000 = 3FFFFFFFFFFFFFFF8000000000000000 +-mlgr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 8000000000000000 = 00000000000000008000000000000000 +-mlgr 000000000000FFFF * 8000000000000000 = 0000000000007FFF8000000000000000 +-mlgr 0000000000007FFF * 8000000000000000 = 0000000000003FFF8000000000000000 +-mlgr 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 +-mlgr 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF8000000000000000 +-mlgr 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-mlgr 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF8000000000000000 +-mlgr FFFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFFFFFFFFFF8000000000000000 +-mlgr 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 8000000000000000 = 3FFFFFFFFFFFFFFF8000000000000000 +-ml 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-ml 0000000000000001 * 8000000000000000 = 00000000000000000000000080000000 +-ml 000000000000FFFF * 8000000000000000 = 0000000000007FFF0000000080000000 +-ml 0000000000007FFF * 8000000000000000 = 0000000000003FFF0000000080000000 +-ml 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 +-ml 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF0000000080000000 +-ml 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-ml 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF0000000080000000 +-ml FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF7FFFFFFFFFFFFFFF80000000 +-ml 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF7FFFFFFF7FFFFFFF80000000 +-mlr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mlr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000000 +-mlr 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000000 +-mlr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000000 +-mlr 0000000000008000 * 8000000000000000 = 00000000000000000000000000000000 +-mlr 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000000 +-mlr 0000000080000000 * 8000000000000000 = 00000000000000000000000000000000 +-mlr 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000000 +-mlr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mlr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 +-ms 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-ms 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 +-ms 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF +-ms 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF +-ms 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF +-ms 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000001 +-msr 000000000000FFFF * 8000000000000000 = 0000000000000000000000000000FFFF +-msr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000007FFF +-msr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msr 00000000FFFFFFFF * 8000000000000000 = 000000000000000000000000FFFFFFFF +-msr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msr 000000007FFFFFFF * 8000000000000000 = 0000000000000000000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msg 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 +-msg 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF +-msg 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF +-msg 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msg 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF +-msg 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msg 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msgr 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 +-msgr 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF +-msgr 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF +-msgr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msgr 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF +-msgr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msgr 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msgf 0000000000000001 * 8000000000000000 = FFFFFFFF800000000000000000000001 +-msgf 000000000000FFFF * 8000000000000000 = FFFF800080000000000000000000FFFF +-msgf 0000000000007FFF * 8000000000000000 = FFFFC000800000000000000000007FFF +-msgf 0000000000008000 * 8000000000000000 = FFFFC000000000000000000000008000 +-msgf 00000000FFFFFFFF * 8000000000000000 = 800000008000000000000000FFFFFFFF +-msgf 0000000080000000 * 8000000000000000 = C0000000000000000000000080000000 +-msgf 000000007FFFFFFF * 8000000000000000 = C000000080000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000080000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000800000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000001 +-msgfr 000000000000FFFF * 8000000000000000 = 0000000000000000000000000000FFFF +-msgfr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000007FFF +-msgfr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msgfr 00000000FFFFFFFF * 8000000000000000 = 000000000000000000000000FFFFFFFF +-msgfr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msgfr 000000007FFFFFFF * 8000000000000000 = 0000000000000000000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000000000007FFFFFFFFFFFFFFF +-msy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-msy 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 +-msy 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF +-msy 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF +-msy 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF +-msy 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF +-m 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-m 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFFFFFF +-m 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF0001 +-m 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF8001 +-m 0000000000008000 * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF8000 +-m 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000001 +-m 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000080000000 +-m 000000007FFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFF0000000080000001 +-m FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000001 +-m 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000001 +-mr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mr 0000000000000001 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mr 000000000000FFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mr 0000000000007FFF * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mr 0000000000008000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mr 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mr 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mr 000000007FFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mr 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mh 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mh 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF0000000000000001 +-mh 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFF0001000000000000FFFF +-mh 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFF80010000000000007FFF +-mh 0000000000008000 * FFFFFFFF00000000 = 00000000FFFF80000000000000008000 +-mh 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000100000000FFFFFFFF +-mh 0000000080000000 * FFFFFFFF00000000 = 00000000800000000000000080000000 +-mh 000000007FFFFFFF * FFFFFFFF00000000 = 0000000080000001000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-mh 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-mlg 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlg 0000000000000001 * FFFFFFFF00000000 = 0000000000000000FFFFFFFF00000000 +-mlg 000000000000FFFF * FFFFFFFF00000000 = 000000000000FFFEFFFF000100000000 +-mlg 0000000000007FFF * FFFFFFFF00000000 = 0000000000007FFEFFFF800100000000 +-mlg 0000000000008000 * FFFFFFFF00000000 = 0000000000007FFFFFFF800000000000 +-mlg 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFE0000000100000000 +-mlg 0000000080000000 * FFFFFFFF00000000 = 000000007FFFFFFF8000000000000000 +-mlg 000000007FFFFFFF * FFFFFFFF00000000 = 000000007FFFFFFE8000000100000000 +-mlg FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFEFFFFFFFF0000000100000000 +-mlg 8000000000000000 * FFFFFFFF00000000 = 7FFFFFFF800000000000000000000000 +-mlg 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF7FFFFFFF0000000100000000 +-mlgr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlgr 0000000000000001 * FFFFFFFF00000000 = 0000000000000000FFFFFFFF00000000 +-mlgr 000000000000FFFF * FFFFFFFF00000000 = 000000000000FFFEFFFF000100000000 +-mlgr 0000000000007FFF * FFFFFFFF00000000 = 0000000000007FFEFFFF800100000000 +-mlgr 0000000000008000 * FFFFFFFF00000000 = 0000000000007FFFFFFF800000000000 +-mlgr 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFE0000000100000000 +-mlgr 0000000080000000 * FFFFFFFF00000000 = 000000007FFFFFFF8000000000000000 +-mlgr 000000007FFFFFFF * FFFFFFFF00000000 = 000000007FFFFFFE8000000100000000 +-mlgr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFEFFFFFFFF0000000100000000 +-mlgr 8000000000000000 * FFFFFFFF00000000 = 7FFFFFFF800000000000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF7FFFFFFF0000000100000000 +-ml 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-ml 0000000000000001 * FFFFFFFF00000000 = 000000000000000000000000FFFFFFFF +-ml 000000000000FFFF * FFFFFFFF00000000 = 000000000000FFFE00000000FFFF0001 +-ml 0000000000007FFF * FFFFFFFF00000000 = 0000000000007FFE00000000FFFF8001 +-ml 0000000000008000 * FFFFFFFF00000000 = 0000000000007FFF00000000FFFF8000 +-ml 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFE0000000000000001 +-ml 0000000080000000 * FFFFFFFF00000000 = 000000007FFFFFFF0000000080000000 +-ml 000000007FFFFFFF * FFFFFFFF00000000 = 000000007FFFFFFE0000000080000001 +-ml FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFEFFFFFFFF00000001 +-ml 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 +-mlr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 0000000000000001 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 000000000000FFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 0000000000007FFF * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 0000000000008000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlr 000000007FFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mlr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mlr 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000000 +-ms 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-ms 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF0000000000000001 +-ms 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFF0001000000000000FFFF +-ms 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFF80010000000000007FFF +-ms 0000000000008000 * FFFFFFFF00000000 = 00000000FFFF80000000000000008000 +-ms 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000100000000FFFFFFFF +-ms 0000000080000000 * FFFFFFFF00000000 = 00000000800000000000000080000000 +-ms 000000007FFFFFFF * FFFFFFFF00000000 = 0000000080000001000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-ms 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-msr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-msr 0000000000000001 * FFFFFFFF00000000 = 00000000000000000000000000000001 +-msr 000000000000FFFF * FFFFFFFF00000000 = 0000000000000000000000000000FFFF +-msr 0000000000007FFF * FFFFFFFF00000000 = 00000000000000000000000000007FFF +-msr 0000000000008000 * FFFFFFFF00000000 = 00000000000000000000000000008000 +-msr 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000000000000FFFFFFFF +-msr 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000080000000 +-msr 000000007FFFFFFF * FFFFFFFF00000000 = 0000000000000000000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msr 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msg 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-msg 0000000000000001 * FFFFFFFF00000000 = FFFFFFFF000000000000000000000001 +-msg 000000000000FFFF * FFFFFFFF00000000 = FFFF000100000000000000000000FFFF +-msg 0000000000007FFF * FFFFFFFF00000000 = FFFF8001000000000000000000007FFF +-msg 0000000000008000 * FFFFFFFF00000000 = FFFF8000000000000000000000008000 +-msg 00000000FFFFFFFF * FFFFFFFF00000000 = 000000010000000000000000FFFFFFFF +-msg 0000000080000000 * FFFFFFFF00000000 = 80000000000000000000000080000000 +-msg 000000007FFFFFFF * FFFFFFFF00000000 = 8000000100000000000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000100000000FFFFFFFFFFFFFFFF +-msg 8000000000000000 * FFFFFFFF00000000 = 00000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000001000000007FFFFFFFFFFFFFFF +-msgr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-msgr 0000000000000001 * FFFFFFFF00000000 = FFFFFFFF000000000000000000000001 +-msgr 000000000000FFFF * FFFFFFFF00000000 = FFFF000100000000000000000000FFFF +-msgr 0000000000007FFF * FFFFFFFF00000000 = FFFF8001000000000000000000007FFF +-msgr 0000000000008000 * FFFFFFFF00000000 = FFFF8000000000000000000000008000 +-msgr 00000000FFFFFFFF * FFFFFFFF00000000 = 000000010000000000000000FFFFFFFF +-msgr 0000000080000000 * FFFFFFFF00000000 = 80000000000000000000000080000000 +-msgr 000000007FFFFFFF * FFFFFFFF00000000 = 8000000100000000000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000100000000FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * FFFFFFFF00000000 = 00000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000001000000007FFFFFFFFFFFFFFF +-msgf 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-msgf 0000000000000001 * FFFFFFFF00000000 = FFFFFFFFFFFFFFFF0000000000000001 +-msgf 000000000000FFFF * FFFFFFFF00000000 = FFFFFFFFFFFF0001000000000000FFFF +-msgf 0000000000007FFF * FFFFFFFF00000000 = FFFFFFFFFFFF80010000000000007FFF +-msgf 0000000000008000 * FFFFFFFF00000000 = FFFFFFFFFFFF80000000000000008000 +-msgf 00000000FFFFFFFF * FFFFFFFF00000000 = FFFFFFFF0000000100000000FFFFFFFF +-msgf 0000000080000000 * FFFFFFFF00000000 = FFFFFFFF800000000000000080000000 +-msgf 000000007FFFFFFF * FFFFFFFF00000000 = FFFFFFFF80000001000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000000000001FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 80000000000000017FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-msgfr 0000000000000001 * FFFFFFFF00000000 = 00000000000000000000000000000001 +-msgfr 000000000000FFFF * FFFFFFFF00000000 = 0000000000000000000000000000FFFF +-msgfr 0000000000007FFF * FFFFFFFF00000000 = 00000000000000000000000000007FFF +-msgfr 0000000000008000 * FFFFFFFF00000000 = 00000000000000000000000000008000 +-msgfr 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000000000000FFFFFFFF +-msgfr 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000080000000 +-msgfr 000000007FFFFFFF * FFFFFFFF00000000 = 0000000000000000000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000000000000FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * FFFFFFFF00000000 = 00000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000000000000007FFFFFFFFFFFFFFF +-msy 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-msy 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF0000000000000001 +-msy 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFF0001000000000000FFFF +-msy 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFF80010000000000007FFF +-msy 0000000000008000 * FFFFFFFF00000000 = 00000000FFFF80000000000000008000 +-msy 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000100000000FFFFFFFF +-msy 0000000080000000 * FFFFFFFF00000000 = 00000000800000000000000080000000 +-msy 000000007FFFFFFF * FFFFFFFF00000000 = 0000000080000001000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-msy 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-m 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-m 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000000 +-m 000000000000FFFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-m 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-m 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-m 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-m 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-m 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-m FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 +-m 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mr 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF +-mr 000000000000FFFF * 000000007FFFFFFF = 0000000000007FFF000000007FFF0001 +-mr 0000000000007FFF * 000000007FFFFFFF = 0000000000003FFF000000007FFF8001 +-mr 0000000000008000 * 000000007FFFFFFF = 0000000000003FFF00000000FFFF8000 +-mr 00000000FFFFFFFF * 000000007FFFFFFF = 00000000FFFFFFFF0000000080000001 +-mr 0000000080000000 * 000000007FFFFFFF = 00000000C00000000000000080000000 +-mr 000000007FFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF0000000000000001 +-mr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 +-mr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 +-mh 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mh 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 +-mh 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF +-mh 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF +-mh 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 +-mh 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF +-mh 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mlg 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF +-mlg 000000000000FFFF * 000000007FFFFFFF = 000000000000000000007FFF7FFF0001 +-mlg 0000000000007FFF * 000000007FFFFFFF = 000000000000000000003FFF7FFF8001 +-mlg 0000000000008000 * 000000007FFFFFFF = 000000000000000000003FFFFFFF8000 +-mlg 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000007FFFFFFE80000001 +-mlg 0000000080000000 * 000000007FFFFFFF = 00000000000000003FFFFFFF80000000 +-mlg 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000003FFFFFFF00000001 +-mlg FFFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000007FFFFFFEFFFFFFFF80000001 +-mlg 8000000000000000 * 000000007FFFFFFF = 000000003FFFFFFF8000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 +-mlgr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF +-mlgr 000000000000FFFF * 000000007FFFFFFF = 000000000000000000007FFF7FFF0001 +-mlgr 0000000000007FFF * 000000007FFFFFFF = 000000000000000000003FFF7FFF8001 +-mlgr 0000000000008000 * 000000007FFFFFFF = 000000000000000000003FFFFFFF8000 +-mlgr 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000007FFFFFFE80000001 +-mlgr 0000000080000000 * 000000007FFFFFFF = 00000000000000003FFFFFFF80000000 +-mlgr 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000003FFFFFFF00000001 +-mlgr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000007FFFFFFEFFFFFFFF80000001 +-mlgr 8000000000000000 * 000000007FFFFFFF = 000000003FFFFFFF8000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 +-ml 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-ml 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000000 +-ml 000000000000FFFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-ml 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-ml 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-ml 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-ml 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-ml 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-ml FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 +-ml 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mlr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mlr 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF +-mlr 000000000000FFFF * 000000007FFFFFFF = 0000000000007FFF000000007FFF0001 +-mlr 0000000000007FFF * 000000007FFFFFFF = 0000000000003FFF000000007FFF8001 +-mlr 0000000000008000 * 000000007FFFFFFF = 0000000000003FFF00000000FFFF8000 +-mlr 00000000FFFFFFFF * 000000007FFFFFFF = 000000007FFFFFFE0000000080000001 +-mlr 0000000080000000 * 000000007FFFFFFF = 000000003FFFFFFF0000000080000000 +-mlr 000000007FFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF0000000000000001 +-mlr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF7FFFFFFEFFFFFFFF80000001 +-mlr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF7FFFFFFE7FFFFFFF80000001 +-ms 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-ms 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 +-ms 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF +-ms 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF +-ms 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF +-ms 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-msr 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 +-msr 000000000000FFFF * 000000007FFFFFFF = 000000007FFF0001000000000000FFFF +-msr 0000000000007FFF * 000000007FFFFFFF = 000000007FFF80010000000000007FFF +-msr 0000000000008000 * 000000007FFFFFFF = 00000000FFFF80000000000000008000 +-msr 00000000FFFFFFFF * 000000007FFFFFFF = 000000008000000100000000FFFFFFFF +-msr 0000000080000000 * 000000007FFFFFFF = 00000000800000000000000080000000 +-msr 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000001000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-msg 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-msg 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 +-msg 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF0001000000000000FFFF +-msg 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000007FFF +-msg 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000008000 +-msg 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF +-msg 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000080000000 +-msg 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF00000001000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-msgr 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 +-msgr 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF0001000000000000FFFF +-msgr 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000007FFF +-msgr 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000008000 +-msgr 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF +-msgr 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000080000000 +-msgr 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF00000001000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-msgf 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 +-msgf 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF +-msgf 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF +-msgf 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 +-msgf 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF +-msgf 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 +-msgf 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 000000007FFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 000000007FFFFFFF = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 00000000000000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 +-msgfr 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF0001000000000000FFFF +-msgfr 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000007FFF +-msgfr 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000008000 +-msgfr 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF +-msgfr 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000080000000 +-msgfr 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF00000001000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-msy 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-msy 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 +-msy 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF +-msy 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF +-msy 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF +-msy 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-m 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-m 0000000000000001 * 0000000080000000 = 00000000000000000000000000000000 +-m 000000000000FFFF * 0000000080000000 = 00000000000000000000000000000000 +-m 0000000000007FFF * 0000000080000000 = 00000000000000000000000000000000 +-m 0000000000008000 * 0000000080000000 = 00000000000000000000000000000000 +-m 00000000FFFFFFFF * 0000000080000000 = 00000000000000000000000000000000 +-m 0000000080000000 * 0000000080000000 = 00000000000000000000000000000000 +-m 000000007FFFFFFF * 0000000080000000 = 00000000000000000000000000000000 +-m FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFF00000000 +-m 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-mr 0000000000000001 * 0000000080000000 = 00000000FFFFFFFF0000000080000000 +-mr 000000000000FFFF * 0000000080000000 = 00000000FFFF80000000000080000000 +-mr 0000000000007FFF * 0000000080000000 = 00000000FFFFC0000000000080000000 +-mr 0000000000008000 * 0000000080000000 = 00000000FFFFC0000000000000000000 +-mr 00000000FFFFFFFF * 0000000080000000 = 00000000000000000000000080000000 +-mr 0000000080000000 * 0000000080000000 = 00000000400000000000000000000000 +-mr 000000007FFFFFFF * 0000000080000000 = 00000000C00000000000000080000000 +-mr FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFF80000000 +-mr 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFF80000000 +-mh 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-mh 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 +-mh 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF +-mh 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF +-mh 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 +-mh 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF +-mh 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-mlg 0000000000000001 * 0000000080000000 = 00000000000000000000000080000000 +-mlg 000000000000FFFF * 0000000080000000 = 000000000000000000007FFF80000000 +-mlg 0000000000007FFF * 0000000080000000 = 000000000000000000003FFF80000000 +-mlg 0000000000008000 * 0000000080000000 = 00000000000000000000400000000000 +-mlg 00000000FFFFFFFF * 0000000080000000 = 00000000000000007FFFFFFF80000000 +-mlg 0000000080000000 * 0000000080000000 = 00000000000000004000000000000000 +-mlg 000000007FFFFFFF * 0000000080000000 = 00000000000000003FFFFFFF80000000 +-mlg FFFFFFFFFFFFFFFF * 0000000080000000 = 000000007FFFFFFFFFFFFFFF80000000 +-mlg 8000000000000000 * 0000000080000000 = 00000000400000000000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 0000000080000000 = 000000003FFFFFFFFFFFFFFF80000000 +-mlgr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 0000000080000000 = 00000000000000000000000080000000 +-mlgr 000000000000FFFF * 0000000080000000 = 000000000000000000007FFF80000000 +-mlgr 0000000000007FFF * 0000000080000000 = 000000000000000000003FFF80000000 +-mlgr 0000000000008000 * 0000000080000000 = 00000000000000000000400000000000 +-mlgr 00000000FFFFFFFF * 0000000080000000 = 00000000000000007FFFFFFF80000000 +-mlgr 0000000080000000 * 0000000080000000 = 00000000000000004000000000000000 +-mlgr 000000007FFFFFFF * 0000000080000000 = 00000000000000003FFFFFFF80000000 +-mlgr FFFFFFFFFFFFFFFF * 0000000080000000 = 000000007FFFFFFFFFFFFFFF80000000 +-mlgr 8000000000000000 * 0000000080000000 = 00000000400000000000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 0000000080000000 = 000000003FFFFFFFFFFFFFFF80000000 +-ml 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-ml 0000000000000001 * 0000000080000000 = 00000000000000000000000000000000 +-ml 000000000000FFFF * 0000000080000000 = 00000000000000000000000000000000 +-ml 0000000000007FFF * 0000000080000000 = 00000000000000000000000000000000 +-ml 0000000000008000 * 0000000080000000 = 00000000000000000000000000000000 +-ml 00000000FFFFFFFF * 0000000080000000 = 00000000000000000000000000000000 +-ml 0000000080000000 * 0000000080000000 = 00000000000000000000000000000000 +-ml 000000007FFFFFFF * 0000000080000000 = 00000000000000000000000000000000 +-ml FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFF00000000 +-ml 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mlr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-mlr 0000000000000001 * 0000000080000000 = 00000000000000000000000080000000 +-mlr 000000000000FFFF * 0000000080000000 = 0000000000007FFF0000000080000000 +-mlr 0000000000007FFF * 0000000080000000 = 0000000000003FFF0000000080000000 +-mlr 0000000000008000 * 0000000080000000 = 00000000000040000000000000000000 +-mlr 00000000FFFFFFFF * 0000000080000000 = 000000007FFFFFFF0000000080000000 +-mlr 0000000080000000 * 0000000080000000 = 00000000400000000000000000000000 +-mlr 000000007FFFFFFF * 0000000080000000 = 000000003FFFFFFF0000000080000000 +-mlr FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF7FFFFFFFFFFFFFFF80000000 +-mlr 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF7FFFFFFF7FFFFFFF80000000 +-ms 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-ms 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 +-ms 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF +-ms 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF +-ms 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF +-ms 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-msr 0000000000000001 * 0000000080000000 = 00000000800000000000000000000001 +-msr 000000000000FFFF * 0000000080000000 = 0000000080000000000000000000FFFF +-msr 0000000000007FFF * 0000000080000000 = 00000000800000000000000000007FFF +-msr 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 +-msr 00000000FFFFFFFF * 0000000080000000 = 000000008000000000000000FFFFFFFF +-msr 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 +-msr 000000007FFFFFFF * 0000000080000000 = 0000000080000000000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF +-msg 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-msg 0000000000000001 * 0000000080000000 = 00000000800000000000000000000001 +-msg 000000000000FFFF * 0000000080000000 = 00007FFF80000000000000000000FFFF +-msg 0000000000007FFF * 0000000080000000 = 00003FFF800000000000000000007FFF +-msg 0000000000008000 * 0000000080000000 = 00004000000000000000000000008000 +-msg 00000000FFFFFFFF * 0000000080000000 = 7FFFFFFF8000000000000000FFFFFFFF +-msg 0000000080000000 * 0000000080000000 = 40000000000000000000000080000000 +-msg 000000007FFFFFFF * 0000000080000000 = 3FFFFFFF80000000000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF800000007FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-msgr 0000000000000001 * 0000000080000000 = 00000000800000000000000000000001 +-msgr 000000000000FFFF * 0000000080000000 = 00007FFF80000000000000000000FFFF +-msgr 0000000000007FFF * 0000000080000000 = 00003FFF800000000000000000007FFF +-msgr 0000000000008000 * 0000000080000000 = 00004000000000000000000000008000 +-msgr 00000000FFFFFFFF * 0000000080000000 = 7FFFFFFF8000000000000000FFFFFFFF +-msgr 0000000080000000 * 0000000080000000 = 40000000000000000000000080000000 +-msgr 000000007FFFFFFF * 0000000080000000 = 3FFFFFFF80000000000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF800000007FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-msgf 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 +-msgf 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF +-msgf 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF +-msgf 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 +-msgf 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF +-msgf 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 +-msgf 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 0000000080000000 = 0000000000000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 0000000080000000 = 00000000000000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 0000000080000000 = FFFFFFFF800000000000000000000001 +-msgfr 000000000000FFFF * 0000000080000000 = FFFF800080000000000000000000FFFF +-msgfr 0000000000007FFF * 0000000080000000 = FFFFC000800000000000000000007FFF +-msgfr 0000000000008000 * 0000000080000000 = FFFFC000000000000000000000008000 +-msgfr 00000000FFFFFFFF * 0000000080000000 = 800000008000000000000000FFFFFFFF +-msgfr 0000000080000000 * 0000000080000000 = C0000000000000000000000080000000 +-msgfr 000000007FFFFFFF * 0000000080000000 = C000000080000000000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 0000000080000000 = 0000000080000000FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 0000000080000000 = 00000000800000007FFFFFFFFFFFFFFF +-msy 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-msy 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 +-msy 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF +-msy 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF +-msy 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF +-msy 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-m 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-m 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-m 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-m 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-m 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-m 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-m 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-m 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-m FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 +-m 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mr 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF +-mr 000000000000FFFF * 00000000FFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 +-mr 0000000000007FFF * 00000000FFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 +-mr 0000000000008000 * 00000000FFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 +-mr 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000001 +-mr 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 +-mr 000000007FFFFFFF * 00000000FFFFFFFF = 00000000FFFFFFFF0000000080000001 +-mr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 +-mr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 +-mh 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mh 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 +-mh 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF +-mh 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF +-mh 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 +-mh 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF +-mh 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mlg 0000000000000001 * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF +-mlg 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000FFFEFFFF0001 +-mlg 0000000000007FFF * 00000000FFFFFFFF = 000000000000000000007FFEFFFF8001 +-mlg 0000000000008000 * 00000000FFFFFFFF = 000000000000000000007FFFFFFF8000 +-mlg 00000000FFFFFFFF * 00000000FFFFFFFF = 0000000000000000FFFFFFFE00000001 +-mlg 0000000080000000 * 00000000FFFFFFFF = 00000000000000007FFFFFFF80000000 +-mlg 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000007FFFFFFE80000001 +-mlg FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = 00000000FFFFFFFEFFFFFFFF00000001 +-mlg 8000000000000000 * 00000000FFFFFFFF = 000000007FFFFFFF8000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 +-mlgr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF +-mlgr 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000FFFEFFFF0001 +-mlgr 0000000000007FFF * 00000000FFFFFFFF = 000000000000000000007FFEFFFF8001 +-mlgr 0000000000008000 * 00000000FFFFFFFF = 000000000000000000007FFFFFFF8000 +-mlgr 00000000FFFFFFFF * 00000000FFFFFFFF = 0000000000000000FFFFFFFE00000001 +-mlgr 0000000080000000 * 00000000FFFFFFFF = 00000000000000007FFFFFFF80000000 +-mlgr 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000007FFFFFFE80000001 +-mlgr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = 00000000FFFFFFFEFFFFFFFF00000001 +-mlgr 8000000000000000 * 00000000FFFFFFFF = 000000007FFFFFFF8000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 +-ml 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-ml 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-ml 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-ml 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-ml 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-ml 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-ml 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-ml 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-ml FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 +-ml 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mlr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mlr 0000000000000001 * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF +-mlr 000000000000FFFF * 00000000FFFFFFFF = 000000000000FFFE00000000FFFF0001 +-mlr 0000000000007FFF * 00000000FFFFFFFF = 0000000000007FFE00000000FFFF8001 +-mlr 0000000000008000 * 00000000FFFFFFFF = 0000000000007FFF00000000FFFF8000 +-mlr 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000FFFFFFFE0000000000000001 +-mlr 0000000080000000 * 00000000FFFFFFFF = 000000007FFFFFFF0000000080000000 +-mlr 000000007FFFFFFF * 00000000FFFFFFFF = 000000007FFFFFFE0000000080000001 +-mlr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFFFFFFFFFEFFFFFFFF00000001 +-mlr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 +-ms 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-ms 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 +-ms 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF +-ms 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF +-ms 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF +-ms 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-msr 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF0000000000000001 +-msr 000000000000FFFF * 00000000FFFFFFFF = 00000000FFFF0001000000000000FFFF +-msr 0000000000007FFF * 00000000FFFFFFFF = 00000000FFFF80010000000000007FFF +-msr 0000000000008000 * 00000000FFFFFFFF = 00000000FFFF80000000000000008000 +-msr 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000100000000FFFFFFFF +-msr 0000000080000000 * 00000000FFFFFFFF = 00000000800000000000000080000000 +-msr 000000007FFFFFFF * 00000000FFFFFFFF = 0000000080000001000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-msg 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-msg 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF0000000000000001 +-msg 000000000000FFFF * 00000000FFFFFFFF = 0000FFFEFFFF0001000000000000FFFF +-msg 0000000000007FFF * 00000000FFFFFFFF = 00007FFEFFFF80010000000000007FFF +-msg 0000000000008000 * 00000000FFFFFFFF = 00007FFFFFFF80000000000000008000 +-msg 00000000FFFFFFFF * 00000000FFFFFFFF = FFFFFFFE0000000100000000FFFFFFFF +-msg 0000000080000000 * 00000000FFFFFFFF = 7FFFFFFF800000000000000080000000 +-msg 000000007FFFFFFF * 00000000FFFFFFFF = 7FFFFFFE80000001000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-msgr 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF0000000000000001 +-msgr 000000000000FFFF * 00000000FFFFFFFF = 0000FFFEFFFF0001000000000000FFFF +-msgr 0000000000007FFF * 00000000FFFFFFFF = 00007FFEFFFF80010000000000007FFF +-msgr 0000000000008000 * 00000000FFFFFFFF = 00007FFFFFFF80000000000000008000 +-msgr 00000000FFFFFFFF * 00000000FFFFFFFF = FFFFFFFE0000000100000000FFFFFFFF +-msgr 0000000080000000 * 00000000FFFFFFFF = 7FFFFFFF800000000000000080000000 +-msgr 000000007FFFFFFF * 00000000FFFFFFFF = 7FFFFFFE80000001000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-msgf 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 +-msgf 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF +-msgf 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF +-msgf 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 +-msgf 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF +-msgf 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 +-msgf 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 00000000FFFFFFFF = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 00000000000000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 00000000FFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 +-msgfr 000000000000FFFF * 00000000FFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF +-msgfr 0000000000007FFF * 00000000FFFFFFFF = FFFFFFFFFFFF80010000000000007FFF +-msgfr 0000000000008000 * 00000000FFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-msgfr 00000000FFFFFFFF * 00000000FFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF +-msgfr 0000000080000000 * 00000000FFFFFFFF = FFFFFFFF800000000000000080000000 +-msgfr 000000007FFFFFFF * 00000000FFFFFFFF = FFFFFFFF80000001000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF +-msy 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-msy 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 +-msy 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF +-msy 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF +-msy 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF +-msy 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-m 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-m 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 +-m 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 +-m 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 +-m 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 +-m 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-m 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 +-m 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-m FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 +-m 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF +-mr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 +-mr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 +-mr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 +-mr 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFFFFFF00000000FFFF0001 +-mr 0000000080000000 * 000000000000FFFF = 00000000FFFF80000000000080000000 +-mr 000000007FFFFFFF * 000000000000FFFF = 0000000000007FFF000000007FFF0001 +-mr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 +-mr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFFFFFF7FFFFFFFFFFF0001 +-mh 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mh 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-mh 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-mh 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-mh 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-mh 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-mh 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mlg 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF +-mlg 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 +-mlg 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 +-mlg 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 +-mlg 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 +-mlg 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 +-mlg 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 +-mlg FFFFFFFFFFFFFFFF * 000000000000FFFF = 000000000000FFFEFFFFFFFFFFFF0001 +-mlg 8000000000000000 * 000000000000FFFF = 0000000000007FFF8000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 +-mlgr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF +-mlgr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 +-mlgr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 +-mlgr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 +-mlgr 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 +-mlgr 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 +-mlgr 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 +-mlgr FFFFFFFFFFFFFFFF * 000000000000FFFF = 000000000000FFFEFFFFFFFFFFFF0001 +-mlgr 8000000000000000 * 000000000000FFFF = 0000000000007FFF8000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 +-ml 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-ml 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 +-ml 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 +-ml 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 +-ml 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 +-ml 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-ml 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 +-ml 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-ml FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 +-ml 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mlr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mlr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF +-mlr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 +-mlr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 +-mlr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 +-mlr 00000000FFFFFFFF * 000000000000FFFF = 000000000000FFFE00000000FFFF0001 +-mlr 0000000080000000 * 000000000000FFFF = 0000000000007FFF0000000080000000 +-mlr 000000007FFFFFFF * 000000000000FFFF = 0000000000007FFF000000007FFF0001 +-mlr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF0000FFFEFFFFFFFFFFFF0001 +-mlr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF0000FFFE7FFFFFFFFFFF0001 +-ms 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-ms 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-ms 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-ms 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-ms 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-ms 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 +-msr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF +-msr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF +-msr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 +-msr 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFF000100000000FFFFFFFF +-msr 0000000080000000 * 000000000000FFFF = 00000000800000000000000080000000 +-msr 000000007FFFFFFF * 000000000000FFFF = 000000007FFF0001000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF +-msg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msg 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 +-msg 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF +-msg 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF +-msg 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 +-msg 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF +-msg 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 +-msg 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msgr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 +-msgr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF +-msgr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF +-msgr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 +-msgr 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF +-msgr 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 +-msgr 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msgf 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-msgf 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-msgf 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-msgf 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-msgf 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-msgf 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-msgf 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 000000000000FFFF = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 000000000000FFFF = 00000000000000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 +-msgfr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF +-msgfr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF +-msgfr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 +-msgfr 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF +-msgfr 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 +-msgfr 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF +-msy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-msy 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-msy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-msy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-msy 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-m 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-m 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000000 +-m 000000000000FFFF * 0000000000007FFF = 00000000000000000000000000000000 +-m 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000000000 +-m 0000000000008000 * 0000000000007FFF = 00000000000000000000000000000000 +-m 00000000FFFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 +-m 0000000080000000 * 0000000000007FFF = 00000000000000000000000000000000 +-m 000000007FFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 +-m FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFF00000000 +-m 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFF00000000 +-mr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mr 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF +-mr 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 +-mr 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 +-mr 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 +-mr 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFFFFFF00000000FFFF8001 +-mr 0000000080000000 * 0000000000007FFF = 00000000FFFFC0000000000080000000 +-mr 000000007FFFFFFF * 0000000000007FFF = 0000000000003FFF000000007FFF8001 +-mr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8001 +-mr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFFFFFF7FFFFFFFFFFF8001 +-mh 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mh 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 +-mh 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF +-mh 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF +-mh 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 +-mh 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF +-mh 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mlg 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF +-mlg 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 +-mlg 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 +-mlg 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 +-mlg 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000007FFEFFFF8001 +-mlg 0000000080000000 * 0000000000007FFF = 000000000000000000003FFF80000000 +-mlg 000000007FFFFFFF * 0000000000007FFF = 000000000000000000003FFF7FFF8001 +-mlg FFFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000007FFEFFFFFFFFFFFF8001 +-mlg 8000000000000000 * 0000000000007FFF = 0000000000003FFF8000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000003FFF7FFFFFFFFFFF8001 +-mlgr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF +-mlgr 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 +-mlgr 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 +-mlgr 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 +-mlgr 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000007FFEFFFF8001 +-mlgr 0000000080000000 * 0000000000007FFF = 000000000000000000003FFF80000000 +-mlgr 000000007FFFFFFF * 0000000000007FFF = 000000000000000000003FFF7FFF8001 +-mlgr FFFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000007FFEFFFFFFFFFFFF8001 +-mlgr 8000000000000000 * 0000000000007FFF = 0000000000003FFF8000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000003FFF7FFFFFFFFFFF8001 +-ml 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-ml 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000000 +-ml 000000000000FFFF * 0000000000007FFF = 00000000000000000000000000000000 +-ml 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000000000 +-ml 0000000000008000 * 0000000000007FFF = 00000000000000000000000000000000 +-ml 00000000FFFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 +-ml 0000000080000000 * 0000000000007FFF = 00000000000000000000000000000000 +-ml 000000007FFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 +-ml FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFF00000000 +-ml 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFF00000000 +-mlr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mlr 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF +-mlr 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 +-mlr 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 +-mlr 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 +-mlr 00000000FFFFFFFF * 0000000000007FFF = 0000000000007FFE00000000FFFF8001 +-mlr 0000000080000000 * 0000000000007FFF = 0000000000003FFF0000000080000000 +-mlr 000000007FFFFFFF * 0000000000007FFF = 0000000000003FFF000000007FFF8001 +-mlr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00007FFEFFFFFFFFFFFF8001 +-mlr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF00007FFE7FFFFFFFFFFF8001 +-ms 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-ms 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 +-ms 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF +-ms 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF +-ms 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF +-ms 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-msr 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-msr 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-msr 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-msr 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-msr 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF +-msr 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 +-msr 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-msg 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-msg 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-msg 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-msg 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-msg 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-msg 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF +-msg 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 +-msg 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-msgr 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-msgr 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-msgr 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-msgr 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-msgr 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF +-msgr 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 +-msgr 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-msgf 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 +-msgf 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF +-msgf 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF +-msgf 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 +-msgf 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF +-msgf 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 +-msgf 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 0000000000007FFF = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 0000000000007FFF = 00000000000000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-msgfr 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-msgfr 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-msgfr 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-msgfr 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF +-msgfr 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 +-msgfr 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-msy 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-msy 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 +-msy 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF +-msy 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF +-msy 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF +-msy 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-m 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-m 0000000000000001 * 0000000000008000 = 00000000000000000000000000000000 +-m 000000000000FFFF * 0000000000008000 = 00000000000000000000000000000000 +-m 0000000000007FFF * 0000000000008000 = 00000000000000000000000000000000 +-m 0000000000008000 * 0000000000008000 = 00000000000000000000000000000000 +-m 00000000FFFFFFFF * 0000000000008000 = 00000000000000000000000000000000 +-m 0000000080000000 * 0000000000008000 = 00000000000000000000000000000000 +-m 000000007FFFFFFF * 0000000000008000 = 00000000000000000000000000000000 +-m FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFF00000000 +-m 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFF00000000 +-mr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-mr 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 +-mr 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 +-mr 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 +-mr 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 +-mr 00000000FFFFFFFF * 0000000000008000 = 00000000FFFFFFFF00000000FFFF8000 +-mr 0000000080000000 * 0000000000008000 = 00000000FFFFC0000000000000000000 +-mr 000000007FFFFFFF * 0000000000008000 = 0000000000003FFF00000000FFFF8000 +-mr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8000 +-mr 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFFFFFFFFFF7FFFFFFFFFFF8000 +-mh 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-mh 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 +-mh 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF +-mh 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF +-mh 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 +-mh 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF +-mh 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-mlg 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 +-mlg 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 +-mlg 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 +-mlg 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 +-mlg 00000000FFFFFFFF * 0000000000008000 = 000000000000000000007FFFFFFF8000 +-mlg 0000000080000000 * 0000000000008000 = 00000000000000000000400000000000 +-mlg 000000007FFFFFFF * 0000000000008000 = 000000000000000000003FFFFFFF8000 +-mlg FFFFFFFFFFFFFFFF * 0000000000008000 = 0000000000007FFFFFFFFFFFFFFF8000 +-mlg 8000000000000000 * 0000000000008000 = 00000000000040000000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 0000000000008000 = 0000000000003FFFFFFFFFFFFFFF8000 +-mlgr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 +-mlgr 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 +-mlgr 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 +-mlgr 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 +-mlgr 00000000FFFFFFFF * 0000000000008000 = 000000000000000000007FFFFFFF8000 +-mlgr 0000000080000000 * 0000000000008000 = 00000000000000000000400000000000 +-mlgr 000000007FFFFFFF * 0000000000008000 = 000000000000000000003FFFFFFF8000 +-mlgr FFFFFFFFFFFFFFFF * 0000000000008000 = 0000000000007FFFFFFFFFFFFFFF8000 +-mlgr 8000000000000000 * 0000000000008000 = 00000000000040000000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 0000000000008000 = 0000000000003FFFFFFFFFFFFFFF8000 +-ml 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-ml 0000000000000001 * 0000000000008000 = 00000000000000000000000000000000 +-ml 000000000000FFFF * 0000000000008000 = 00000000000000000000000000000000 +-ml 0000000000007FFF * 0000000000008000 = 00000000000000000000000000000000 +-ml 0000000000008000 * 0000000000008000 = 00000000000000000000000000000000 +-ml 00000000FFFFFFFF * 0000000000008000 = 00000000000000000000000000000000 +-ml 0000000080000000 * 0000000000008000 = 00000000000000000000000000000000 +-ml 000000007FFFFFFF * 0000000000008000 = 00000000000000000000000000000000 +-ml FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFF00000000 +-ml 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFF00000000 +-mlr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-mlr 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 +-mlr 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 +-mlr 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 +-mlr 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 +-mlr 00000000FFFFFFFF * 0000000000008000 = 0000000000007FFF00000000FFFF8000 +-mlr 0000000080000000 * 0000000000008000 = 00000000000040000000000000000000 +-mlr 000000007FFFFFFF * 0000000000008000 = 0000000000003FFF00000000FFFF8000 +-mlr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00007FFFFFFFFFFFFFFF8000 +-mlr 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF00007FFF7FFFFFFFFFFF8000 +-ms 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-ms 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 +-ms 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF +-ms 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF +-ms 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF +-ms 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-msr 0000000000000001 * 0000000000008000 = 00000000000080000000000000000001 +-msr 000000000000FFFF * 0000000000008000 = 000000007FFF8000000000000000FFFF +-msr 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000007FFF +-msr 0000000000008000 * 0000000000008000 = 00000000400000000000000000008000 +-msr 00000000FFFFFFFF * 0000000000008000 = 00000000FFFF800000000000FFFFFFFF +-msr 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 +-msr 000000007FFFFFFF * 0000000000008000 = 00000000FFFF8000000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF8000FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFFFFFF80007FFFFFFFFFFFFFFF +-msg 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-msg 0000000000000001 * 0000000000008000 = 00000000000080000000000000000001 +-msg 000000000000FFFF * 0000000000008000 = 000000007FFF8000000000000000FFFF +-msg 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000007FFF +-msg 0000000000008000 * 0000000000008000 = 00000000400000000000000000008000 +-msg 00000000FFFFFFFF * 0000000000008000 = 00007FFFFFFF800000000000FFFFFFFF +-msg 0000000080000000 * 0000000000008000 = 00004000000000000000000080000000 +-msg 000000007FFFFFFF * 0000000000008000 = 00003FFFFFFF8000000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF8000FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80007FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-msgr 0000000000000001 * 0000000000008000 = 00000000000080000000000000000001 +-msgr 000000000000FFFF * 0000000000008000 = 000000007FFF8000000000000000FFFF +-msgr 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000007FFF +-msgr 0000000000008000 * 0000000000008000 = 00000000400000000000000000008000 +-msgr 00000000FFFFFFFF * 0000000000008000 = 00007FFFFFFF800000000000FFFFFFFF +-msgr 0000000080000000 * 0000000000008000 = 00004000000000000000000080000000 +-msgr 000000007FFFFFFF * 0000000000008000 = 00003FFFFFFF8000000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF8000FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80007FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-msgf 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 +-msgf 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF +-msgf 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF +-msgf 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 +-msgf 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF +-msgf 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 +-msgf 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 0000000000008000 = 0000000000000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 0000000000008000 = 00000000000000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 0000000000008000 = 00000000000080000000000000000001 +-msgfr 000000000000FFFF * 0000000000008000 = 000000007FFF8000000000000000FFFF +-msgfr 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000007FFF +-msgfr 0000000000008000 * 0000000000008000 = 00000000400000000000000000008000 +-msgfr 00000000FFFFFFFF * 0000000000008000 = 00007FFFFFFF800000000000FFFFFFFF +-msgfr 0000000080000000 * 0000000000008000 = 00004000000000000000000080000000 +-msgfr 000000007FFFFFFF * 0000000000008000 = 00003FFFFFFF8000000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF8000FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80007FFFFFFFFFFFFFFF +-msy 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-msy 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 +-msy 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF +-msy 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF +-msy 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF +-msy 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-m 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-m 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 +-m 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 +-m 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 +-m 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 +-m 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-m 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 +-m 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-m FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 +-m 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-m 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF +-mr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 +-mr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 +-mr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 +-mr 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFFFFFF00000000FFFF0001 +-mr 0000000080000000 * 000000000000FFFF = 00000000FFFF80000000000080000000 +-mr 000000007FFFFFFF * 000000000000FFFF = 0000000000007FFF000000007FFF0001 +-mr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 +-mr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFFFFFF7FFFFFFFFFFF0001 +-mh 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mh 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-mh 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-mh 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-mh 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-mh 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-mh 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-mh 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-mh FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mh 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mh 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mlg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mlg 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF +-mlg 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 +-mlg 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 +-mlg 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 +-mlg 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 +-mlg 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 +-mlg 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 +-mlg FFFFFFFFFFFFFFFF * 000000000000FFFF = 000000000000FFFEFFFFFFFFFFFF0001 +-mlg 8000000000000000 * 000000000000FFFF = 0000000000007FFF8000000000000000 +-mlg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 +-mlgr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mlgr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF +-mlgr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 +-mlgr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 +-mlgr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 +-mlgr 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 +-mlgr 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 +-mlgr 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 +-mlgr FFFFFFFFFFFFFFFF * 000000000000FFFF = 000000000000FFFEFFFFFFFFFFFF0001 +-mlgr 8000000000000000 * 000000000000FFFF = 0000000000007FFF8000000000000000 +-mlgr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 +-ml 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-ml 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 +-ml 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 +-ml 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 +-ml 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 +-ml 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-ml 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 +-ml 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-ml FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 +-ml 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-ml 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mlr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mlr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF +-mlr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 +-mlr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 +-mlr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 +-mlr 00000000FFFFFFFF * 000000000000FFFF = 000000000000FFFE00000000FFFF0001 +-mlr 0000000080000000 * 000000000000FFFF = 0000000000007FFF0000000080000000 +-mlr 000000007FFFFFFF * 000000000000FFFF = 0000000000007FFF000000007FFF0001 +-mlr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF0000FFFEFFFFFFFFFFFF0001 +-mlr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mlr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF0000FFFE7FFFFFFFFFFF0001 +-ms 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-ms 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-ms 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-ms 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-ms 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-ms 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-ms 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-ms 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-ms FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-ms 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-ms 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-msr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 +-msr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF +-msr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF +-msr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 +-msr 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFF000100000000FFFFFFFF +-msr 0000000080000000 * 000000000000FFFF = 00000000800000000000000080000000 +-msr 000000007FFFFFFF * 000000000000FFFF = 000000007FFF0001000000007FFFFFFF +-msr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF +-msr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF +-msg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msg 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 +-msg 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF +-msg 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF +-msg 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 +-msg 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF +-msg 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 +-msg 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF +-msg FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF +-msg 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF +-msgr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msgr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 +-msgr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF +-msgr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF +-msgr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 +-msgr 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF +-msgr 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 +-msgr 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF +-msgr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF +-msgr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msgr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF +-msgf 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msgf 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-msgf 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-msgf 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-msgf 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-msgf 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-msgf 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-msgf 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-msgf FFFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000000000FFFFFFFFFFFFFFFF +-msgf 8000000000000000 * 000000000000FFFF = 00000000000000008000000000000000 +-msgf 7FFFFFFFFFFFFFFF * 000000000000FFFF = 00000000000000007FFFFFFFFFFFFFFF +-msgfr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msgfr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 +-msgfr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF +-msgfr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF +-msgfr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 +-msgfr 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF +-msgfr 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 +-msgfr 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF +-msgfr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF +-msgfr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msgfr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF +-msy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-msy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-msy 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-msy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-msy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-msy 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-msy 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-msy 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-msy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-msy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-msy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mhi 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mhi 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-mhi 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-mhi 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-mhi 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-mhi 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-mhi 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-mhi 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-mhi FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mhi 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-mhi 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mhi 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mhi 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 +-mhi 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF +-mhi 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF +-mhi 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-mhi 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF +-mhi 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-mhi 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF +-mhi FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-mhi 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mhi 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-mhi 0000000000000000 * FFFFFFFFFFFF8000 = 00000000000000000000000000000000 +-mhi 0000000000000001 * FFFFFFFFFFFF8000 = 00000000FFFF80000000000000000001 +-mhi 000000000000FFFF * FFFFFFFFFFFF8000 = 0000000080008000000000000000FFFF +-mhi 0000000000007FFF * FFFFFFFFFFFF8000 = 00000000C00080000000000000007FFF +-mhi 0000000000008000 * FFFFFFFFFFFF8000 = 00000000C00000000000000000008000 +-mhi 00000000FFFFFFFF * FFFFFFFFFFFF8000 = 000000000000800000000000FFFFFFFF +-mhi 0000000080000000 * FFFFFFFFFFFF8000 = 00000000000000000000000080000000 +-mhi 000000007FFFFFFF * FFFFFFFFFFFF8000 = 0000000000008000000000007FFFFFFF +-mhi FFFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF +-mhi 8000000000000000 * FFFFFFFFFFFF8000 = 80000000000000008000000000000000 +-mhi 7FFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF +-mhi 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mhi 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-mhi 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-mhi 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-mhi 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-mhi 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF +-mhi 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 +-mhi 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF +-mhi FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-mhi 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-mhi 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-mghi 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mghi 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-mghi 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-mghi 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-mghi 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-mghi 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-mghi 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-mghi 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-mghi FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF +-mghi 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 +-mghi 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF +-mghi 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mghi 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 +-mghi 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF +-mghi 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF +-mghi 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-mghi 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF +-mghi 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 +-mghi 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF +-mghi FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF +-mghi 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mghi 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF +-mghi 0000000000000000 * FFFFFFFFFFFF8000 = 00000000000000000000000000000000 +-mghi 0000000000000001 * FFFFFFFFFFFF8000 = FFFFFFFFFFFF80000000000000000001 +-mghi 000000000000FFFF * FFFFFFFFFFFF8000 = FFFFFFFF80008000000000000000FFFF +-mghi 0000000000007FFF * FFFFFFFFFFFF8000 = FFFFFFFFC00080000000000000007FFF +-mghi 0000000000008000 * FFFFFFFFFFFF8000 = FFFFFFFFC00000000000000000008000 +-mghi 00000000FFFFFFFF * FFFFFFFFFFFF8000 = FFFF80000000800000000000FFFFFFFF +-mghi 0000000080000000 * FFFFFFFFFFFF8000 = FFFFC000000000000000000080000000 +-mghi 000000007FFFFFFF * FFFFFFFFFFFF8000 = FFFFC00000008000000000007FFFFFFF +-mghi FFFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 0000000000008000FFFFFFFFFFFFFFFF +-mghi 8000000000000000 * FFFFFFFFFFFF8000 = 00000000000000008000000000000000 +-mghi 7FFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 00000000000080007FFFFFFFFFFFFFFF +-mghi 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mghi 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-mghi 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-mghi 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-mghi 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-mghi 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF +-mghi 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 +-mghi 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF +-mghi FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-mghi 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-mghi 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF ++m 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++m 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++m 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mr 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mh 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++mh 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++mh 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 8000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 8000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++ml 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mlr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mlr 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++ms 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++ms 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++ms 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++msr 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msr 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++msg 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msg 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msg 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++msgr 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msgr 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++msgfr 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msgfr 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++msy 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msy 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++m 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF000000007FFF0001 (cc=0) ++m 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF000000007FFF8001 (cc=0) ++m 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFF00000000FFFF8000 (cc=0) ++m 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 (cc=0) ++m 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000C00000000000000080000000 (cc=0) ++m 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF0000000000000001 (cc=0) ++m FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 (cc=0) ++m 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 (cc=0) ++mr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF (cc=0) ++mr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 (cc=0) ++mr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 (cc=0) ++mr 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 (cc=0) ++mr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000001 (cc=0) ++mr 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000080000000 (cc=0) ++mr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 (cc=0) ++mr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 (cc=0) ++mr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 (cc=0) ++mh 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000007FFF0000000000000001 (cc=0) ++mh 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFE8001000000000000FFFF (cc=0) ++mh 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000003FFF00010000000000007FFF (cc=0) ++mh 0000000000008000 * 7FFFFFFFFFFFFFFF = 000000003FFF80000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFF800100000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFF8001000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mlg 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++mlg 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF7FFFFFFFFFFF8001 (cc=0) ++mlg 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFFFFFFFFFFFFFF8000 (cc=0) ++mlg 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 (cc=0) ++mlg 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000003FFFFFFFFFFFFFFF80000000 (cc=0) ++mlg 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE8000000000000001 (cc=0) ++mlg 8000000000000000 * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF0000000000000001 (cc=0) ++mlgr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mlgr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++mlgr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF7FFFFFFFFFFF8001 (cc=0) ++mlgr 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFFFFFFFFFFFFFF8000 (cc=0) ++mlgr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 (cc=0) ++mlgr 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000003FFFFFFFFFFFFFFF80000000 (cc=0) ++mlgr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE8000000000000001 (cc=0) ++mlgr 8000000000000000 * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 3FFFFFFFFFFFFFFF0000000000000001 (cc=0) ++ml 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++ml 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF000000007FFF0001 (cc=0) ++ml 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF000000007FFF8001 (cc=0) ++ml 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFF00000000FFFF8000 (cc=0) ++ml 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFE0000000080000001 (cc=0) ++ml 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF0000000080000000 (cc=0) ++ml 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF0000000000000001 (cc=0) ++ml FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF7FFFFFFEFFFFFFFF80000001 (cc=0) ++ml 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF7FFFFFFE7FFFFFFF80000001 (cc=0) ++mlr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 7FFFFFFFFFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mlr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000000000FFFE00000000FFFF0001 (cc=0) ++mlr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000007FFE00000000FFFF8001 (cc=0) ++mlr 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000007FFF00000000FFFF8000 (cc=0) ++mlr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFE0000000000000001 (cc=0) ++mlr 0000000080000000 * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF0000000080000000 (cc=0) ++mlr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFFFFFE0000000080000001 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFEFFFFFFFF00000001 (cc=0) ++mlr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 (cc=0) ++ms 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF0000000000000001 (cc=0) ++ms 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFF0001000000000000FFFF (cc=0) ++ms 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000007FFF80010000000000007FFF (cc=0) ++ms 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000008000000100000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 0000000000000001000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++msr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=0) ++msr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF (cc=0) ++msr 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msg 000000000000FFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF0001000000000000FFFF (cc=0) ++msg 0000000000007FFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80010000000000007FFF (cc=0) ++msg 0000000000008000 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF0000000100000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 7FFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF80000001000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 8000000000000001FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000000000017FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msgr 000000000000FFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF0001000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80010000000000007FFF (cc=0) ++msgr 0000000000008000 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF0000000100000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 7FFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF80000001000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 8000000000000001FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000000000017FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF0000000000000001 (cc=0) ++msgf 000000000000FFFF * 7FFFFFFFFFFFFFFF = 00007FFF7FFF0001000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 7FFFFFFFFFFFFFFF = 00003FFF7FFF80010000000000007FFF (cc=0) ++msgf 0000000000008000 * 7FFFFFFFFFFFFFFF = 00003FFFFFFF80000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 7FFFFFFFFFFFFFFF = 3FFFFFFF800000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 3FFFFFFF00000001000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msgfr 000000000000FFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++msgfr 0000000000008000 * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 7FFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 7FFFFFFFFFFFFFFF = 000000007FFFFFFF0000000000000001 (cc=0) ++msy 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFF0001000000000000FFFF (cc=0) ++msy 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000007FFF80010000000000007FFF (cc=0) ++msy 0000000000008000 * 7FFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 000000008000000100000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 0000000000000001000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 8000000000000000 = 00000000FFFFFFFF0000000080000000 (cc=0) ++m 000000000000FFFF * 8000000000000000 = 00000000FFFF80000000000080000000 (cc=0) ++m 0000000000007FFF * 8000000000000000 = 00000000FFFFC0000000000080000000 (cc=0) ++m 0000000000008000 * 8000000000000000 = 00000000FFFFC0000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++m 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 8000000000000000 = 00000000C00000000000000080000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF80000000 (cc=0) ++m 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF80000000 (cc=0) ++mr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000008000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000080000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mh 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 8000000000000000 = 00000000FFFF80000000000000000001 (cc=0) ++mh 000000000000FFFF * 8000000000000000 = 0000000080008000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 8000000000000000 = 00000000C00080000000000000007FFF (cc=0) ++mh 0000000000008000 * 8000000000000000 = 00000000C00000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 8000000000000000 = 000000000000800000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 8000000000000000 = 0000000000008000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mlg 000000000000FFFF * 8000000000000000 = 0000000000007FFF8000000000000000 (cc=0) ++mlg 0000000000007FFF * 8000000000000000 = 0000000000003FFF8000000000000000 (cc=0) ++mlg 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 (cc=0) ++mlg 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF8000000000000000 (cc=0) ++mlg 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++mlg 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF8000000000000000 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlg 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 8000000000000000 = 3FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlgr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mlgr 000000000000FFFF * 8000000000000000 = 0000000000007FFF8000000000000000 (cc=0) ++mlgr 0000000000007FFF * 8000000000000000 = 0000000000003FFF8000000000000000 (cc=0) ++mlgr 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 (cc=0) ++mlgr 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF8000000000000000 (cc=0) ++mlgr 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++mlgr 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF8000000000000000 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlgr 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 8000000000000000 = 3FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++ml 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++ml 000000000000FFFF * 8000000000000000 = 0000000000007FFF0000000080000000 (cc=0) ++ml 0000000000007FFF * 8000000000000000 = 0000000000003FFF0000000080000000 (cc=0) ++ml 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF0000000080000000 (cc=0) ++ml 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF0000000080000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF7FFFFFFFFFFFFFFF80000000 (cc=0) ++ml 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF7FFFFFFF7FFFFFFF80000000 (cc=0) ++mlr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000008000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000080000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mlr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++ms 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 (cc=0) ++ms 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF (cc=0) ++ms 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000001 (cc=0) ++msr 000000000000FFFF * 8000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 8000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 8000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 (cc=0) ++msg 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF (cc=0) ++msg 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF (cc=0) ++msg 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 (cc=0) ++msgr 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF (cc=0) ++msgr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 8000000000000000 = FFFFFFFF800000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 8000000000000000 = FFFF800080000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 8000000000000000 = FFFFC000800000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 8000000000000000 = FFFFC000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 8000000000000000 = 800000008000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 8000000000000000 = C0000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 8000000000000000 = C000000080000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000080000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000800000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000001 (cc=0) ++msgfr 000000000000FFFF * 8000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msgfr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 8000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 8000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 (cc=0) ++msy 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF (cc=0) ++msy 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF (cc=0) ++m 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 (cc=0) ++m 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 (cc=0) ++m 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 (cc=0) ++m 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000000000000000000001 (cc=0) ++m 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000080000000 (cc=0) ++m 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 (cc=0) ++m FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 (cc=0) ++m 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 (cc=0) ++mr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF (cc=0) ++mr 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 (cc=0) ++mr 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 (cc=0) ++mr 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 (cc=0) ++mr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000000000000000000001 (cc=0) ++mr 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000080000000 (cc=0) ++mr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 (cc=0) ++mr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 (cc=0) ++mr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 (cc=0) ++mh 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++mh 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=0) ++mh 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF (cc=0) ++mh 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF (cc=0) ++mh 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * FFFFFFFFFFFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mlg 000000000000FFFF * FFFFFFFFFFFFFFFF = 000000000000FFFEFFFFFFFFFFFF0001 (cc=0) ++mlg 0000000000007FFF * FFFFFFFFFFFFFFFF = 0000000000007FFEFFFFFFFFFFFF8001 (cc=0) ++mlg 0000000000008000 * FFFFFFFFFFFFFFFF = 0000000000007FFFFFFFFFFFFFFF8000 (cc=0) ++mlg 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFEFFFFFFFF00000001 (cc=0) ++mlg 0000000080000000 * FFFFFFFFFFFFFFFF = 000000007FFFFFFFFFFFFFFF80000000 (cc=0) ++mlg 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 000000007FFFFFFEFFFFFFFF80000001 (cc=0) ++mlg FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFE0000000000000001 (cc=0) ++mlg 8000000000000000 * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE8000000000000001 (cc=0) ++mlgr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * FFFFFFFFFFFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mlgr 000000000000FFFF * FFFFFFFFFFFFFFFF = 000000000000FFFEFFFFFFFFFFFF0001 (cc=0) ++mlgr 0000000000007FFF * FFFFFFFFFFFFFFFF = 0000000000007FFEFFFFFFFFFFFF8001 (cc=0) ++mlgr 0000000000008000 * FFFFFFFFFFFFFFFF = 0000000000007FFFFFFFFFFFFFFF8000 (cc=0) ++mlgr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFEFFFFFFFF00000001 (cc=0) ++mlgr 0000000080000000 * FFFFFFFFFFFFFFFF = 000000007FFFFFFFFFFFFFFF80000000 (cc=0) ++mlgr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 000000007FFFFFFEFFFFFFFF80000001 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFE0000000000000001 (cc=0) ++mlgr 8000000000000000 * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE8000000000000001 (cc=0) ++ml 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * FFFFFFFFFFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++ml 000000000000FFFF * FFFFFFFFFFFFFFFF = 000000000000FFFE00000000FFFF0001 (cc=0) ++ml 0000000000007FFF * FFFFFFFFFFFFFFFF = 0000000000007FFE00000000FFFF8001 (cc=0) ++ml 0000000000008000 * FFFFFFFFFFFFFFFF = 0000000000007FFF00000000FFFF8000 (cc=0) ++ml 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFE0000000000000001 (cc=0) ++ml 0000000080000000 * FFFFFFFFFFFFFFFF = 000000007FFFFFFF0000000080000000 (cc=0) ++ml 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 000000007FFFFFFE0000000080000001 (cc=0) ++ml FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFEFFFFFFFF00000001 (cc=0) ++ml 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 (cc=0) ++mlr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * FFFFFFFFFFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mlr 000000000000FFFF * FFFFFFFFFFFFFFFF = 000000000000FFFE00000000FFFF0001 (cc=0) ++mlr 0000000000007FFF * FFFFFFFFFFFFFFFF = 0000000000007FFE00000000FFFF8001 (cc=0) ++mlr 0000000000008000 * FFFFFFFFFFFFFFFF = 0000000000007FFF00000000FFFF8000 (cc=0) ++mlr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFE0000000000000001 (cc=0) ++mlr 0000000080000000 * FFFFFFFFFFFFFFFF = 000000007FFFFFFF0000000080000000 (cc=0) ++mlr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 000000007FFFFFFE0000000080000001 (cc=0) ++mlr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFEFFFFFFFF00000001 (cc=0) ++mlr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 (cc=0) ++ms 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++ms 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=0) ++ms 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF (cc=0) ++ms 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF (cc=0) ++ms 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++msr 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=0) ++msr 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF (cc=0) ++msr 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF (cc=0) ++msr 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msg 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++msg 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++msg 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++msg 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msgr 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++msgr 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++msgr 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msgf 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++msgf 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++msgf 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msgfr 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++msgfr 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++msy 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=0) ++msy 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF (cc=0) ++msy 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF (cc=0) ++msy 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF (cc=0) ++m 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF000000007FFF0001 (cc=0) ++m 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF000000007FFF8001 (cc=0) ++m 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFF00000000FFFF8000 (cc=0) ++m 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000FFFFFFFF0000000080000001 (cc=0) ++m 0000000080000000 * 7FFFFFFF00000000 = 00000000C00000000000000080000000 (cc=0) ++m 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000000000001 (cc=0) ++m FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFFFFFF80000001 (cc=0) ++m 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 (cc=0) ++mr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000000000FFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000007FFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000008000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000080000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000007FFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mr 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mh 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 7FFFFFFF00000000 = 0000000000007FFF0000000000000001 (cc=0) ++mh 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFE8001000000000000FFFF (cc=0) ++mh 0000000000007FFF * 7FFFFFFF00000000 = 000000003FFF00010000000000007FFF (cc=0) ++mh 0000000000008000 * 7FFFFFFF00000000 = 000000003FFF80000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000FFFF800100000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 7FFFFFFF00000000 = 00000000800000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 7FFFFFFF00000000 = 000000007FFF8001000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 7FFFFFFF00000000 = 00000000000000007FFFFFFF00000000 (cc=0) ++mlg 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF7FFF000100000000 (cc=0) ++mlg 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF7FFF800100000000 (cc=0) ++mlg 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFFFFFF800000000000 (cc=0) ++mlg 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000007FFFFFFE8000000100000000 (cc=0) ++mlg 0000000080000000 * 7FFFFFFF00000000 = 000000003FFFFFFF8000000000000000 (cc=0) ++mlg 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000100000000 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFEFFFFFFFF8000000100000000 (cc=0) ++mlg 8000000000000000 * 7FFFFFFF00000000 = 3FFFFFFF800000000000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 3FFFFFFF7FFFFFFF8000000100000000 (cc=0) ++mlgr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000007FFFFFFF00000000 (cc=0) ++mlgr 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF7FFF000100000000 (cc=0) ++mlgr 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF7FFF800100000000 (cc=0) ++mlgr 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFFFFFF800000000000 (cc=0) ++mlgr 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000007FFFFFFE8000000100000000 (cc=0) ++mlgr 0000000080000000 * 7FFFFFFF00000000 = 000000003FFFFFFF8000000000000000 (cc=0) ++mlgr 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000100000000 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFEFFFFFFFF8000000100000000 (cc=0) ++mlgr 8000000000000000 * 7FFFFFFF00000000 = 3FFFFFFF800000000000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 3FFFFFFF7FFFFFFF8000000100000000 (cc=0) ++ml 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF (cc=0) ++ml 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF000000007FFF0001 (cc=0) ++ml 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF000000007FFF8001 (cc=0) ++ml 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFF00000000FFFF8000 (cc=0) ++ml 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000007FFFFFFE0000000080000001 (cc=0) ++ml 0000000080000000 * 7FFFFFFF00000000 = 000000003FFFFFFF0000000080000000 (cc=0) ++ml 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000000000001 (cc=0) ++ml FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF7FFFFFFEFFFFFFFF80000001 (cc=0) ++ml 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF7FFFFFFE7FFFFFFF80000001 (cc=0) ++mlr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000000000FFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000007FFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000008000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000080000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000007FFFFFFF * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mlr 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++ms 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 7FFFFFFF00000000 = 000000007FFFFFFF0000000000000001 (cc=0) ++ms 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFF0001000000000000FFFF (cc=0) ++ms 0000000000007FFF * 7FFFFFFF00000000 = 000000007FFF80010000000000007FFF (cc=0) ++ms 0000000000008000 * 7FFFFFFF00000000 = 00000000FFFF80000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000008000000100000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 7FFFFFFF00000000 = 00000000800000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000000000001000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000000000000000000001 (cc=0) ++msr 000000000000FFFF * 7FFFFFFF00000000 = 0000000000000000000000000000FFFF (cc=0) ++msr 0000000000007FFF * 7FFFFFFF00000000 = 00000000000000000000000000007FFF (cc=0) ++msr 0000000000008000 * 7FFFFFFF00000000 = 00000000000000000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 7FFFFFFF00000000 = 00000000000000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 7FFFFFFF00000000 = 7FFFFFFF000000000000000000000001 (cc=0) ++msg 000000000000FFFF * 7FFFFFFF00000000 = 7FFF000100000000000000000000FFFF (cc=0) ++msg 0000000000007FFF * 7FFFFFFF00000000 = 7FFF8001000000000000000000007FFF (cc=0) ++msg 0000000000008000 * 7FFFFFFF00000000 = FFFF8000000000000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 7FFFFFFF00000000 = 800000010000000000000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 7FFFFFFF00000000 = 80000000000000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000100000000000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 8000000100000000FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 7FFFFFFF00000000 = 00000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 80000001000000007FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 7FFFFFFF00000000 = 7FFFFFFF000000000000000000000001 (cc=0) ++msgr 000000000000FFFF * 7FFFFFFF00000000 = 7FFF000100000000000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 7FFFFFFF00000000 = 7FFF8001000000000000000000007FFF (cc=0) ++msgr 0000000000008000 * 7FFFFFFF00000000 = FFFF8000000000000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 7FFFFFFF00000000 = 800000010000000000000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 7FFFFFFF00000000 = 80000000000000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000100000000000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 8000000100000000FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 7FFFFFFF00000000 = 00000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 80000001000000007FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 7FFFFFFF00000000 = 000000007FFFFFFF0000000000000001 (cc=0) ++msgf 000000000000FFFF * 7FFFFFFF00000000 = 00007FFF7FFF0001000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 7FFFFFFF00000000 = 00003FFF7FFF80010000000000007FFF (cc=0) ++msgf 0000000000008000 * 7FFFFFFF00000000 = 00003FFFFFFF80000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFE8000000100000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 7FFFFFFF00000000 = 3FFFFFFF800000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 7FFFFFFF00000000 = 3FFFFFFF00000001000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 7FFFFFFF00000000 = 00000000000000000000000000000001 (cc=0) ++msgfr 000000000000FFFF * 7FFFFFFF00000000 = 0000000000000000000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 7FFFFFFF00000000 = 00000000000000000000000000007FFF (cc=0) ++msgfr 0000000000008000 * 7FFFFFFF00000000 = 00000000000000000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 7FFFFFFF00000000 = 00000000000000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 7FFFFFFF00000000 = 00000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 7FFFFFFF00000000 = 000000007FFFFFFF0000000000000001 (cc=0) ++msy 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFF0001000000000000FFFF (cc=0) ++msy 0000000000007FFF * 7FFFFFFF00000000 = 000000007FFF80010000000000007FFF (cc=0) ++msy 0000000000008000 * 7FFFFFFF00000000 = 00000000FFFF80000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 7FFFFFFF00000000 = 000000008000000100000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 7FFFFFFF00000000 = 00000000800000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 7FFFFFFF00000000 = 0000000000000001000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 8000000000000000 = 00000000FFFFFFFF0000000080000000 (cc=0) ++m 000000000000FFFF * 8000000000000000 = 00000000FFFF80000000000080000000 (cc=0) ++m 0000000000007FFF * 8000000000000000 = 00000000FFFFC0000000000080000000 (cc=0) ++m 0000000000008000 * 8000000000000000 = 00000000FFFFC0000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++m 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 8000000000000000 = 00000000C00000000000000080000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF80000000 (cc=0) ++m 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF80000000 (cc=0) ++mr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000008000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000080000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mh 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 8000000000000000 = 00000000FFFF80000000000000000001 (cc=0) ++mh 000000000000FFFF * 8000000000000000 = 0000000080008000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 8000000000000000 = 00000000C00080000000000000007FFF (cc=0) ++mh 0000000000008000 * 8000000000000000 = 00000000C00000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 8000000000000000 = 000000000000800000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 8000000000000000 = 0000000000008000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mlg 000000000000FFFF * 8000000000000000 = 0000000000007FFF8000000000000000 (cc=0) ++mlg 0000000000007FFF * 8000000000000000 = 0000000000003FFF8000000000000000 (cc=0) ++mlg 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 (cc=0) ++mlg 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF8000000000000000 (cc=0) ++mlg 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++mlg 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF8000000000000000 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlg 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 8000000000000000 = 3FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlgr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++mlgr 000000000000FFFF * 8000000000000000 = 0000000000007FFF8000000000000000 (cc=0) ++mlgr 0000000000007FFF * 8000000000000000 = 0000000000003FFF8000000000000000 (cc=0) ++mlgr 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 (cc=0) ++mlgr 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF8000000000000000 (cc=0) ++mlgr 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++mlgr 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF8000000000000000 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++mlgr 8000000000000000 * 8000000000000000 = 40000000000000000000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 8000000000000000 = 3FFFFFFFFFFFFFFF8000000000000000 (cc=0) ++ml 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++ml 000000000000FFFF * 8000000000000000 = 0000000000007FFF0000000080000000 (cc=0) ++ml 0000000000007FFF * 8000000000000000 = 0000000000003FFF0000000080000000 (cc=0) ++ml 0000000000008000 * 8000000000000000 = 00000000000040000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 8000000000000000 = 000000007FFFFFFF0000000080000000 (cc=0) ++ml 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 8000000000000000 = 000000003FFFFFFF0000000080000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF7FFFFFFFFFFFFFFF80000000 (cc=0) ++ml 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF7FFFFFFF7FFFFFFF80000000 (cc=0) ++mlr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000000000FFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000008000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000080000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000007FFFFFFF * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mlr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++ms 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 (cc=0) ++ms 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF (cc=0) ++ms 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000001 (cc=0) ++msr 000000000000FFFF * 8000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 8000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 8000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 (cc=0) ++msg 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF (cc=0) ++msg 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF (cc=0) ++msg 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 8000000000000000 = 80000000000000000000000000000001 (cc=0) ++msgr 000000000000FFFF * 8000000000000000 = 8000000000000000000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 8000000000000000 = 80000000000000000000000000007FFF (cc=0) ++msgr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 8000000000000000 = 800000000000000000000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 8000000000000000 = 8000000000000000000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 8000000000000000 = 8000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 8000000000000000 = 80000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 8000000000000000 = FFFFFFFF800000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 8000000000000000 = FFFF800080000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 8000000000000000 = FFFFC000800000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 8000000000000000 = FFFFC000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 8000000000000000 = 800000008000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 8000000000000000 = C0000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 8000000000000000 = C000000080000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000080000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000800000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 8000000000000000 = 00000000000000000000000000000001 (cc=0) ++msgfr 000000000000FFFF * 8000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 8000000000000000 = 00000000000000000000000000007FFF (cc=0) ++msgfr 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 8000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 8000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 8000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 8000000000000000 = 00000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 8000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 8000000000000000 = 00000000800000000000000000000001 (cc=0) ++msy 000000000000FFFF * 8000000000000000 = 0000000080000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 8000000000000000 = 00000000800000000000000000007FFF (cc=0) ++msy 0000000000008000 * 8000000000000000 = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 8000000000000000 = 000000008000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 8000000000000000 = 0000000080000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFFFFFF (cc=0) ++m 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF0001 (cc=0) ++m 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF8001 (cc=0) ++m 0000000000008000 * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF8000 (cc=0) ++m 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000001 (cc=0) ++m 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000080000000 (cc=0) ++m 000000007FFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFF0000000080000001 (cc=0) ++m FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000001 (cc=0) ++m 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000001 (cc=0) ++mr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000000000FFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000007FFF * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000008000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr 000000007FFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mr 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mh 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF0000000000000001 (cc=0) ++mh 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFF0001000000000000FFFF (cc=0) ++mh 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFF80010000000000007FFF (cc=0) ++mh 0000000000008000 * FFFFFFFF00000000 = 00000000FFFF80000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000100000000FFFFFFFF (cc=0) ++mh 0000000080000000 * FFFFFFFF00000000 = 00000000800000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * FFFFFFFF00000000 = 0000000080000001000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * FFFFFFFF00000000 = 0000000000000000FFFFFFFF00000000 (cc=0) ++mlg 000000000000FFFF * FFFFFFFF00000000 = 000000000000FFFEFFFF000100000000 (cc=0) ++mlg 0000000000007FFF * FFFFFFFF00000000 = 0000000000007FFEFFFF800100000000 (cc=0) ++mlg 0000000000008000 * FFFFFFFF00000000 = 0000000000007FFFFFFF800000000000 (cc=0) ++mlg 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFE0000000100000000 (cc=0) ++mlg 0000000080000000 * FFFFFFFF00000000 = 000000007FFFFFFF8000000000000000 (cc=0) ++mlg 000000007FFFFFFF * FFFFFFFF00000000 = 000000007FFFFFFE8000000100000000 (cc=0) ++mlg FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFEFFFFFFFF0000000100000000 (cc=0) ++mlg 8000000000000000 * FFFFFFFF00000000 = 7FFFFFFF800000000000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF7FFFFFFF0000000100000000 (cc=0) ++mlgr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * FFFFFFFF00000000 = 0000000000000000FFFFFFFF00000000 (cc=0) ++mlgr 000000000000FFFF * FFFFFFFF00000000 = 000000000000FFFEFFFF000100000000 (cc=0) ++mlgr 0000000000007FFF * FFFFFFFF00000000 = 0000000000007FFEFFFF800100000000 (cc=0) ++mlgr 0000000000008000 * FFFFFFFF00000000 = 0000000000007FFFFFFF800000000000 (cc=0) ++mlgr 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFE0000000100000000 (cc=0) ++mlgr 0000000080000000 * FFFFFFFF00000000 = 000000007FFFFFFF8000000000000000 (cc=0) ++mlgr 000000007FFFFFFF * FFFFFFFF00000000 = 000000007FFFFFFE8000000100000000 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFEFFFFFFFF0000000100000000 (cc=0) ++mlgr 8000000000000000 * FFFFFFFF00000000 = 7FFFFFFF800000000000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF7FFFFFFF0000000100000000 (cc=0) ++ml 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * FFFFFFFF00000000 = 000000000000000000000000FFFFFFFF (cc=0) ++ml 000000000000FFFF * FFFFFFFF00000000 = 000000000000FFFE00000000FFFF0001 (cc=0) ++ml 0000000000007FFF * FFFFFFFF00000000 = 0000000000007FFE00000000FFFF8001 (cc=0) ++ml 0000000000008000 * FFFFFFFF00000000 = 0000000000007FFF00000000FFFF8000 (cc=0) ++ml 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFE0000000000000001 (cc=0) ++ml 0000000080000000 * FFFFFFFF00000000 = 000000007FFFFFFF0000000080000000 (cc=0) ++ml 000000007FFFFFFF * FFFFFFFF00000000 = 000000007FFFFFFE0000000080000001 (cc=0) ++ml FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFFFFFFFFFEFFFFFFFF00000001 (cc=0) ++ml 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 (cc=0) ++mlr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000000000FFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000007FFF * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000008000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr 000000007FFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mlr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mlr 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++ms 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF0000000000000001 (cc=0) ++ms 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFF0001000000000000FFFF (cc=0) ++ms 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFF80010000000000007FFF (cc=0) ++ms 0000000000008000 * FFFFFFFF00000000 = 00000000FFFF80000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000100000000FFFFFFFF (cc=0) ++ms 0000000080000000 * FFFFFFFF00000000 = 00000000800000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * FFFFFFFF00000000 = 0000000080000001000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * FFFFFFFF00000000 = 00000000000000000000000000000001 (cc=0) ++msr 000000000000FFFF * FFFFFFFF00000000 = 0000000000000000000000000000FFFF (cc=0) ++msr 0000000000007FFF * FFFFFFFF00000000 = 00000000000000000000000000007FFF (cc=0) ++msr 0000000000008000 * FFFFFFFF00000000 = 00000000000000000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msr 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * FFFFFFFF00000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * FFFFFFFF00000000 = FFFFFFFF000000000000000000000001 (cc=0) ++msg 000000000000FFFF * FFFFFFFF00000000 = FFFF000100000000000000000000FFFF (cc=0) ++msg 0000000000007FFF * FFFFFFFF00000000 = FFFF8001000000000000000000007FFF (cc=0) ++msg 0000000000008000 * FFFFFFFF00000000 = FFFF8000000000000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * FFFFFFFF00000000 = 000000010000000000000000FFFFFFFF (cc=0) ++msg 0000000080000000 * FFFFFFFF00000000 = 80000000000000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * FFFFFFFF00000000 = 8000000100000000000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000100000000FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * FFFFFFFF00000000 = 00000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000001000000007FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * FFFFFFFF00000000 = FFFFFFFF000000000000000000000001 (cc=0) ++msgr 000000000000FFFF * FFFFFFFF00000000 = FFFF000100000000000000000000FFFF (cc=0) ++msgr 0000000000007FFF * FFFFFFFF00000000 = FFFF8001000000000000000000007FFF (cc=0) ++msgr 0000000000008000 * FFFFFFFF00000000 = FFFF8000000000000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * FFFFFFFF00000000 = 000000010000000000000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * FFFFFFFF00000000 = 80000000000000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * FFFFFFFF00000000 = 8000000100000000000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000100000000FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * FFFFFFFF00000000 = 00000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000001000000007FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * FFFFFFFF00000000 = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msgf 000000000000FFFF * FFFFFFFF00000000 = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++msgf 0000000000007FFF * FFFFFFFF00000000 = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++msgf 0000000000008000 * FFFFFFFF00000000 = FFFFFFFFFFFF80000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * FFFFFFFF00000000 = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * FFFFFFFF00000000 = FFFFFFFF800000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * FFFFFFFF00000000 = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * FFFFFFFF00000000 = 00000000000000000000000000000001 (cc=0) ++msgfr 000000000000FFFF * FFFFFFFF00000000 = 0000000000000000000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * FFFFFFFF00000000 = 00000000000000000000000000007FFF (cc=0) ++msgfr 0000000000008000 * FFFFFFFF00000000 = 00000000000000000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * FFFFFFFF00000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * FFFFFFFF00000000 = 00000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF0000000000000001 (cc=0) ++msy 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFF0001000000000000FFFF (cc=0) ++msy 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFF80010000000000007FFF (cc=0) ++msy 0000000000008000 * FFFFFFFF00000000 = 00000000FFFF80000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000100000000FFFFFFFF (cc=0) ++msy 0000000080000000 * FFFFFFFF00000000 = 00000000800000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * FFFFFFFF00000000 = 0000000080000001000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 000000000000FFFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++m 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mr 000000000000FFFF * 000000007FFFFFFF = 0000000000007FFF000000007FFF0001 (cc=0) ++mr 0000000000007FFF * 000000007FFFFFFF = 0000000000003FFF000000007FFF8001 (cc=0) ++mr 0000000000008000 * 000000007FFFFFFF = 0000000000003FFF00000000FFFF8000 (cc=0) ++mr 00000000FFFFFFFF * 000000007FFFFFFF = 00000000FFFFFFFF0000000080000001 (cc=0) ++mr 0000000080000000 * 000000007FFFFFFF = 00000000C00000000000000080000000 (cc=0) ++mr 000000007FFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF0000000000000001 (cc=0) ++mr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 (cc=0) ++mr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 (cc=0) ++mh 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 (cc=0) ++mh 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF (cc=0) ++mh 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mlg 000000000000FFFF * 000000007FFFFFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mlg 0000000000007FFF * 000000007FFFFFFF = 000000000000000000003FFF7FFF8001 (cc=0) ++mlg 0000000000008000 * 000000007FFFFFFF = 000000000000000000003FFFFFFF8000 (cc=0) ++mlg 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000007FFFFFFE80000001 (cc=0) ++mlg 0000000080000000 * 000000007FFFFFFF = 00000000000000003FFFFFFF80000000 (cc=0) ++mlg 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000003FFFFFFF00000001 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000007FFFFFFEFFFFFFFF80000001 (cc=0) ++mlg 8000000000000000 * 000000007FFFFFFF = 000000003FFFFFFF8000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 (cc=0) ++mlgr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mlgr 000000000000FFFF * 000000007FFFFFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mlgr 0000000000007FFF * 000000007FFFFFFF = 000000000000000000003FFF7FFF8001 (cc=0) ++mlgr 0000000000008000 * 000000007FFFFFFF = 000000000000000000003FFFFFFF8000 (cc=0) ++mlgr 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000007FFFFFFE80000001 (cc=0) ++mlgr 0000000080000000 * 000000007FFFFFFF = 00000000000000003FFFFFFF80000000 (cc=0) ++mlgr 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000003FFFFFFF00000001 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000007FFFFFFEFFFFFFFF80000001 (cc=0) ++mlgr 8000000000000000 * 000000007FFFFFFF = 000000003FFFFFFF8000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF7FFFFFFF80000001 (cc=0) ++ml 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 000000000000FFFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++ml 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mlr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mlr 000000000000FFFF * 000000007FFFFFFF = 0000000000007FFF000000007FFF0001 (cc=0) ++mlr 0000000000007FFF * 000000007FFFFFFF = 0000000000003FFF000000007FFF8001 (cc=0) ++mlr 0000000000008000 * 000000007FFFFFFF = 0000000000003FFF00000000FFFF8000 (cc=0) ++mlr 00000000FFFFFFFF * 000000007FFFFFFF = 000000007FFFFFFE0000000080000001 (cc=0) ++mlr 0000000080000000 * 000000007FFFFFFF = 000000003FFFFFFF0000000080000000 (cc=0) ++mlr 000000007FFFFFFF * 000000007FFFFFFF = 000000003FFFFFFF0000000000000001 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF7FFFFFFEFFFFFFFF80000001 (cc=0) ++mlr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF7FFFFFFE7FFFFFFF80000001 (cc=0) ++ms 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 (cc=0) ++ms 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF (cc=0) ++ms 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 (cc=0) ++msr 000000000000FFFF * 000000007FFFFFFF = 000000007FFF0001000000000000FFFF (cc=0) ++msr 0000000000007FFF * 000000007FFFFFFF = 000000007FFF80010000000000007FFF (cc=0) ++msr 0000000000008000 * 000000007FFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 000000007FFFFFFF = 000000008000000100000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 000000007FFFFFFF = 00000000800000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000001000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 (cc=0) ++msg 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF0001000000000000FFFF (cc=0) ++msg 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000007FFF (cc=0) ++msg 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF00000001000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 (cc=0) ++msgr 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF0001000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000007FFF (cc=0) ++msgr 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF00000001000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 000000007FFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 000000007FFFFFFF = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 (cc=0) ++msgfr 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF0001000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000007FFF (cc=0) ++msgfr 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF00000001000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 (cc=0) ++msy 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF (cc=0) ++msy 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++m 000000000000FFFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000007FFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000008000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++m 0000000080000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++m 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 0000000080000000 = 00000000FFFFFFFF0000000080000000 (cc=0) ++mr 000000000000FFFF * 0000000080000000 = 00000000FFFF80000000000080000000 (cc=0) ++mr 0000000000007FFF * 0000000080000000 = 00000000FFFFC0000000000080000000 (cc=0) ++mr 0000000000008000 * 0000000080000000 = 00000000FFFFC0000000000000000000 (cc=0) ++mr 00000000FFFFFFFF * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++mr 0000000080000000 * 0000000080000000 = 00000000400000000000000000000000 (cc=0) ++mr 000000007FFFFFFF * 0000000080000000 = 00000000C00000000000000080000000 (cc=0) ++mr FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFF80000000 (cc=0) ++mr 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFF80000000 (cc=0) ++mh 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 (cc=0) ++mh 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF (cc=0) ++mh 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++mlg 000000000000FFFF * 0000000080000000 = 000000000000000000007FFF80000000 (cc=0) ++mlg 0000000000007FFF * 0000000080000000 = 000000000000000000003FFF80000000 (cc=0) ++mlg 0000000000008000 * 0000000080000000 = 00000000000000000000400000000000 (cc=0) ++mlg 00000000FFFFFFFF * 0000000080000000 = 00000000000000007FFFFFFF80000000 (cc=0) ++mlg 0000000080000000 * 0000000080000000 = 00000000000000004000000000000000 (cc=0) ++mlg 000000007FFFFFFF * 0000000080000000 = 00000000000000003FFFFFFF80000000 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 0000000080000000 = 000000007FFFFFFFFFFFFFFF80000000 (cc=0) ++mlg 8000000000000000 * 0000000080000000 = 00000000400000000000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 0000000080000000 = 000000003FFFFFFFFFFFFFFF80000000 (cc=0) ++mlgr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++mlgr 000000000000FFFF * 0000000080000000 = 000000000000000000007FFF80000000 (cc=0) ++mlgr 0000000000007FFF * 0000000080000000 = 000000000000000000003FFF80000000 (cc=0) ++mlgr 0000000000008000 * 0000000080000000 = 00000000000000000000400000000000 (cc=0) ++mlgr 00000000FFFFFFFF * 0000000080000000 = 00000000000000007FFFFFFF80000000 (cc=0) ++mlgr 0000000080000000 * 0000000080000000 = 00000000000000004000000000000000 (cc=0) ++mlgr 000000007FFFFFFF * 0000000080000000 = 00000000000000003FFFFFFF80000000 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 0000000080000000 = 000000007FFFFFFFFFFFFFFF80000000 (cc=0) ++mlgr 8000000000000000 * 0000000080000000 = 00000000400000000000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 0000000080000000 = 000000003FFFFFFFFFFFFFFF80000000 (cc=0) ++ml 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++ml 000000000000FFFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000007FFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000008000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000080000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++ml 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mlr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++mlr 000000000000FFFF * 0000000080000000 = 0000000000007FFF0000000080000000 (cc=0) ++mlr 0000000000007FFF * 0000000080000000 = 0000000000003FFF0000000080000000 (cc=0) ++mlr 0000000000008000 * 0000000080000000 = 00000000000040000000000000000000 (cc=0) ++mlr 00000000FFFFFFFF * 0000000080000000 = 000000007FFFFFFF0000000080000000 (cc=0) ++mlr 0000000080000000 * 0000000080000000 = 00000000400000000000000000000000 (cc=0) ++mlr 000000007FFFFFFF * 0000000080000000 = 000000003FFFFFFF0000000080000000 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF7FFFFFFFFFFFFFFF80000000 (cc=0) ++mlr 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF7FFFFFFF7FFFFFFF80000000 (cc=0) ++ms 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 (cc=0) ++ms 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF (cc=0) ++ms 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 0000000080000000 = 00000000800000000000000000000001 (cc=0) ++msr 000000000000FFFF * 0000000080000000 = 0000000080000000000000000000FFFF (cc=0) ++msr 0000000000007FFF * 0000000080000000 = 00000000800000000000000000007FFF (cc=0) ++msr 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 0000000080000000 = 000000008000000000000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 0000000080000000 = 0000000080000000000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 0000000080000000 = 00000000800000000000000000000001 (cc=0) ++msg 000000000000FFFF * 0000000080000000 = 00007FFF80000000000000000000FFFF (cc=0) ++msg 0000000000007FFF * 0000000080000000 = 00003FFF800000000000000000007FFF (cc=0) ++msg 0000000000008000 * 0000000080000000 = 00004000000000000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 0000000080000000 = 7FFFFFFF8000000000000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 0000000080000000 = 40000000000000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 0000000080000000 = 3FFFFFFF80000000000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF800000007FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 0000000080000000 = 00000000800000000000000000000001 (cc=0) ++msgr 000000000000FFFF * 0000000080000000 = 00007FFF80000000000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 0000000080000000 = 00003FFF800000000000000000007FFF (cc=0) ++msgr 0000000000008000 * 0000000080000000 = 00004000000000000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 0000000080000000 = 7FFFFFFF8000000000000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 0000000080000000 = 40000000000000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 0000000080000000 = 3FFFFFFF80000000000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF800000007FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 0000000080000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 0000000080000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 0000000080000000 = FFFFFFFF800000000000000000000001 (cc=0) ++msgfr 000000000000FFFF * 0000000080000000 = FFFF800080000000000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 0000000080000000 = FFFFC000800000000000000000007FFF (cc=0) ++msgfr 0000000000008000 * 0000000080000000 = FFFFC000000000000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 0000000080000000 = 800000008000000000000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 0000000080000000 = C0000000000000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 0000000080000000 = C000000080000000000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 0000000080000000 = 0000000080000000FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 0000000080000000 = 00000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 0000000080000000 = 00000000800000007FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 (cc=0) ++msy 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF (cc=0) ++msy 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++m 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF (cc=0) ++mr 000000000000FFFF * 00000000FFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 (cc=0) ++mr 0000000000007FFF * 00000000FFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 (cc=0) ++mr 0000000000008000 * 00000000FFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 (cc=0) ++mr 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000001 (cc=0) ++mr 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 (cc=0) ++mr 000000007FFFFFFF * 00000000FFFFFFFF = 00000000FFFFFFFF0000000080000001 (cc=0) ++mr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 (cc=0) ++mr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 (cc=0) ++mh 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 (cc=0) ++mh 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF (cc=0) ++mh 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mlg 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mlg 0000000000007FFF * 00000000FFFFFFFF = 000000000000000000007FFEFFFF8001 (cc=0) ++mlg 0000000000008000 * 00000000FFFFFFFF = 000000000000000000007FFFFFFF8000 (cc=0) ++mlg 00000000FFFFFFFF * 00000000FFFFFFFF = 0000000000000000FFFFFFFE00000001 (cc=0) ++mlg 0000000080000000 * 00000000FFFFFFFF = 00000000000000007FFFFFFF80000000 (cc=0) ++mlg 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000007FFFFFFE80000001 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = 00000000FFFFFFFEFFFFFFFF00000001 (cc=0) ++mlg 8000000000000000 * 00000000FFFFFFFF = 000000007FFFFFFF8000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 (cc=0) ++mlgr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mlgr 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mlgr 0000000000007FFF * 00000000FFFFFFFF = 000000000000000000007FFEFFFF8001 (cc=0) ++mlgr 0000000000008000 * 00000000FFFFFFFF = 000000000000000000007FFFFFFF8000 (cc=0) ++mlgr 00000000FFFFFFFF * 00000000FFFFFFFF = 0000000000000000FFFFFFFE00000001 (cc=0) ++mlgr 0000000080000000 * 00000000FFFFFFFF = 00000000000000007FFFFFFF80000000 (cc=0) ++mlgr 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000007FFFFFFE80000001 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = 00000000FFFFFFFEFFFFFFFF00000001 (cc=0) ++mlgr 8000000000000000 * 00000000FFFFFFFF = 000000007FFFFFFF8000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 000000007FFFFFFF7FFFFFFF00000001 (cc=0) ++ml 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++ml 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mlr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mlr 000000000000FFFF * 00000000FFFFFFFF = 000000000000FFFE00000000FFFF0001 (cc=0) ++mlr 0000000000007FFF * 00000000FFFFFFFF = 0000000000007FFE00000000FFFF8001 (cc=0) ++mlr 0000000000008000 * 00000000FFFFFFFF = 0000000000007FFF00000000FFFF8000 (cc=0) ++mlr 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000FFFFFFFE0000000000000001 (cc=0) ++mlr 0000000080000000 * 00000000FFFFFFFF = 000000007FFFFFFF0000000080000000 (cc=0) ++mlr 000000007FFFFFFF * 00000000FFFFFFFF = 000000007FFFFFFE0000000080000001 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFFFFFFFFFEFFFFFFFF00000001 (cc=0) ++mlr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFFFFFFFFFE7FFFFFFF00000001 (cc=0) ++ms 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 (cc=0) ++ms 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF (cc=0) ++ms 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++msr 000000000000FFFF * 00000000FFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=0) ++msr 0000000000007FFF * 00000000FFFFFFFF = 00000000FFFF80010000000000007FFF (cc=0) ++msr 0000000000008000 * 00000000FFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000100000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 00000000FFFFFFFF = 00000000800000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 00000000FFFFFFFF = 0000000080000001000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++msg 000000000000FFFF * 00000000FFFFFFFF = 0000FFFEFFFF0001000000000000FFFF (cc=0) ++msg 0000000000007FFF * 00000000FFFFFFFF = 00007FFEFFFF80010000000000007FFF (cc=0) ++msg 0000000000008000 * 00000000FFFFFFFF = 00007FFFFFFF80000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 00000000FFFFFFFF = FFFFFFFE0000000100000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 00000000FFFFFFFF = 7FFFFFFF800000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 00000000FFFFFFFF = 7FFFFFFE80000001000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 00000000FFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++msgr 000000000000FFFF * 00000000FFFFFFFF = 0000FFFEFFFF0001000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 00000000FFFFFFFF = 00007FFEFFFF80010000000000007FFF (cc=0) ++msgr 0000000000008000 * 00000000FFFFFFFF = 00007FFFFFFF80000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 00000000FFFFFFFF = FFFFFFFE0000000100000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 00000000FFFFFFFF = 7FFFFFFF800000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 00000000FFFFFFFF = 7FFFFFFE80000001000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 00000000FFFFFFFF = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 00000000FFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++msgfr 000000000000FFFF * 00000000FFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 00000000FFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++msgfr 0000000000008000 * 00000000FFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 00000000FFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 00000000FFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 00000000FFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 (cc=0) ++msy 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF (cc=0) ++msy 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++m 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mr 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFFFFFF00000000FFFF0001 (cc=0) ++mr 0000000080000000 * 000000000000FFFF = 00000000FFFF80000000000080000000 (cc=0) ++mr 000000007FFFFFFF * 000000000000FFFF = 0000000000007FFF000000007FFF0001 (cc=0) ++mr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 (cc=0) ++mr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFFFFFF7FFFFFFFFFFF0001 (cc=0) ++mh 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++mh 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++mh 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mlg 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mlg 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mlg 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mlg 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mlg 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 (cc=0) ++mlg 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 000000000000FFFF = 000000000000FFFEFFFFFFFFFFFF0001 (cc=0) ++mlg 8000000000000000 * 000000000000FFFF = 0000000000007FFF8000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++mlgr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mlgr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mlgr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mlgr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mlgr 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mlgr 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 (cc=0) ++mlgr 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 000000000000FFFF = 000000000000FFFEFFFFFFFFFFFF0001 (cc=0) ++mlgr 8000000000000000 * 000000000000FFFF = 0000000000007FFF8000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++ml 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++ml 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mlr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mlr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mlr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mlr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mlr 00000000FFFFFFFF * 000000000000FFFF = 000000000000FFFE00000000FFFF0001 (cc=0) ++mlr 0000000080000000 * 000000000000FFFF = 0000000000007FFF0000000080000000 (cc=0) ++mlr 000000007FFFFFFF * 000000000000FFFF = 0000000000007FFF000000007FFF0001 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF0000FFFEFFFFFFFFFFFF0001 (cc=0) ++mlr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF0000FFFE7FFFFFFFFFFF0001 (cc=0) ++ms 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++ms 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++ms 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=0) ++msr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=0) ++msr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=0) ++msr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFF000100000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 000000000000FFFF = 00000000800000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 000000000000FFFF = 000000007FFF0001000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=0) ++msg 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=0) ++msg 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=0) ++msg 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=0) ++msgr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=0) ++msgr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 000000000000FFFF = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 000000000000FFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=0) ++msgfr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=0) ++msgfr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++msy 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++msy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++m 000000000000FFFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000008000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++m 0000000080000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++m 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++mr 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 (cc=0) ++mr 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 (cc=0) ++mr 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 (cc=0) ++mr 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFFFFFF00000000FFFF8001 (cc=0) ++mr 0000000080000000 * 0000000000007FFF = 00000000FFFFC0000000000080000000 (cc=0) ++mr 000000007FFFFFFF * 0000000000007FFF = 0000000000003FFF000000007FFF8001 (cc=0) ++mr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8001 (cc=0) ++mr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFFFFFF7FFFFFFFFFFF8001 (cc=0) ++mh 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 (cc=0) ++mh 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++mh 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++mlg 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 (cc=0) ++mlg 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 (cc=0) ++mlg 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 (cc=0) ++mlg 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000007FFEFFFF8001 (cc=0) ++mlg 0000000080000000 * 0000000000007FFF = 000000000000000000003FFF80000000 (cc=0) ++mlg 000000007FFFFFFF * 0000000000007FFF = 000000000000000000003FFF7FFF8001 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000007FFEFFFFFFFFFFFF8001 (cc=0) ++mlg 8000000000000000 * 0000000000007FFF = 0000000000003FFF8000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000003FFF7FFFFFFFFFFF8001 (cc=0) ++mlgr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++mlgr 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 (cc=0) ++mlgr 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 (cc=0) ++mlgr 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 (cc=0) ++mlgr 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000007FFEFFFF8001 (cc=0) ++mlgr 0000000080000000 * 0000000000007FFF = 000000000000000000003FFF80000000 (cc=0) ++mlgr 000000007FFFFFFF * 0000000000007FFF = 000000000000000000003FFF7FFF8001 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000007FFEFFFFFFFFFFFF8001 (cc=0) ++mlgr 8000000000000000 * 0000000000007FFF = 0000000000003FFF8000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000003FFF7FFFFFFFFFFF8001 (cc=0) ++ml 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++ml 000000000000FFFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000008000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000080000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++ml 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mlr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++mlr 000000000000FFFF * 0000000000007FFF = 0000000000000000000000007FFE8001 (cc=0) ++mlr 0000000000007FFF * 0000000000007FFF = 0000000000000000000000003FFF0001 (cc=0) ++mlr 0000000000008000 * 0000000000007FFF = 0000000000000000000000003FFF8000 (cc=0) ++mlr 00000000FFFFFFFF * 0000000000007FFF = 0000000000007FFE00000000FFFF8001 (cc=0) ++mlr 0000000080000000 * 0000000000007FFF = 0000000000003FFF0000000080000000 (cc=0) ++mlr 000000007FFFFFFF * 0000000000007FFF = 0000000000003FFF000000007FFF8001 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00007FFEFFFFFFFFFFFF8001 (cc=0) ++mlr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF00007FFE7FFFFFFFFFFF8001 (cc=0) ++ms 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 (cc=0) ++ms 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++ms 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++msr 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++msr 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++msr 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++msg 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++msg 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++msg 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++msgr 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++msgr 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 0000000000007FFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 0000000000007FFF = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 0000000000007FFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++msgfr 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++msgfr 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 (cc=0) ++msy 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++msy 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++m 000000000000FFFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000007FFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++m 0000000000008000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++m 0000000080000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++m 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++mr 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 (cc=0) ++mr 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 (cc=0) ++mr 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 (cc=0) ++mr 00000000FFFFFFFF * 0000000000008000 = 00000000FFFFFFFF00000000FFFF8000 (cc=0) ++mr 0000000080000000 * 0000000000008000 = 00000000FFFFC0000000000000000000 (cc=0) ++mr 000000007FFFFFFF * 0000000000008000 = 0000000000003FFF00000000FFFF8000 (cc=0) ++mr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFFFFFFFFFFFFFFFFFF8000 (cc=0) ++mr 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFFFFFFFFFF7FFFFFFFFFFF8000 (cc=0) ++mh 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 (cc=0) ++mh 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF (cc=0) ++mh 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++mlg 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 (cc=0) ++mlg 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 (cc=0) ++mlg 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 (cc=0) ++mlg 00000000FFFFFFFF * 0000000000008000 = 000000000000000000007FFFFFFF8000 (cc=0) ++mlg 0000000080000000 * 0000000000008000 = 00000000000000000000400000000000 (cc=0) ++mlg 000000007FFFFFFF * 0000000000008000 = 000000000000000000003FFFFFFF8000 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 0000000000008000 = 0000000000007FFFFFFFFFFFFFFF8000 (cc=0) ++mlg 8000000000000000 * 0000000000008000 = 00000000000040000000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 0000000000008000 = 0000000000003FFFFFFFFFFFFFFF8000 (cc=0) ++mlgr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++mlgr 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 (cc=0) ++mlgr 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 (cc=0) ++mlgr 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 (cc=0) ++mlgr 00000000FFFFFFFF * 0000000000008000 = 000000000000000000007FFFFFFF8000 (cc=0) ++mlgr 0000000080000000 * 0000000000008000 = 00000000000000000000400000000000 (cc=0) ++mlgr 000000007FFFFFFF * 0000000000008000 = 000000000000000000003FFFFFFF8000 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 0000000000008000 = 0000000000007FFFFFFFFFFFFFFF8000 (cc=0) ++mlgr 8000000000000000 * 0000000000008000 = 00000000000040000000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 0000000000008000 = 0000000000003FFFFFFFFFFFFFFF8000 (cc=0) ++ml 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++ml 000000000000FFFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000007FFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000000008000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++ml 0000000080000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++ml 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mlr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++mlr 000000000000FFFF * 0000000000008000 = 0000000000000000000000007FFF8000 (cc=0) ++mlr 0000000000007FFF * 0000000000008000 = 0000000000000000000000003FFF8000 (cc=0) ++mlr 0000000000008000 * 0000000000008000 = 00000000000000000000000040000000 (cc=0) ++mlr 00000000FFFFFFFF * 0000000000008000 = 0000000000007FFF00000000FFFF8000 (cc=0) ++mlr 0000000080000000 * 0000000000008000 = 00000000000040000000000000000000 (cc=0) ++mlr 000000007FFFFFFF * 0000000000008000 = 0000000000003FFF00000000FFFF8000 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00007FFFFFFFFFFFFFFF8000 (cc=0) ++mlr 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF00007FFF7FFFFFFFFFFF8000 (cc=0) ++ms 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 (cc=0) ++ms 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF (cc=0) ++ms 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 0000000000008000 = 00000000000080000000000000000001 (cc=0) ++msr 000000000000FFFF * 0000000000008000 = 000000007FFF8000000000000000FFFF (cc=0) ++msr 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000007FFF (cc=0) ++msr 0000000000008000 * 0000000000008000 = 00000000400000000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 0000000000008000 = 00000000FFFF800000000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 0000000000008000 = 00000000FFFF8000000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF8000FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFFFFFF80007FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 0000000000008000 = 00000000000080000000000000000001 (cc=0) ++msg 000000000000FFFF * 0000000000008000 = 000000007FFF8000000000000000FFFF (cc=0) ++msg 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000007FFF (cc=0) ++msg 0000000000008000 * 0000000000008000 = 00000000400000000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 0000000000008000 = 00007FFFFFFF800000000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 0000000000008000 = 00004000000000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 0000000000008000 = 00003FFFFFFF8000000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF8000FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80007FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 0000000000008000 = 00000000000080000000000000000001 (cc=0) ++msgr 000000000000FFFF * 0000000000008000 = 000000007FFF8000000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000007FFF (cc=0) ++msgr 0000000000008000 * 0000000000008000 = 00000000400000000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 0000000000008000 = 00007FFFFFFF800000000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 0000000000008000 = 00004000000000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 0000000000008000 = 00003FFFFFFF8000000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF8000FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80007FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 0000000000008000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 0000000000008000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 0000000000008000 = 00000000000080000000000000000001 (cc=0) ++msgfr 000000000000FFFF * 0000000000008000 = 000000007FFF8000000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 0000000000008000 = 000000003FFF80000000000000007FFF (cc=0) ++msgfr 0000000000008000 * 0000000000008000 = 00000000400000000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 0000000000008000 = 00007FFFFFFF800000000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 0000000000008000 = 00004000000000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 0000000000008000 = 00003FFFFFFF8000000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF8000FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 0000000000008000 = 00000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFFFFFF80007FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 (cc=0) ++msy 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF (cc=0) ++msy 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++m 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++m FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++m 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++m 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mr 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFFFFFF00000000FFFF0001 (cc=0) ++mr 0000000080000000 * 000000000000FFFF = 00000000FFFF80000000000080000000 (cc=0) ++mr 000000007FFFFFFF * 000000000000FFFF = 0000000000007FFF000000007FFF0001 (cc=0) ++mr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFFFFFFFFFFFFFFFFFF0001 (cc=0) ++mr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFFFFFF7FFFFFFFFFFF0001 (cc=0) ++mh 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mh 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++mh 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mh 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++mh 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++mh 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mh 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++mh 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mh FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mh 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mh 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mlg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mlg 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mlg 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mlg 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mlg 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mlg 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mlg 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 (cc=0) ++mlg 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mlg FFFFFFFFFFFFFFFF * 000000000000FFFF = 000000000000FFFEFFFFFFFFFFFF0001 (cc=0) ++mlg 8000000000000000 * 000000000000FFFF = 0000000000007FFF8000000000000000 (cc=0) ++mlg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++mlgr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mlgr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mlgr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mlgr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mlgr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mlgr 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000FFFEFFFF0001 (cc=0) ++mlgr 0000000080000000 * 000000000000FFFF = 000000000000000000007FFF80000000 (cc=0) ++mlgr 000000007FFFFFFF * 000000000000FFFF = 000000000000000000007FFF7FFF0001 (cc=0) ++mlgr FFFFFFFFFFFFFFFF * 000000000000FFFF = 000000000000FFFEFFFFFFFFFFFF0001 (cc=0) ++mlgr 8000000000000000 * 000000000000FFFF = 0000000000007FFF8000000000000000 (cc=0) ++mlgr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000007FFF7FFFFFFFFFFF0001 (cc=0) ++ml 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ml FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++ml 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++ml 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mlr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mlr 0000000000000001 * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mlr 000000000000FFFF * 000000000000FFFF = 000000000000000000000000FFFE0001 (cc=0) ++mlr 0000000000007FFF * 000000000000FFFF = 0000000000000000000000007FFE8001 (cc=0) ++mlr 0000000000008000 * 000000000000FFFF = 0000000000000000000000007FFF8000 (cc=0) ++mlr 00000000FFFFFFFF * 000000000000FFFF = 000000000000FFFE00000000FFFF0001 (cc=0) ++mlr 0000000080000000 * 000000000000FFFF = 0000000000007FFF0000000080000000 (cc=0) ++mlr 000000007FFFFFFF * 000000000000FFFF = 0000000000007FFF000000007FFF0001 (cc=0) ++mlr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF0000FFFEFFFFFFFFFFFF0001 (cc=0) ++mlr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mlr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF0000FFFE7FFFFFFFFFFF0001 (cc=0) ++ms 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++ms 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++ms 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++ms 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++ms 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++ms 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++ms 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++ms 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++ms FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++ms 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++ms 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++msr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=0) ++msr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=0) ++msr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=0) ++msr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=0) ++msr 00000000FFFFFFFF * 000000000000FFFF = 00000000FFFF000100000000FFFFFFFF (cc=0) ++msr 0000000080000000 * 000000000000FFFF = 00000000800000000000000080000000 (cc=0) ++msr 000000007FFFFFFF * 000000000000FFFF = 000000007FFF0001000000007FFFFFFF (cc=0) ++msr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=0) ++msr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=0) ++msg 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msg 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=0) ++msg 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=0) ++msg 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=0) ++msg 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=0) ++msg 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF (cc=0) ++msg 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 (cc=0) ++msg 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF (cc=0) ++msg FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=0) ++msg 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msg 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=0) ++msgr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msgr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=0) ++msgr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=0) ++msgr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=0) ++msgr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=0) ++msgr 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF (cc=0) ++msgr 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 (cc=0) ++msgr 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF (cc=0) ++msgr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=0) ++msgr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msgr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=0) ++msgf 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msgf 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++msgf 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++msgf 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++msgf 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++msgf 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msgf 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++msgf 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msgf FFFFFFFFFFFFFFFF * 000000000000FFFF = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++msgf 8000000000000000 * 000000000000FFFF = 00000000000000008000000000000000 (cc=0) ++msgf 7FFFFFFFFFFFFFFF * 000000000000FFFF = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++msgfr 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msgfr 0000000000000001 * 000000000000FFFF = 000000000000FFFF0000000000000001 (cc=0) ++msgfr 000000000000FFFF * 000000000000FFFF = 00000000FFFE0001000000000000FFFF (cc=0) ++msgfr 0000000000007FFF * 000000000000FFFF = 000000007FFE80010000000000007FFF (cc=0) ++msgfr 0000000000008000 * 000000000000FFFF = 000000007FFF80000000000000008000 (cc=0) ++msgfr 00000000FFFFFFFF * 000000000000FFFF = 0000FFFEFFFF000100000000FFFFFFFF (cc=0) ++msgfr 0000000080000000 * 000000000000FFFF = 00007FFF800000000000000080000000 (cc=0) ++msgfr 000000007FFFFFFF * 000000000000FFFF = 00007FFF7FFF0001000000007FFFFFFF (cc=0) ++msgfr FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFFFFFF0001FFFFFFFFFFFFFFFF (cc=0) ++msgfr 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msgfr 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFFFFFF00017FFFFFFFFFFFFFFF (cc=0) ++msy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++msy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++msy 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++msy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++msy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++msy 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++msy 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++msy 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++msy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++msy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++msy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mhi 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mhi 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++mhi 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++mhi 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++mhi 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++mhi 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++mhi 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++mhi 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++mhi FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mhi 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++mhi 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mhi 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mhi 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++mhi 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=0) ++mhi 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF (cc=0) ++mhi 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++mhi 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF (cc=0) ++mhi 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++mhi 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF (cc=0) ++mhi FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++mhi 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mhi 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++mhi 0000000000000000 * FFFFFFFFFFFF8000 = 00000000000000000000000000000000 (cc=0) ++mhi 0000000000000001 * FFFFFFFFFFFF8000 = 00000000FFFF80000000000000000001 (cc=0) ++mhi 000000000000FFFF * FFFFFFFFFFFF8000 = 0000000080008000000000000000FFFF (cc=0) ++mhi 0000000000007FFF * FFFFFFFFFFFF8000 = 00000000C00080000000000000007FFF (cc=0) ++mhi 0000000000008000 * FFFFFFFFFFFF8000 = 00000000C00000000000000000008000 (cc=0) ++mhi 00000000FFFFFFFF * FFFFFFFFFFFF8000 = 000000000000800000000000FFFFFFFF (cc=0) ++mhi 0000000080000000 * FFFFFFFFFFFF8000 = 00000000000000000000000080000000 (cc=0) ++mhi 000000007FFFFFFF * FFFFFFFFFFFF8000 = 0000000000008000000000007FFFFFFF (cc=0) ++mhi FFFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF (cc=0) ++mhi 8000000000000000 * FFFFFFFFFFFF8000 = 80000000000000008000000000000000 (cc=0) ++mhi 7FFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF (cc=0) ++mhi 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mhi 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++mhi 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++mhi 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++mhi 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++mhi 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF (cc=0) ++mhi 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 (cc=0) ++mhi 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF (cc=0) ++mhi FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++mhi 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++mhi 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++mghi 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mghi 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++mghi 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++mghi 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++mghi 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++mghi 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++mghi 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++mghi 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++mghi FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++mghi 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 (cc=0) ++mghi 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++mghi 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mghi 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++mghi 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++mghi 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++mghi 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++mghi 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++mghi 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++mghi 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++mghi FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++mghi 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mghi 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++mghi 0000000000000000 * FFFFFFFFFFFF8000 = 00000000000000000000000000000000 (cc=0) ++mghi 0000000000000001 * FFFFFFFFFFFF8000 = FFFFFFFFFFFF80000000000000000001 (cc=0) ++mghi 000000000000FFFF * FFFFFFFFFFFF8000 = FFFFFFFF80008000000000000000FFFF (cc=0) ++mghi 0000000000007FFF * FFFFFFFFFFFF8000 = FFFFFFFFC00080000000000000007FFF (cc=0) ++mghi 0000000000008000 * FFFFFFFFFFFF8000 = FFFFFFFFC00000000000000000008000 (cc=0) ++mghi 00000000FFFFFFFF * FFFFFFFFFFFF8000 = FFFF80000000800000000000FFFFFFFF (cc=0) ++mghi 0000000080000000 * FFFFFFFFFFFF8000 = FFFFC000000000000000000080000000 (cc=0) ++mghi 000000007FFFFFFF * FFFFFFFFFFFF8000 = FFFFC00000008000000000007FFFFFFF (cc=0) ++mghi FFFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 0000000000008000FFFFFFFFFFFFFFFF (cc=0) ++mghi 8000000000000000 * FFFFFFFFFFFF8000 = 00000000000000008000000000000000 (cc=0) ++mghi 7FFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 00000000000080007FFFFFFFFFFFFFFF (cc=0) ++mghi 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mghi 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++mghi 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++mghi 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++mghi 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++mghi 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF (cc=0) ++mghi 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 (cc=0) ++mghi 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF (cc=0) ++mghi FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++mghi 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++mghi 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) +diff --git a/none/tests/s390x/mul_GE.stdout.exp b/none/tests/s390x/mul_GE.stdout.exp +index a94288aa3..32a349bbe 100644 +--- a/none/tests/s390x/mul_GE.stdout.exp ++++ b/none/tests/s390x/mul_GE.stdout.exp +@@ -1,484 +1,484 @@ +-mhy 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mhy 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-mhy 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-mhy 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-mhy 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-mhy 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-mhy 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-mfy 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 +-mfy 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 +-mfy 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 +-mfy 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 +-mfy 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mfy 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 +-mfy 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 +-mfy FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mfy 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mhy 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mhy 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000007FFF0000000000000001 +-mhy 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFE8001000000000000FFFF +-mhy 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000003FFF00010000000000007FFF +-mhy 0000000000008000 * 7FFFFFFFFFFFFFFF = 000000003FFF80000000000000008000 +-mhy 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFF800100000000FFFFFFFF +-mhy 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-mhy 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFF8001000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mfy 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000000000000000007FFFFFFF +-mfy 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF000000007FFF0001 +-mfy 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF000000007FFF8001 +-mfy 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFF00000000FFFF8000 +-mfy 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 +-mfy 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000C00000000000000080000000 +-mfy 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF0000000000000001 +-mfy FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 +-mfy 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 +-mhy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mhy 0000000000000001 * 8000000000000000 = 00000000FFFF80000000000000000001 +-mhy 000000000000FFFF * 8000000000000000 = 0000000080008000000000000000FFFF +-mhy 0000000000007FFF * 8000000000000000 = 00000000C00080000000000000007FFF +-mhy 0000000000008000 * 8000000000000000 = 00000000C00000000000000000008000 +-mhy 00000000FFFFFFFF * 8000000000000000 = 000000000000800000000000FFFFFFFF +-mhy 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 8000000000000000 = 0000000000008000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mfy 0000000000000001 * 8000000000000000 = 00000000FFFFFFFF0000000080000000 +-mfy 000000000000FFFF * 8000000000000000 = 00000000FFFF80000000000080000000 +-mfy 0000000000007FFF * 8000000000000000 = 00000000FFFFC0000000000080000000 +-mfy 0000000000008000 * 8000000000000000 = 00000000FFFFC0000000000000000000 +-mfy 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000080000000 +-mfy 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-mfy 000000007FFFFFFF * 8000000000000000 = 00000000C00000000000000080000000 +-mfy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF80000000 +-mfy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF80000000 +-mhy 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mhy 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 +-mhy 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF +-mhy 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF +-mhy 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-mhy 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF +-mhy 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-mhy 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-mfy 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-mfy 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF +-mfy 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 +-mfy 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 +-mfy 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 +-mfy 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000000000000000000001 +-mfy 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000080000000 +-mfy 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 +-mfy FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 +-mfy 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 +-mhy 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mhy 0000000000000001 * 7FFFFFFF00000000 = 0000000000007FFF0000000000000001 +-mhy 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFE8001000000000000FFFF +-mhy 0000000000007FFF * 7FFFFFFF00000000 = 000000003FFF00010000000000007FFF +-mhy 0000000000008000 * 7FFFFFFF00000000 = 000000003FFF80000000000000008000 +-mhy 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000FFFF800100000000FFFFFFFF +-mhy 0000000080000000 * 7FFFFFFF00000000 = 00000000800000000000000080000000 +-mhy 000000007FFFFFFF * 7FFFFFFF00000000 = 000000007FFF8001000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 +-mfy 0000000000000001 * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF +-mfy 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF000000007FFF0001 +-mfy 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF000000007FFF8001 +-mfy 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFF00000000FFFF8000 +-mfy 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000FFFFFFFF0000000080000001 +-mfy 0000000080000000 * 7FFFFFFF00000000 = 00000000C00000000000000080000000 +-mfy 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000000000001 +-mfy FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFFFFFF80000001 +-mfy 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 +-mhy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mhy 0000000000000001 * 8000000000000000 = 00000000FFFF80000000000000000001 +-mhy 000000000000FFFF * 8000000000000000 = 0000000080008000000000000000FFFF +-mhy 0000000000007FFF * 8000000000000000 = 00000000C00080000000000000007FFF +-mhy 0000000000008000 * 8000000000000000 = 00000000C00000000000000000008000 +-mhy 00000000FFFFFFFF * 8000000000000000 = 000000000000800000000000FFFFFFFF +-mhy 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 8000000000000000 = 0000000000008000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 +-mfy 0000000000000001 * 8000000000000000 = 00000000FFFFFFFF0000000080000000 +-mfy 000000000000FFFF * 8000000000000000 = 00000000FFFF80000000000080000000 +-mfy 0000000000007FFF * 8000000000000000 = 00000000FFFFC0000000000080000000 +-mfy 0000000000008000 * 8000000000000000 = 00000000FFFFC0000000000000000000 +-mfy 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000080000000 +-mfy 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 +-mfy 000000007FFFFFFF * 8000000000000000 = 00000000C00000000000000080000000 +-mfy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF80000000 +-mfy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF80000000 +-mhy 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mhy 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF0000000000000001 +-mhy 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFF0001000000000000FFFF +-mhy 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFF80010000000000007FFF +-mhy 0000000000008000 * FFFFFFFF00000000 = 00000000FFFF80000000000000008000 +-mhy 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000100000000FFFFFFFF +-mhy 0000000080000000 * FFFFFFFF00000000 = 00000000800000000000000080000000 +-mhy 000000007FFFFFFF * FFFFFFFF00000000 = 0000000080000001000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-mfy 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 +-mfy 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFFFFFF +-mfy 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF0001 +-mfy 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF8001 +-mfy 0000000000008000 * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF8000 +-mfy 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000001 +-mfy 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000080000000 +-mfy 000000007FFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFF0000000080000001 +-mfy FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000001 +-mfy 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000001 +-mhy 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mhy 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 +-mhy 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF +-mhy 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF +-mhy 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 +-mhy 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF +-mhy 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mfy 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mfy 000000000000FFFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-mfy 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-mfy 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mfy 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-mfy 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-mfy 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 +-mfy FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 +-mfy 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mhy 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-mhy 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 +-mhy 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF +-mhy 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF +-mhy 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 +-mhy 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF +-mhy 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 +-mfy 0000000000000001 * 0000000080000000 = 00000000000000000000000000000000 +-mfy 000000000000FFFF * 0000000080000000 = 00000000000000000000000000000000 +-mfy 0000000000007FFF * 0000000080000000 = 00000000000000000000000000000000 +-mfy 0000000000008000 * 0000000080000000 = 00000000000000000000000000000000 +-mfy 00000000FFFFFFFF * 0000000080000000 = 00000000000000000000000000000000 +-mfy 0000000080000000 * 0000000080000000 = 00000000000000000000000000000000 +-mfy 000000007FFFFFFF * 0000000080000000 = 00000000000000000000000000000000 +-mfy FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFF00000000 +-mfy 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFF00000000 +-mhy 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mhy 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 +-mhy 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF +-mhy 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF +-mhy 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 +-mhy 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF +-mhy 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mfy 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mfy 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mfy 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mfy 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mfy 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mfy 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mfy 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 +-mfy FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 +-mfy 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mhy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mhy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-mhy 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-mhy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-mhy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-mhy 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-mhy 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-mfy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 +-mfy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 +-mhy 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mhy 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 +-mhy 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF +-mhy 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF +-mhy 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 +-mhy 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF +-mhy 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mfy 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000000 +-mfy 000000000000FFFF * 0000000000007FFF = 00000000000000000000000000000000 +-mfy 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000000000 +-mfy 0000000000008000 * 0000000000007FFF = 00000000000000000000000000000000 +-mfy 00000000FFFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 +-mfy 0000000080000000 * 0000000000007FFF = 00000000000000000000000000000000 +-mfy 000000007FFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 +-mfy FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFF00000000 +-mfy 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFF00000000 +-mhy 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-mhy 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 +-mhy 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF +-mhy 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF +-mhy 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 +-mhy 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF +-mhy 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 +-mfy 0000000000000001 * 0000000000008000 = 00000000000000000000000000000000 +-mfy 000000000000FFFF * 0000000000008000 = 00000000000000000000000000000000 +-mfy 0000000000007FFF * 0000000000008000 = 00000000000000000000000000000000 +-mfy 0000000000008000 * 0000000000008000 = 00000000000000000000000000000000 +-mfy 00000000FFFFFFFF * 0000000000008000 = 00000000000000000000000000000000 +-mfy 0000000080000000 * 0000000000008000 = 00000000000000000000000000000000 +-mfy 000000007FFFFFFF * 0000000000008000 = 00000000000000000000000000000000 +-mfy FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFF00000000 +-mfy 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFF00000000 +-mhy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mhy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 +-mhy 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF +-mhy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF +-mhy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 +-mhy 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF +-mhy 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 +-mhy 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF +-mhy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-mhy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mhy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-mfy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 +-mfy 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 +-mfy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 +-mfy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 +-mfy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 +-MSFI 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-MSFI 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-MSFI 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-MSFI 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-MSFI 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-MSFI 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-MSFI 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-MSFI 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-MSFI FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF +-MSFI 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 +-MSFI 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF +-MSFI 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-MSFI 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 +-MSFI 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF +-MSFI 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF +-MSFI 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 +-MSFI 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF +-MSFI 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 +-MSFI 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF +-MSFI FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF +-MSFI 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-MSFI 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF +-MSFI 0000000000000000 * FFFFFFFFFFFF8000 = 00000000000000000000000000000000 +-MSFI 0000000000000001 * FFFFFFFFFFFF8000 = 00000000FFFF80000000000000000001 +-MSFI 000000000000FFFF * FFFFFFFFFFFF8000 = 0000000080008000000000000000FFFF +-MSFI 0000000000007FFF * FFFFFFFFFFFF8000 = 00000000C00080000000000000007FFF +-MSFI 0000000000008000 * FFFFFFFFFFFF8000 = 00000000C00000000000000000008000 +-MSFI 00000000FFFFFFFF * FFFFFFFFFFFF8000 = 000000000000800000000000FFFFFFFF +-MSFI 0000000080000000 * FFFFFFFFFFFF8000 = 00000000000000000000000080000000 +-MSFI 000000007FFFFFFF * FFFFFFFFFFFF8000 = 0000000000008000000000007FFFFFFF +-MSFI FFFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF +-MSFI 8000000000000000 * FFFFFFFFFFFF8000 = 80000000000000008000000000000000 +-MSFI 7FFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF +-MSFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-MSFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-MSFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-MSFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-MSFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-MSFI 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF +-MSFI 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 +-MSFI 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF +-MSFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-MSFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-MSFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-MSFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-MSFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-MSFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-MSFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-MSFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-MSFI 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF +-MSFI 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 +-MSFI 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF +-MSFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-MSFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-MSFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-MSFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-MSFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-MSFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-MSFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-MSFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-MSFI 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF +-MSFI 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 +-MSFI 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF +-MSFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-MSFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-MSFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-MSFI 0000000000000000 * FFFFFFFF80000000 = 00000000000000000000000000000000 +-MSFI 0000000000000001 * FFFFFFFF80000000 = 00000000800000000000000000000001 +-MSFI 000000000000FFFF * FFFFFFFF80000000 = 0000000080000000000000000000FFFF +-MSFI 0000000000007FFF * FFFFFFFF80000000 = 00000000800000000000000000007FFF +-MSFI 0000000000008000 * FFFFFFFF80000000 = 00000000000000000000000000008000 +-MSFI 00000000FFFFFFFF * FFFFFFFF80000000 = 000000008000000000000000FFFFFFFF +-MSFI 0000000080000000 * FFFFFFFF80000000 = 00000000000000000000000080000000 +-MSFI 000000007FFFFFFF * FFFFFFFF80000000 = 0000000080000000000000007FFFFFFF +-MSFI FFFFFFFFFFFFFFFF * FFFFFFFF80000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF +-MSFI 8000000000000000 * FFFFFFFF80000000 = 80000000000000008000000000000000 +-MSFI 7FFFFFFFFFFFFFFF * FFFFFFFF80000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF +-MSFI 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-MSFI 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 +-MSFI 000000000000FFFF * 000000007FFFFFFF = 000000007FFF0001000000000000FFFF +-MSFI 0000000000007FFF * 000000007FFFFFFF = 000000007FFF80010000000000007FFF +-MSFI 0000000000008000 * 000000007FFFFFFF = 00000000FFFF80000000000000008000 +-MSFI 00000000FFFFFFFF * 000000007FFFFFFF = 000000008000000100000000FFFFFFFF +-MSFI 0000000080000000 * 000000007FFFFFFF = 00000000800000000000000080000000 +-MSFI 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000001000000007FFFFFFF +-MSFI FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-MSFI 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-MSFI 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF +-MSGFI 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 +-MSGFI 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 +-MSGFI 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF +-MSGFI 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF +-MSGFI 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 +-MSGFI 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF +-MSGFI 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 +-MSGFI 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF +-MSGFI FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF +-MSGFI 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 +-MSGFI 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF +-MSGFI 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 +-MSGFI 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 +-MSGFI 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF +-MSGFI 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF +-MSGFI 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 +-MSGFI 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF +-MSGFI 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 +-MSGFI 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF +-MSGFI FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF +-MSGFI 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 +-MSGFI 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF +-MSGFI 0000000000000000 * FFFFFFFFFFFF8000 = 00000000000000000000000000000000 +-MSGFI 0000000000000001 * FFFFFFFFFFFF8000 = FFFFFFFFFFFF80000000000000000001 +-MSGFI 000000000000FFFF * FFFFFFFFFFFF8000 = FFFFFFFF80008000000000000000FFFF +-MSGFI 0000000000007FFF * FFFFFFFFFFFF8000 = FFFFFFFFC00080000000000000007FFF +-MSGFI 0000000000008000 * FFFFFFFFFFFF8000 = FFFFFFFFC00000000000000000008000 +-MSGFI 00000000FFFFFFFF * FFFFFFFFFFFF8000 = FFFF80000000800000000000FFFFFFFF +-MSGFI 0000000080000000 * FFFFFFFFFFFF8000 = FFFFC000000000000000000080000000 +-MSGFI 000000007FFFFFFF * FFFFFFFFFFFF8000 = FFFFC00000008000000000007FFFFFFF +-MSGFI FFFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 0000000000008000FFFFFFFFFFFFFFFF +-MSGFI 8000000000000000 * FFFFFFFFFFFF8000 = 00000000000000008000000000000000 +-MSGFI 7FFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 00000000000080007FFFFFFFFFFFFFFF +-MSGFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-MSGFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-MSGFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-MSGFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-MSGFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-MSGFI 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF +-MSGFI 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 +-MSGFI 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF +-MSGFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-MSGFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-MSGFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-MSGFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-MSGFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-MSGFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-MSGFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-MSGFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-MSGFI 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF +-MSGFI 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 +-MSGFI 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF +-MSGFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-MSGFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-MSGFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-MSGFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 +-MSGFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 +-MSGFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF +-MSGFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF +-MSGFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 +-MSGFI 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF +-MSGFI 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 +-MSGFI 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF +-MSGFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF +-MSGFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 +-MSGFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF +-MSGFI 0000000000000000 * FFFFFFFF80000000 = 00000000000000000000000000000000 +-MSGFI 0000000000000001 * FFFFFFFF80000000 = FFFFFFFF800000000000000000000001 +-MSGFI 000000000000FFFF * FFFFFFFF80000000 = FFFF800080000000000000000000FFFF +-MSGFI 0000000000007FFF * FFFFFFFF80000000 = FFFFC000800000000000000000007FFF +-MSGFI 0000000000008000 * FFFFFFFF80000000 = FFFFC000000000000000000000008000 +-MSGFI 00000000FFFFFFFF * FFFFFFFF80000000 = 800000008000000000000000FFFFFFFF +-MSGFI 0000000080000000 * FFFFFFFF80000000 = C0000000000000000000000080000000 +-MSGFI 000000007FFFFFFF * FFFFFFFF80000000 = C000000080000000000000007FFFFFFF +-MSGFI FFFFFFFFFFFFFFFF * FFFFFFFF80000000 = 0000000080000000FFFFFFFFFFFFFFFF +-MSGFI 8000000000000000 * FFFFFFFF80000000 = 00000000000000008000000000000000 +-MSGFI 7FFFFFFFFFFFFFFF * FFFFFFFF80000000 = 00000000800000007FFFFFFFFFFFFFFF +-MSGFI 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 +-MSGFI 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 +-MSGFI 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF0001000000000000FFFF +-MSGFI 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000007FFF +-MSGFI 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000008000 +-MSGFI 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF +-MSGFI 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000080000000 +-MSGFI 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF00000001000000007FFFFFFF +-MSGFI FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF +-MSGFI 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 +-MSGFI 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF ++mhy 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++mhy 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++mhy 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy 000000000000FFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000007FFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000008000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000080000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mfy 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mhy 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000007FFF0000000000000001 (cc=0) ++mhy 000000000000FFFF * 7FFFFFFFFFFFFFFF = 000000007FFE8001000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 7FFFFFFFFFFFFFFF = 000000003FFF00010000000000007FFF (cc=0) ++mhy 0000000000008000 * 7FFFFFFFFFFFFFFF = 000000003FFF80000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFF800100000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000007FFF8001000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 7FFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 7FFFFFFFFFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mfy 000000000000FFFF * 7FFFFFFFFFFFFFFF = 0000000000007FFF000000007FFF0001 (cc=0) ++mfy 0000000000007FFF * 7FFFFFFFFFFFFFFF = 0000000000003FFF000000007FFF8001 (cc=0) ++mfy 0000000000008000 * 7FFFFFFFFFFFFFFF = 0000000000003FFF00000000FFFF8000 (cc=0) ++mfy 00000000FFFFFFFF * 7FFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 (cc=0) ++mfy 0000000080000000 * 7FFFFFFFFFFFFFFF = 00000000C00000000000000080000000 (cc=0) ++mfy 000000007FFFFFFF * 7FFFFFFFFFFFFFFF = 000000003FFFFFFF0000000000000001 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFFFFFFFFFF80000001 (cc=0) ++mfy 8000000000000000 * 7FFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 7FFFFFFFFFFFFFFF = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 (cc=0) ++mhy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 8000000000000000 = 00000000FFFF80000000000000000001 (cc=0) ++mhy 000000000000FFFF * 8000000000000000 = 0000000080008000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 8000000000000000 = 00000000C00080000000000000007FFF (cc=0) ++mhy 0000000000008000 * 8000000000000000 = 00000000C00000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 8000000000000000 = 000000000000800000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 8000000000000000 = 0000000000008000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 8000000000000000 = 00000000FFFFFFFF0000000080000000 (cc=0) ++mfy 000000000000FFFF * 8000000000000000 = 00000000FFFF80000000000080000000 (cc=0) ++mfy 0000000000007FFF * 8000000000000000 = 00000000FFFFC0000000000080000000 (cc=0) ++mfy 0000000000008000 * 8000000000000000 = 00000000FFFFC0000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++mfy 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 8000000000000000 = 00000000C00000000000000080000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF80000000 (cc=0) ++mfy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF80000000 (cc=0) ++mhy 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++mhy 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=0) ++mhy 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF (cc=0) ++mhy 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFFFFFF (cc=0) ++mfy 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF0001 (cc=0) ++mfy 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8001 (cc=0) ++mfy 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF00000000FFFF8000 (cc=0) ++mfy 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 00000000000000000000000000000001 (cc=0) ++mfy 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000080000000 (cc=0) ++mfy 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000080000001 (cc=0) ++mfy FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000000FFFFFFFF00000001 (cc=0) ++mfy 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000007FFFFFFF00000001 (cc=0) ++mhy 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 7FFFFFFF00000000 = 0000000000007FFF0000000000000001 (cc=0) ++mhy 000000000000FFFF * 7FFFFFFF00000000 = 000000007FFE8001000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 7FFFFFFF00000000 = 000000003FFF00010000000000007FFF (cc=0) ++mhy 0000000000008000 * 7FFFFFFF00000000 = 000000003FFF80000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000FFFF800100000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 7FFFFFFF00000000 = 00000000800000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 7FFFFFFF00000000 = 000000007FFF8001000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 7FFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 7FFFFFFF00000000 = 0000000000000000000000007FFFFFFF (cc=0) ++mfy 000000000000FFFF * 7FFFFFFF00000000 = 0000000000007FFF000000007FFF0001 (cc=0) ++mfy 0000000000007FFF * 7FFFFFFF00000000 = 0000000000003FFF000000007FFF8001 (cc=0) ++mfy 0000000000008000 * 7FFFFFFF00000000 = 0000000000003FFF00000000FFFF8000 (cc=0) ++mfy 00000000FFFFFFFF * 7FFFFFFF00000000 = 00000000FFFFFFFF0000000080000001 (cc=0) ++mfy 0000000080000000 * 7FFFFFFF00000000 = 00000000C00000000000000080000000 (cc=0) ++mfy 000000007FFFFFFF * 7FFFFFFF00000000 = 000000003FFFFFFF0000000000000001 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 7FFFFFFF00000000 = FFFFFFFFFFFFFFFFFFFFFFFF80000001 (cc=0) ++mfy 8000000000000000 * 7FFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 7FFFFFFF00000000 = 7FFFFFFFFFFFFFFF7FFFFFFF80000001 (cc=0) ++mhy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 8000000000000000 = 00000000FFFF80000000000000000001 (cc=0) ++mhy 000000000000FFFF * 8000000000000000 = 0000000080008000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 8000000000000000 = 00000000C00080000000000000007FFF (cc=0) ++mhy 0000000000008000 * 8000000000000000 = 00000000C00000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 8000000000000000 = 000000000000800000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 8000000000000000 = 0000000000008000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 8000000000000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 8000000000000000 = 00000000FFFFFFFF0000000080000000 (cc=0) ++mfy 000000000000FFFF * 8000000000000000 = 00000000FFFF80000000000080000000 (cc=0) ++mfy 0000000000007FFF * 8000000000000000 = 00000000FFFFC0000000000080000000 (cc=0) ++mfy 0000000000008000 * 8000000000000000 = 00000000FFFFC0000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 8000000000000000 = 00000000000000000000000080000000 (cc=0) ++mfy 0000000080000000 * 8000000000000000 = 00000000400000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 8000000000000000 = 00000000C00000000000000080000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 8000000000000000 = FFFFFFFF00000000FFFFFFFF80000000 (cc=0) ++mfy 8000000000000000 * 8000000000000000 = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 8000000000000000 = 7FFFFFFF000000007FFFFFFF80000000 (cc=0) ++mhy 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF0000000000000001 (cc=0) ++mhy 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFF0001000000000000FFFF (cc=0) ++mhy 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFF80010000000000007FFF (cc=0) ++mhy 0000000000008000 * FFFFFFFF00000000 = 00000000FFFF80000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * FFFFFFFF00000000 = 000000000000000100000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * FFFFFFFF00000000 = 00000000800000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * FFFFFFFF00000000 = 0000000080000001000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * FFFFFFFF00000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFFFFFF (cc=0) ++mfy 000000000000FFFF * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF0001 (cc=0) ++mfy 0000000000007FFF * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF8001 (cc=0) ++mfy 0000000000008000 * FFFFFFFF00000000 = 00000000FFFFFFFF00000000FFFF8000 (cc=0) ++mfy 00000000FFFFFFFF * FFFFFFFF00000000 = 00000000000000000000000000000001 (cc=0) ++mfy 0000000080000000 * FFFFFFFF00000000 = 00000000000000000000000080000000 (cc=0) ++mfy 000000007FFFFFFF * FFFFFFFF00000000 = 00000000FFFFFFFF0000000080000001 (cc=0) ++mfy FFFFFFFFFFFFFFFF * FFFFFFFF00000000 = FFFFFFFF00000000FFFFFFFF00000001 (cc=0) ++mfy 8000000000000000 * FFFFFFFF00000000 = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * FFFFFFFF00000000 = 7FFFFFFF000000007FFFFFFF00000001 (cc=0) ++mhy 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000001 (cc=0) ++mhy 000000000000FFFF * 000000007FFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000007FFF (cc=0) ++mhy 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 000000007FFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000000000FFFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000007FFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000008000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000080000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mfy 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mhy 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 0000000080000000 = 00000000000000000000000000000001 (cc=0) ++mhy 000000000000FFFF * 0000000080000000 = 0000000000000000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 0000000080000000 = 00000000000000000000000000007FFF (cc=0) ++mhy 0000000000008000 * 0000000080000000 = 00000000000000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 0000000080000000 = 000000000000000000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 0000000080000000 = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 0000000080000000 = 0000000000000000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mfy 000000000000FFFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000007FFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000008000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000080000000 * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 0000000080000000 = 00000000000000000000000000000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 0000000080000000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mfy 8000000000000000 * 0000000080000000 = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 0000000080000000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mhy 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000001 (cc=0) ++mhy 000000000000FFFF * 00000000FFFFFFFF = 0000000000000000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000007FFF (cc=0) ++mhy 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 00000000FFFFFFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 00000000FFFFFFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000000000FFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000007FFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000008000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000080000000 * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 00000000FFFFFFFF = 00000000000000000000000000000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 00000000FFFFFFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mfy 8000000000000000 * 00000000FFFFFFFF = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 00000000FFFFFFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mhy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++mhy 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++mhy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mfy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mhy 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000001 (cc=0) ++mhy 000000000000FFFF * 0000000000007FFF = 0000000000000000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000007FFF (cc=0) ++mhy 0000000000008000 * 0000000000007FFF = 00000000000000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 0000000000007FFF = 000000000000000000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 0000000000007FFF = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 0000000000007FFF = 0000000000000000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000000000FFFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000007FFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000008000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000080000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mfy 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mhy 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 0000000000008000 = 00000000000000000000000000000001 (cc=0) ++mhy 000000000000FFFF * 0000000000008000 = 0000000000000000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 0000000000008000 = 00000000000000000000000000007FFF (cc=0) ++mhy 0000000000008000 * 0000000000008000 = 00000000000000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 0000000000008000 = 000000000000000000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 0000000000008000 = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 0000000000008000 = 0000000000000000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mfy 000000000000FFFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000007FFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000008000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mfy 0000000080000000 * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 0000000000008000 = 00000000000000000000000000000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 0000000000008000 = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mfy 8000000000000000 * 0000000000008000 = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 0000000000008000 = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++mhy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mhy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000001 (cc=0) ++mhy 000000000000FFFF * 000000000000FFFF = 0000000000000000000000000000FFFF (cc=0) ++mhy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000007FFF (cc=0) ++mhy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000008000 (cc=0) ++mhy 00000000FFFFFFFF * 000000000000FFFF = 000000000000000000000000FFFFFFFF (cc=0) ++mhy 0000000080000000 * 000000000000FFFF = 00000000000000000000000080000000 (cc=0) ++mhy 000000007FFFFFFF * 000000000000FFFF = 0000000000000000000000007FFFFFFF (cc=0) ++mhy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++mhy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mhy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++mfy 0000000000000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000000001 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000000000FFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000007FFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000000008000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 00000000FFFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 0000000080000000 * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy 000000007FFFFFFF * 000000000000FFFF = 00000000000000000000000000000000 (cc=0) ++mfy FFFFFFFFFFFFFFFF * 000000000000FFFF = FFFFFFFF00000000FFFFFFFF00000000 (cc=0) ++mfy 8000000000000000 * 000000000000FFFF = 80000000000000008000000000000000 (cc=0) ++mfy 7FFFFFFFFFFFFFFF * 000000000000FFFF = 7FFFFFFF000000007FFFFFFF00000000 (cc=0) ++MSFI 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++MSFI 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++MSFI 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++MSFI 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++MSFI 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++MSFI 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++MSFI 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++MSFI 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++MSFI FFFFFFFFFFFFFFFF * 0000000000000000 = FFFFFFFF00000000FFFFFFFFFFFFFFFF (cc=0) ++MSFI 8000000000000000 * 0000000000000000 = 80000000000000008000000000000000 (cc=0) ++MSFI 7FFFFFFFFFFFFFFF * 0000000000000000 = 7FFFFFFF000000007FFFFFFFFFFFFFFF (cc=0) ++MSFI 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++MSFI 0000000000000001 * FFFFFFFFFFFFFFFF = 00000000FFFFFFFF0000000000000001 (cc=0) ++MSFI 000000000000FFFF * FFFFFFFFFFFFFFFF = 00000000FFFF0001000000000000FFFF (cc=0) ++MSFI 0000000000007FFF * FFFFFFFFFFFFFFFF = 00000000FFFF80010000000000007FFF (cc=0) ++MSFI 0000000000008000 * FFFFFFFFFFFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++MSFI 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = 000000000000000100000000FFFFFFFF (cc=0) ++MSFI 0000000080000000 * FFFFFFFFFFFFFFFF = 00000000800000000000000080000000 (cc=0) ++MSFI 000000007FFFFFFF * FFFFFFFFFFFFFFFF = 0000000080000001000000007FFFFFFF (cc=0) ++MSFI FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF00000001FFFFFFFFFFFFFFFF (cc=0) ++MSFI 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++MSFI 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 7FFFFFFF000000017FFFFFFFFFFFFFFF (cc=0) ++MSFI 0000000000000000 * FFFFFFFFFFFF8000 = 00000000000000000000000000000000 (cc=0) ++MSFI 0000000000000001 * FFFFFFFFFFFF8000 = 00000000FFFF80000000000000000001 (cc=0) ++MSFI 000000000000FFFF * FFFFFFFFFFFF8000 = 0000000080008000000000000000FFFF (cc=0) ++MSFI 0000000000007FFF * FFFFFFFFFFFF8000 = 00000000C00080000000000000007FFF (cc=0) ++MSFI 0000000000008000 * FFFFFFFFFFFF8000 = 00000000C00000000000000000008000 (cc=0) ++MSFI 00000000FFFFFFFF * FFFFFFFFFFFF8000 = 000000000000800000000000FFFFFFFF (cc=0) ++MSFI 0000000080000000 * FFFFFFFFFFFF8000 = 00000000000000000000000080000000 (cc=0) ++MSFI 000000007FFFFFFF * FFFFFFFFFFFF8000 = 0000000000008000000000007FFFFFFF (cc=0) ++MSFI FFFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = FFFFFFFF00008000FFFFFFFFFFFFFFFF (cc=0) ++MSFI 8000000000000000 * FFFFFFFFFFFF8000 = 80000000000000008000000000000000 (cc=0) ++MSFI 7FFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 7FFFFFFF000080007FFFFFFFFFFFFFFF (cc=0) ++MSFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++MSFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++MSFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++MSFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++MSFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++MSFI 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF (cc=0) ++MSFI 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 (cc=0) ++MSFI 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF (cc=0) ++MSFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++MSFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++MSFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++MSFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++MSFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++MSFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++MSFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++MSFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++MSFI 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF (cc=0) ++MSFI 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 (cc=0) ++MSFI 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF (cc=0) ++MSFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++MSFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++MSFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++MSFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++MSFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++MSFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++MSFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++MSFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++MSFI 00000000FFFFFFFF * 0000000000007FFF = 00000000FFFF800100000000FFFFFFFF (cc=0) ++MSFI 0000000080000000 * 0000000000007FFF = 00000000800000000000000080000000 (cc=0) ++MSFI 000000007FFFFFFF * 0000000000007FFF = 000000007FFF8001000000007FFFFFFF (cc=0) ++MSFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++MSFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++MSFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++MSFI 0000000000000000 * FFFFFFFF80000000 = 00000000000000000000000000000000 (cc=0) ++MSFI 0000000000000001 * FFFFFFFF80000000 = 00000000800000000000000000000001 (cc=0) ++MSFI 000000000000FFFF * FFFFFFFF80000000 = 0000000080000000000000000000FFFF (cc=0) ++MSFI 0000000000007FFF * FFFFFFFF80000000 = 00000000800000000000000000007FFF (cc=0) ++MSFI 0000000000008000 * FFFFFFFF80000000 = 00000000000000000000000000008000 (cc=0) ++MSFI 00000000FFFFFFFF * FFFFFFFF80000000 = 000000008000000000000000FFFFFFFF (cc=0) ++MSFI 0000000080000000 * FFFFFFFF80000000 = 00000000000000000000000080000000 (cc=0) ++MSFI 000000007FFFFFFF * FFFFFFFF80000000 = 0000000080000000000000007FFFFFFF (cc=0) ++MSFI FFFFFFFFFFFFFFFF * FFFFFFFF80000000 = FFFFFFFF80000000FFFFFFFFFFFFFFFF (cc=0) ++MSFI 8000000000000000 * FFFFFFFF80000000 = 80000000000000008000000000000000 (cc=0) ++MSFI 7FFFFFFFFFFFFFFF * FFFFFFFF80000000 = 7FFFFFFF800000007FFFFFFFFFFFFFFF (cc=0) ++MSFI 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++MSFI 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 (cc=0) ++MSFI 000000000000FFFF * 000000007FFFFFFF = 000000007FFF0001000000000000FFFF (cc=0) ++MSFI 0000000000007FFF * 000000007FFFFFFF = 000000007FFF80010000000000007FFF (cc=0) ++MSFI 0000000000008000 * 000000007FFFFFFF = 00000000FFFF80000000000000008000 (cc=0) ++MSFI 00000000FFFFFFFF * 000000007FFFFFFF = 000000008000000100000000FFFFFFFF (cc=0) ++MSFI 0000000080000000 * 000000007FFFFFFF = 00000000800000000000000080000000 (cc=0) ++MSFI 000000007FFFFFFF * 000000007FFFFFFF = 0000000000000001000000007FFFFFFF (cc=0) ++MSFI FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++MSFI 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++MSFI 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) ++MSGFI 0000000000000000 * 0000000000000000 = 00000000000000000000000000000000 (cc=0) ++MSGFI 0000000000000001 * 0000000000000000 = 00000000000000000000000000000001 (cc=0) ++MSGFI 000000000000FFFF * 0000000000000000 = 0000000000000000000000000000FFFF (cc=0) ++MSGFI 0000000000007FFF * 0000000000000000 = 00000000000000000000000000007FFF (cc=0) ++MSGFI 0000000000008000 * 0000000000000000 = 00000000000000000000000000008000 (cc=0) ++MSGFI 00000000FFFFFFFF * 0000000000000000 = 000000000000000000000000FFFFFFFF (cc=0) ++MSGFI 0000000080000000 * 0000000000000000 = 00000000000000000000000080000000 (cc=0) ++MSGFI 000000007FFFFFFF * 0000000000000000 = 0000000000000000000000007FFFFFFF (cc=0) ++MSGFI FFFFFFFFFFFFFFFF * 0000000000000000 = 0000000000000000FFFFFFFFFFFFFFFF (cc=0) ++MSGFI 8000000000000000 * 0000000000000000 = 00000000000000008000000000000000 (cc=0) ++MSGFI 7FFFFFFFFFFFFFFF * 0000000000000000 = 00000000000000007FFFFFFFFFFFFFFF (cc=0) ++MSGFI 0000000000000000 * FFFFFFFFFFFFFFFF = 00000000000000000000000000000000 (cc=0) ++MSGFI 0000000000000001 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFFFFFF0000000000000001 (cc=0) ++MSGFI 000000000000FFFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF0001000000000000FFFF (cc=0) ++MSGFI 0000000000007FFF * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80010000000000007FFF (cc=0) ++MSGFI 0000000000008000 * FFFFFFFFFFFFFFFF = FFFFFFFFFFFF80000000000000008000 (cc=0) ++MSGFI 00000000FFFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF0000000100000000FFFFFFFF (cc=0) ++MSGFI 0000000080000000 * FFFFFFFFFFFFFFFF = FFFFFFFF800000000000000080000000 (cc=0) ++MSGFI 000000007FFFFFFF * FFFFFFFFFFFFFFFF = FFFFFFFF80000001000000007FFFFFFF (cc=0) ++MSGFI FFFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 0000000000000001FFFFFFFFFFFFFFFF (cc=0) ++MSGFI 8000000000000000 * FFFFFFFFFFFFFFFF = 80000000000000008000000000000000 (cc=0) ++MSGFI 7FFFFFFFFFFFFFFF * FFFFFFFFFFFFFFFF = 80000000000000017FFFFFFFFFFFFFFF (cc=0) ++MSGFI 0000000000000000 * FFFFFFFFFFFF8000 = 00000000000000000000000000000000 (cc=0) ++MSGFI 0000000000000001 * FFFFFFFFFFFF8000 = FFFFFFFFFFFF80000000000000000001 (cc=0) ++MSGFI 000000000000FFFF * FFFFFFFFFFFF8000 = FFFFFFFF80008000000000000000FFFF (cc=0) ++MSGFI 0000000000007FFF * FFFFFFFFFFFF8000 = FFFFFFFFC00080000000000000007FFF (cc=0) ++MSGFI 0000000000008000 * FFFFFFFFFFFF8000 = FFFFFFFFC00000000000000000008000 (cc=0) ++MSGFI 00000000FFFFFFFF * FFFFFFFFFFFF8000 = FFFF80000000800000000000FFFFFFFF (cc=0) ++MSGFI 0000000080000000 * FFFFFFFFFFFF8000 = FFFFC000000000000000000080000000 (cc=0) ++MSGFI 000000007FFFFFFF * FFFFFFFFFFFF8000 = FFFFC00000008000000000007FFFFFFF (cc=0) ++MSGFI FFFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 0000000000008000FFFFFFFFFFFFFFFF (cc=0) ++MSGFI 8000000000000000 * FFFFFFFFFFFF8000 = 00000000000000008000000000000000 (cc=0) ++MSGFI 7FFFFFFFFFFFFFFF * FFFFFFFFFFFF8000 = 00000000000080007FFFFFFFFFFFFFFF (cc=0) ++MSGFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++MSGFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++MSGFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++MSGFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++MSGFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++MSGFI 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF (cc=0) ++MSGFI 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 (cc=0) ++MSGFI 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF (cc=0) ++MSGFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++MSGFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++MSGFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++MSGFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++MSGFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++MSGFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++MSGFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++MSGFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++MSGFI 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF (cc=0) ++MSGFI 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 (cc=0) ++MSGFI 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF (cc=0) ++MSGFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++MSGFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++MSGFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++MSGFI 0000000000000000 * 0000000000007FFF = 00000000000000000000000000000000 (cc=0) ++MSGFI 0000000000000001 * 0000000000007FFF = 0000000000007FFF0000000000000001 (cc=0) ++MSGFI 000000000000FFFF * 0000000000007FFF = 000000007FFE8001000000000000FFFF (cc=0) ++MSGFI 0000000000007FFF * 0000000000007FFF = 000000003FFF00010000000000007FFF (cc=0) ++MSGFI 0000000000008000 * 0000000000007FFF = 000000003FFF80000000000000008000 (cc=0) ++MSGFI 00000000FFFFFFFF * 0000000000007FFF = 00007FFEFFFF800100000000FFFFFFFF (cc=0) ++MSGFI 0000000080000000 * 0000000000007FFF = 00003FFF800000000000000080000000 (cc=0) ++MSGFI 000000007FFFFFFF * 0000000000007FFF = 00003FFF7FFF8001000000007FFFFFFF (cc=0) ++MSGFI FFFFFFFFFFFFFFFF * 0000000000007FFF = FFFFFFFFFFFF8001FFFFFFFFFFFFFFFF (cc=0) ++MSGFI 8000000000000000 * 0000000000007FFF = 80000000000000008000000000000000 (cc=0) ++MSGFI 7FFFFFFFFFFFFFFF * 0000000000007FFF = 7FFFFFFFFFFF80017FFFFFFFFFFFFFFF (cc=0) ++MSGFI 0000000000000000 * FFFFFFFF80000000 = 00000000000000000000000000000000 (cc=0) ++MSGFI 0000000000000001 * FFFFFFFF80000000 = FFFFFFFF800000000000000000000001 (cc=0) ++MSGFI 000000000000FFFF * FFFFFFFF80000000 = FFFF800080000000000000000000FFFF (cc=0) ++MSGFI 0000000000007FFF * FFFFFFFF80000000 = FFFFC000800000000000000000007FFF (cc=0) ++MSGFI 0000000000008000 * FFFFFFFF80000000 = FFFFC000000000000000000000008000 (cc=0) ++MSGFI 00000000FFFFFFFF * FFFFFFFF80000000 = 800000008000000000000000FFFFFFFF (cc=0) ++MSGFI 0000000080000000 * FFFFFFFF80000000 = C0000000000000000000000080000000 (cc=0) ++MSGFI 000000007FFFFFFF * FFFFFFFF80000000 = C000000080000000000000007FFFFFFF (cc=0) ++MSGFI FFFFFFFFFFFFFFFF * FFFFFFFF80000000 = 0000000080000000FFFFFFFFFFFFFFFF (cc=0) ++MSGFI 8000000000000000 * FFFFFFFF80000000 = 00000000000000008000000000000000 (cc=0) ++MSGFI 7FFFFFFFFFFFFFFF * FFFFFFFF80000000 = 00000000800000007FFFFFFFFFFFFFFF (cc=0) ++MSGFI 0000000000000000 * 000000007FFFFFFF = 00000000000000000000000000000000 (cc=0) ++MSGFI 0000000000000001 * 000000007FFFFFFF = 000000007FFFFFFF0000000000000001 (cc=0) ++MSGFI 000000000000FFFF * 000000007FFFFFFF = 00007FFF7FFF0001000000000000FFFF (cc=0) ++MSGFI 0000000000007FFF * 000000007FFFFFFF = 00003FFF7FFF80010000000000007FFF (cc=0) ++MSGFI 0000000000008000 * 000000007FFFFFFF = 00003FFFFFFF80000000000000008000 (cc=0) ++MSGFI 00000000FFFFFFFF * 000000007FFFFFFF = 7FFFFFFE8000000100000000FFFFFFFF (cc=0) ++MSGFI 0000000080000000 * 000000007FFFFFFF = 3FFFFFFF800000000000000080000000 (cc=0) ++MSGFI 000000007FFFFFFF * 000000007FFFFFFF = 3FFFFFFF00000001000000007FFFFFFF (cc=0) ++MSGFI FFFFFFFFFFFFFFFF * 000000007FFFFFFF = FFFFFFFF80000001FFFFFFFFFFFFFFFF (cc=0) ++MSGFI 8000000000000000 * 000000007FFFFFFF = 80000000000000008000000000000000 (cc=0) ++MSGFI 7FFFFFFFFFFFFFFF * 000000007FFFFFFF = 7FFFFFFF800000017FFFFFFFFFFFFFFF (cc=0) +diff --git a/none/tests/s390x/sub-z14.c b/none/tests/s390x/sub-z14.c +new file mode 100644 +index 000000000..de0a72fb0 +--- /dev/null ++++ b/none/tests/s390x/sub-z14.c +@@ -0,0 +1,13 @@ ++#include "sub.h" ++ ++#define sgh(x, y) ".insn rxy,0xe30000000039, " x ", " y "\n" ++ ++static void do_regmem_insns(unsigned long m2) ++{ ++ memsweep(sgh, m2, 0); ++} ++ ++int main() ++{ ++ for_each_m2(do_regmem_insns); ++} +diff --git a/none/tests/s390x/sub-z14.stderr.exp b/none/tests/s390x/sub-z14.stderr.exp +new file mode 100644 +index 000000000..139597f9c +--- /dev/null ++++ b/none/tests/s390x/sub-z14.stderr.exp +@@ -0,0 +1,2 @@ ++ ++ +diff --git a/none/tests/s390x/sub-z14.stdout.exp b/none/tests/s390x/sub-z14.stdout.exp +new file mode 100644 +index 000000000..d6dd55ed1 +--- /dev/null ++++ b/none/tests/s390x/sub-z14.stdout.exp +@@ -0,0 +1,154 @@ ++sgh 0000000000000000 - 0000000000000000 - 1 = 0000000000000000 (cc=0) ++sgh 0000000000000001 - 0000000000000000 - 1 = 0000000000000001 (cc=2) ++sgh 000000000000FFFF - 0000000000000000 - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000007FFF - 0000000000000000 - 1 = 0000000000007FFF (cc=2) ++sgh 0000000000008000 - 0000000000000000 - 1 = 0000000000008000 (cc=2) ++sgh 00000000FFFFFFFF - 0000000000000000 - 1 = 00000000FFFFFFFF (cc=2) ++sgh 0000000080000000 - 0000000000000000 - 1 = 0000000080000000 (cc=2) ++sgh 000000007FFFFFFF - 0000000000000000 - 1 = 000000007FFFFFFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 0000000000000000 - 1 = FFFFFFFFFFFFFFFF (cc=1) ++sgh 8000000000000000 - 0000000000000000 - 1 = 8000000000000000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 0000000000000000 - 1 = 7FFFFFFFFFFFFFFF (cc=2) ++sgh 0000000000000000 - 7FFFFFFFFFFFFFFF - 1 = FFFFFFFFFFFF8001 (cc=1) ++sgh 0000000000000001 - 7FFFFFFFFFFFFFFF - 1 = FFFFFFFFFFFF8002 (cc=1) ++sgh 000000000000FFFF - 7FFFFFFFFFFFFFFF - 1 = 0000000000008000 (cc=2) ++sgh 0000000000007FFF - 7FFFFFFFFFFFFFFF - 1 = 0000000000000000 (cc=0) ++sgh 0000000000008000 - 7FFFFFFFFFFFFFFF - 1 = 0000000000000001 (cc=2) ++sgh 00000000FFFFFFFF - 7FFFFFFFFFFFFFFF - 1 = 00000000FFFF8000 (cc=2) ++sgh 0000000080000000 - 7FFFFFFFFFFFFFFF - 1 = 000000007FFF8001 (cc=2) ++sgh 000000007FFFFFFF - 7FFFFFFFFFFFFFFF - 1 = 000000007FFF8000 (cc=2) ++sgh FFFFFFFFFFFFFFFF - 7FFFFFFFFFFFFFFF - 1 = FFFFFFFFFFFF8000 (cc=1) ++sgh 8000000000000000 - 7FFFFFFFFFFFFFFF - 1 = 7FFFFFFFFFFF8001 (cc=3) ++sgh 7FFFFFFFFFFFFFFF - 7FFFFFFFFFFFFFFF - 1 = 7FFFFFFFFFFF8000 (cc=2) ++sgh 0000000000000000 - 8000000000000000 - 1 = 0000000000008000 (cc=2) ++sgh 0000000000000001 - 8000000000000000 - 1 = 0000000000008001 (cc=2) ++sgh 000000000000FFFF - 8000000000000000 - 1 = 0000000000017FFF (cc=2) ++sgh 0000000000007FFF - 8000000000000000 - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000008000 - 8000000000000000 - 1 = 0000000000010000 (cc=2) ++sgh 00000000FFFFFFFF - 8000000000000000 - 1 = 0000000100007FFF (cc=2) ++sgh 0000000080000000 - 8000000000000000 - 1 = 0000000080008000 (cc=2) ++sgh 000000007FFFFFFF - 8000000000000000 - 1 = 0000000080007FFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 8000000000000000 - 1 = 0000000000007FFF (cc=2) ++sgh 8000000000000000 - 8000000000000000 - 1 = 8000000000008000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 8000000000000000 - 1 = 8000000000007FFF (cc=3) ++sgh 0000000000000000 - FFFFFFFFFFFFFFFF - 1 = 0000000000000001 (cc=2) ++sgh 0000000000000001 - FFFFFFFFFFFFFFFF - 1 = 0000000000000002 (cc=2) ++sgh 000000000000FFFF - FFFFFFFFFFFFFFFF - 1 = 0000000000010000 (cc=2) ++sgh 0000000000007FFF - FFFFFFFFFFFFFFFF - 1 = 0000000000008000 (cc=2) ++sgh 0000000000008000 - FFFFFFFFFFFFFFFF - 1 = 0000000000008001 (cc=2) ++sgh 00000000FFFFFFFF - FFFFFFFFFFFFFFFF - 1 = 0000000100000000 (cc=2) ++sgh 0000000080000000 - FFFFFFFFFFFFFFFF - 1 = 0000000080000001 (cc=2) ++sgh 000000007FFFFFFF - FFFFFFFFFFFFFFFF - 1 = 0000000080000000 (cc=2) ++sgh FFFFFFFFFFFFFFFF - FFFFFFFFFFFFFFFF - 1 = 0000000000000000 (cc=0) ++sgh 8000000000000000 - FFFFFFFFFFFFFFFF - 1 = 8000000000000001 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - FFFFFFFFFFFFFFFF - 1 = 8000000000000000 (cc=3) ++sgh 0000000000000000 - 7FFFFFFF00000000 - 1 = FFFFFFFFFFFF8001 (cc=1) ++sgh 0000000000000001 - 7FFFFFFF00000000 - 1 = FFFFFFFFFFFF8002 (cc=1) ++sgh 000000000000FFFF - 7FFFFFFF00000000 - 1 = 0000000000008000 (cc=2) ++sgh 0000000000007FFF - 7FFFFFFF00000000 - 1 = 0000000000000000 (cc=0) ++sgh 0000000000008000 - 7FFFFFFF00000000 - 1 = 0000000000000001 (cc=2) ++sgh 00000000FFFFFFFF - 7FFFFFFF00000000 - 1 = 00000000FFFF8000 (cc=2) ++sgh 0000000080000000 - 7FFFFFFF00000000 - 1 = 000000007FFF8001 (cc=2) ++sgh 000000007FFFFFFF - 7FFFFFFF00000000 - 1 = 000000007FFF8000 (cc=2) ++sgh FFFFFFFFFFFFFFFF - 7FFFFFFF00000000 - 1 = FFFFFFFFFFFF8000 (cc=1) ++sgh 8000000000000000 - 7FFFFFFF00000000 - 1 = 7FFFFFFFFFFF8001 (cc=3) ++sgh 7FFFFFFFFFFFFFFF - 7FFFFFFF00000000 - 1 = 7FFFFFFFFFFF8000 (cc=2) ++sgh 0000000000000000 - 8000000000000000 - 1 = 0000000000008000 (cc=2) ++sgh 0000000000000001 - 8000000000000000 - 1 = 0000000000008001 (cc=2) ++sgh 000000000000FFFF - 8000000000000000 - 1 = 0000000000017FFF (cc=2) ++sgh 0000000000007FFF - 8000000000000000 - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000008000 - 8000000000000000 - 1 = 0000000000010000 (cc=2) ++sgh 00000000FFFFFFFF - 8000000000000000 - 1 = 0000000100007FFF (cc=2) ++sgh 0000000080000000 - 8000000000000000 - 1 = 0000000080008000 (cc=2) ++sgh 000000007FFFFFFF - 8000000000000000 - 1 = 0000000080007FFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 8000000000000000 - 1 = 0000000000007FFF (cc=2) ++sgh 8000000000000000 - 8000000000000000 - 1 = 8000000000008000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 8000000000000000 - 1 = 8000000000007FFF (cc=3) ++sgh 0000000000000000 - FFFFFFFF00000000 - 1 = 0000000000000001 (cc=2) ++sgh 0000000000000001 - FFFFFFFF00000000 - 1 = 0000000000000002 (cc=2) ++sgh 000000000000FFFF - FFFFFFFF00000000 - 1 = 0000000000010000 (cc=2) ++sgh 0000000000007FFF - FFFFFFFF00000000 - 1 = 0000000000008000 (cc=2) ++sgh 0000000000008000 - FFFFFFFF00000000 - 1 = 0000000000008001 (cc=2) ++sgh 00000000FFFFFFFF - FFFFFFFF00000000 - 1 = 0000000100000000 (cc=2) ++sgh 0000000080000000 - FFFFFFFF00000000 - 1 = 0000000080000001 (cc=2) ++sgh 000000007FFFFFFF - FFFFFFFF00000000 - 1 = 0000000080000000 (cc=2) ++sgh FFFFFFFFFFFFFFFF - FFFFFFFF00000000 - 1 = 0000000000000000 (cc=0) ++sgh 8000000000000000 - FFFFFFFF00000000 - 1 = 8000000000000001 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - FFFFFFFF00000000 - 1 = 8000000000000000 (cc=3) ++sgh 0000000000000000 - 000000007FFFFFFF - 1 = 0000000000000000 (cc=0) ++sgh 0000000000000001 - 000000007FFFFFFF - 1 = 0000000000000001 (cc=2) ++sgh 000000000000FFFF - 000000007FFFFFFF - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000007FFF - 000000007FFFFFFF - 1 = 0000000000007FFF (cc=2) ++sgh 0000000000008000 - 000000007FFFFFFF - 1 = 0000000000008000 (cc=2) ++sgh 00000000FFFFFFFF - 000000007FFFFFFF - 1 = 00000000FFFFFFFF (cc=2) ++sgh 0000000080000000 - 000000007FFFFFFF - 1 = 0000000080000000 (cc=2) ++sgh 000000007FFFFFFF - 000000007FFFFFFF - 1 = 000000007FFFFFFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 000000007FFFFFFF - 1 = FFFFFFFFFFFFFFFF (cc=1) ++sgh 8000000000000000 - 000000007FFFFFFF - 1 = 8000000000000000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 000000007FFFFFFF - 1 = 7FFFFFFFFFFFFFFF (cc=2) ++sgh 0000000000000000 - 0000000080000000 - 1 = 0000000000000000 (cc=0) ++sgh 0000000000000001 - 0000000080000000 - 1 = 0000000000000001 (cc=2) ++sgh 000000000000FFFF - 0000000080000000 - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000007FFF - 0000000080000000 - 1 = 0000000000007FFF (cc=2) ++sgh 0000000000008000 - 0000000080000000 - 1 = 0000000000008000 (cc=2) ++sgh 00000000FFFFFFFF - 0000000080000000 - 1 = 00000000FFFFFFFF (cc=2) ++sgh 0000000080000000 - 0000000080000000 - 1 = 0000000080000000 (cc=2) ++sgh 000000007FFFFFFF - 0000000080000000 - 1 = 000000007FFFFFFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 0000000080000000 - 1 = FFFFFFFFFFFFFFFF (cc=1) ++sgh 8000000000000000 - 0000000080000000 - 1 = 8000000000000000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 0000000080000000 - 1 = 7FFFFFFFFFFFFFFF (cc=2) ++sgh 0000000000000000 - 00000000FFFFFFFF - 1 = 0000000000000000 (cc=0) ++sgh 0000000000000001 - 00000000FFFFFFFF - 1 = 0000000000000001 (cc=2) ++sgh 000000000000FFFF - 00000000FFFFFFFF - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000007FFF - 00000000FFFFFFFF - 1 = 0000000000007FFF (cc=2) ++sgh 0000000000008000 - 00000000FFFFFFFF - 1 = 0000000000008000 (cc=2) ++sgh 00000000FFFFFFFF - 00000000FFFFFFFF - 1 = 00000000FFFFFFFF (cc=2) ++sgh 0000000080000000 - 00000000FFFFFFFF - 1 = 0000000080000000 (cc=2) ++sgh 000000007FFFFFFF - 00000000FFFFFFFF - 1 = 000000007FFFFFFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 00000000FFFFFFFF - 1 = FFFFFFFFFFFFFFFF (cc=1) ++sgh 8000000000000000 - 00000000FFFFFFFF - 1 = 8000000000000000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 00000000FFFFFFFF - 1 = 7FFFFFFFFFFFFFFF (cc=2) ++sgh 0000000000000000 - 000000000000FFFF - 1 = 0000000000000000 (cc=0) ++sgh 0000000000000001 - 000000000000FFFF - 1 = 0000000000000001 (cc=2) ++sgh 000000000000FFFF - 000000000000FFFF - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000007FFF - 000000000000FFFF - 1 = 0000000000007FFF (cc=2) ++sgh 0000000000008000 - 000000000000FFFF - 1 = 0000000000008000 (cc=2) ++sgh 00000000FFFFFFFF - 000000000000FFFF - 1 = 00000000FFFFFFFF (cc=2) ++sgh 0000000080000000 - 000000000000FFFF - 1 = 0000000080000000 (cc=2) ++sgh 000000007FFFFFFF - 000000000000FFFF - 1 = 000000007FFFFFFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 000000000000FFFF - 1 = FFFFFFFFFFFFFFFF (cc=1) ++sgh 8000000000000000 - 000000000000FFFF - 1 = 8000000000000000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 000000000000FFFF - 1 = 7FFFFFFFFFFFFFFF (cc=2) ++sgh 0000000000000000 - 0000000000007FFF - 1 = 0000000000000000 (cc=0) ++sgh 0000000000000001 - 0000000000007FFF - 1 = 0000000000000001 (cc=2) ++sgh 000000000000FFFF - 0000000000007FFF - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000007FFF - 0000000000007FFF - 1 = 0000000000007FFF (cc=2) ++sgh 0000000000008000 - 0000000000007FFF - 1 = 0000000000008000 (cc=2) ++sgh 00000000FFFFFFFF - 0000000000007FFF - 1 = 00000000FFFFFFFF (cc=2) ++sgh 0000000080000000 - 0000000000007FFF - 1 = 0000000080000000 (cc=2) ++sgh 000000007FFFFFFF - 0000000000007FFF - 1 = 000000007FFFFFFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 0000000000007FFF - 1 = FFFFFFFFFFFFFFFF (cc=1) ++sgh 8000000000000000 - 0000000000007FFF - 1 = 8000000000000000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 0000000000007FFF - 1 = 7FFFFFFFFFFFFFFF (cc=2) ++sgh 0000000000000000 - 0000000000008000 - 1 = 0000000000000000 (cc=0) ++sgh 0000000000000001 - 0000000000008000 - 1 = 0000000000000001 (cc=2) ++sgh 000000000000FFFF - 0000000000008000 - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000007FFF - 0000000000008000 - 1 = 0000000000007FFF (cc=2) ++sgh 0000000000008000 - 0000000000008000 - 1 = 0000000000008000 (cc=2) ++sgh 00000000FFFFFFFF - 0000000000008000 - 1 = 00000000FFFFFFFF (cc=2) ++sgh 0000000080000000 - 0000000000008000 - 1 = 0000000080000000 (cc=2) ++sgh 000000007FFFFFFF - 0000000000008000 - 1 = 000000007FFFFFFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 0000000000008000 - 1 = FFFFFFFFFFFFFFFF (cc=1) ++sgh 8000000000000000 - 0000000000008000 - 1 = 8000000000000000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 0000000000008000 - 1 = 7FFFFFFFFFFFFFFF (cc=2) ++sgh 0000000000000000 - 000000000000FFFF - 1 = 0000000000000000 (cc=0) ++sgh 0000000000000001 - 000000000000FFFF - 1 = 0000000000000001 (cc=2) ++sgh 000000000000FFFF - 000000000000FFFF - 1 = 000000000000FFFF (cc=2) ++sgh 0000000000007FFF - 000000000000FFFF - 1 = 0000000000007FFF (cc=2) ++sgh 0000000000008000 - 000000000000FFFF - 1 = 0000000000008000 (cc=2) ++sgh 00000000FFFFFFFF - 000000000000FFFF - 1 = 00000000FFFFFFFF (cc=2) ++sgh 0000000080000000 - 000000000000FFFF - 1 = 0000000080000000 (cc=2) ++sgh 000000007FFFFFFF - 000000000000FFFF - 1 = 000000007FFFFFFF (cc=2) ++sgh FFFFFFFFFFFFFFFF - 000000000000FFFF - 1 = FFFFFFFFFFFFFFFF (cc=1) ++sgh 8000000000000000 - 000000000000FFFF - 1 = 8000000000000000 (cc=1) ++sgh 7FFFFFFFFFFFFFFF - 000000000000FFFF - 1 = 7FFFFFFFFFFFFFFF (cc=2) +diff --git a/none/tests/s390x/sub-z14.vgtest b/none/tests/s390x/sub-z14.vgtest +new file mode 100644 +index 000000000..7b338980a +--- /dev/null ++++ b/none/tests/s390x/sub-z14.vgtest +@@ -0,0 +1,2 @@ ++prog: sub-z14 ++prereq: ../../../tests/s390x_features s390x-mi2 +diff --git a/none/tests/s390x/sub.c b/none/tests/s390x/sub.c +index 6b610ab2d..737c039df 100644 +--- a/none/tests/s390x/sub.c ++++ b/none/tests/s390x/sub.c +@@ -1,7 +1,25 @@ +-#include + #include "sub.h" + #include "opcodes.h" + ++#define s(x, y) "s " x ", " y "\n" ++#define sh(x, y) "sh " x ", " y "\n" ++#define sg(x, y) "sg " x ", " y "\n" ++#define sgf(x, y) "sgf " x ", " y "\n" ++#define sl(x, y) "sl " x ", " y "\n" ++#define slg(x, y) "slg " x ", " y "\n" ++#define sgf(x, y) "sgf " x ", " y "\n" ++#define slgf(x, y) "slgf " x ", " y "\n" ++#define sr(x, y) "sr " x ", " y "\n" ++#define sgr(x, y) "sgr " x ", " y "\n" ++#define sgfr(x, y) "sgfr " x ", " y "\n" ++#define slr(x, y) "slr " x ", " y "\n" ++#define slgr(x, y) "slgr " x ", " y "\n" ++#define slgfr(x, y) "slgfr " x ", " y "\n" ++#define slb(x, y) "slb " x ", " y "\n" ++#define slbg(x, y) "slbg " x ", " y "\n" ++#define slbr(x, y) "slbr " x ", " y "\n" ++#define slbgr(x, y) "slbgr " x ", " y "\n" ++ + static void do_regmem_insns(unsigned long s2) + { + memsweep(s, s2, 0); +@@ -33,20 +51,5 @@ static void do_regmem_insns(unsigned long s2) + + int main() + { +- do_regmem_insns(0x0ul); +- do_regmem_insns(0x7ffffffffffffffful); +- do_regmem_insns(0x8000000000000000ul); +- do_regmem_insns(0xfffffffffffffffful); +- do_regmem_insns(0x7fffffff00000000ul); +- do_regmem_insns(0x8000000000000000ul); +- do_regmem_insns(0xffffffff00000000ul); +- do_regmem_insns(0x000000007ffffffful); +- do_regmem_insns(0x0000000080000000ul); +- do_regmem_insns(0x00000000fffffffful); +- do_regmem_insns(0x000000000000fffful); +- do_regmem_insns(0x0000000000007ffful); +- do_regmem_insns(0x0000000000008000ul); +- do_regmem_insns(0x000000000000fffful); +- +- return 0; ++ for_each_m2(do_regmem_insns); + } +diff --git a/none/tests/s390x/sub.h b/none/tests/s390x/sub.h +index 7d4bed792..5caa7e385 100644 +--- a/none/tests/s390x/sub.h ++++ b/none/tests/s390x/sub.h +@@ -7,9 +7,9 @@ volatile long v; + ({ \ + unsigned long tmp = s1; \ + int cc; \ +- asm volatile( "lghi 0," #NOBORROW "\n" \ ++ asm volatile( "lghi 0," #NOBORROW "\n" \ + "aghi 0, 0\n" \ +- #insn " %0, %3\n" \ ++ insn("%0", "%3") \ + "ipm %1\n" \ + "srl %1,28\n" \ + : "+d" (tmp), "=d" (cc) \ +@@ -22,9 +22,9 @@ volatile long v; + ({ \ + unsigned long tmp = s1; \ + int cc; \ +- asm volatile( "lghi 0," #NOBORROW "\n" \ ++ asm volatile( "lghi 0," #NOBORROW "\n" \ + "aghi 0, 0\n" \ +- #insn " %0, %3\n" \ ++ insn("%0", "%3") \ + "ipm %1\n" \ + "srl %1,28\n" \ + : "+d" (tmp), "=d" (cc) \ +@@ -37,7 +37,7 @@ volatile long v; + ({ \ + register unsigned long tmp asm("2") = s1; \ + int cc; \ +- asm volatile( "lghi 0," #NOBORROW "\n" \ ++ asm volatile( "lghi 0," #NOBORROW "\n" \ + "aghi 0, 0\n" \ + insn(2,s2) \ + "ipm %1\n" \ +@@ -125,3 +125,21 @@ volatile long v; + SUB_REG_LDISP(i, 0x8000000000000000ul, s2, carryset); \ + SUB_REG_LDISP(i, 0x7ffffffffffffffful, s2, carryset); \ + }) ++ ++#define for_each_m2(f) \ ++({ \ ++ f(0x0ul); \ ++ f(0x7ffffffffffffffful); \ ++ f(0x8000000000000000ul); \ ++ f(0xfffffffffffffffful); \ ++ f(0x7fffffff00000000ul); \ ++ f(0x8000000000000000ul); \ ++ f(0xffffffff00000000ul); \ ++ f(0x000000007ffffffful); \ ++ f(0x0000000080000000ul); \ ++ f(0x00000000fffffffful); \ ++ f(0x000000000000fffful); \ ++ f(0x0000000000007ffful); \ ++ f(0x0000000000008000ul); \ ++ f(0x000000000000fffful); \ ++}) +diff --git a/tests/s390x_features.c b/tests/s390x_features.c +index 301785fac..ce6c4ab26 100644 +--- a/tests/s390x_features.c ++++ b/tests/s390x_features.c +@@ -249,6 +249,8 @@ static int go(char *feature, char *cpu) + match = facilities[2] & FAC_BIT(0); + } else if (strcmp(feature, "s390x-msa5") == 0 ) { + match = facilities[0] & FAC_BIT(57); /* message security assist 5 facility */ ++ } else if (strcmp(feature, "s390x-mi2") == 0 ) { ++ match = facilities[0] & FAC_BIT(58); + } else { + return 2; // Unrecognised feature. + } + +commit 379c62017f1e573eeb54725bf3a3bc84c5aa9977 +Author: Petar Jovanovic +Date: Fri Jun 14 14:14:05 2019 +0000 + + Fix makefile consistency check + + Add ecag.stdout.exp-z14 to EXTRA_DIST. + +diff --git a/none/tests/s390x/Makefile.am b/none/tests/s390x/Makefile.am +index a5fbffd1e..c5b07f7a2 100644 +--- a/none/tests/s390x/Makefile.am ++++ b/none/tests/s390x/Makefile.am +@@ -39,7 +39,7 @@ EXTRA_DIST = \ + $(addsuffix .stdout.exp,$(INSN_TESTS)) \ + $(addsuffix .vgtest,$(INSN_TESTS)) \ + ecag.stdout.exp-z10ec ecag.stdout.exp-z196 ecag.stdout.exp-zec12 \ +- ecag.stdout.exp-z13 \ ++ ecag.stdout.exp-z13 ecag.stdout.exp-z14 \ + op00.stderr.exp1 op00.stderr.exp2 op00.vgtest \ + fixbr.vgtest fixbr.stderr.exp fixbr.stdout.exp \ + fpext.vgtest fpext.stderr.exp fpext.stdout.exp \ diff --git a/SOURCES/valgrind-3.9.0-cachegrind-improvements.patch b/SOURCES/valgrind-3.9.0-cachegrind-improvements.patch new file mode 100644 index 0000000..c2680b1 --- /dev/null +++ b/SOURCES/valgrind-3.9.0-cachegrind-improvements.patch @@ -0,0 +1,54 @@ +--- valgrind-3.8.1/cachegrind/cg_sim.c.jj 2011-10-26 23:24:32.000000000 +0200 ++++ valgrind-3.8.1/cachegrind/cg_sim.c 2011-12-09 17:31:19.256023683 +0100 +@@ -42,27 +42,30 @@ typedef struct { + Int size; /* bytes */ + Int assoc; + Int line_size; /* bytes */ +- Int sets; + Int sets_min_1; + Int line_size_bits; + Int tag_shift; +- HChar desc_line[128]; /* large enough */ + UWord* tags; +-} cache_t2; ++ HChar desc_line[128]; ++} cache_t2 ++#ifdef __GNUC__ ++__attribute__ ((aligned (8 * sizeof (Int)))) ++#endif ++; + + /* By this point, the size/assoc/line_size has been checked. */ + static void cachesim_initcache(cache_t config, cache_t2* c) + { +- Int i; ++ Int sets; + + c->size = config.size; + c->assoc = config.assoc; + c->line_size = config.line_size; + +- c->sets = (c->size / c->line_size) / c->assoc; +- c->sets_min_1 = c->sets - 1; ++ sets = (c->size / c->line_size) / c->assoc; ++ c->sets_min_1 = sets - 1; + c->line_size_bits = VG_(log2)(c->line_size); +- c->tag_shift = c->line_size_bits + VG_(log2)(c->sets); ++ c->tag_shift = c->line_size_bits + VG_(log2)(sets); + + if (c->assoc == 1) { + VG_(sprintf)(c->desc_line, "%d B, %d B, direct-mapped", +@@ -72,11 +75,8 @@ static void cachesim_initcache(cache_t c + c->size, c->line_size, c->assoc); + } + +- c->tags = VG_(malloc)("cg.sim.ci.1", +- sizeof(UWord) * c->sets * c->assoc); +- +- for (i = 0; i < c->sets * c->assoc; i++) +- c->tags[i] = 0; ++ c->tags = VG_(calloc)("cg.sim.ci.1", ++ sizeof(UWord), sets * c->assoc); + } + + /* This attribute forces GCC to inline the function, getting rid of a diff --git a/SOURCES/valgrind-3.9.0-helgrind-race-supp.patch b/SOURCES/valgrind-3.9.0-helgrind-race-supp.patch new file mode 100644 index 0000000..759d151 --- /dev/null +++ b/SOURCES/valgrind-3.9.0-helgrind-race-supp.patch @@ -0,0 +1,15 @@ +--- valgrind/glibc-2.34567-NPTL-helgrind.supp.jj 2009-08-19 15:37:48.000000000 +0200 ++++ valgrind/glibc-2.34567-NPTL-helgrind.supp 2009-10-21 16:46:31.000000000 +0200 +@@ -88,6 +88,12 @@ + obj:*/lib*/libpthread-2.*so* + } + { ++ helgrind-glibc2X-102a ++ Helgrind:Race ++ fun:mythread_wrapper ++ obj:*vgpreload_helgrind*.so ++} ++{ + helgrind-glibc2X-103 + Helgrind:Race + fun:pthread_cond_*@@GLIBC_2.* diff --git a/SOURCES/valgrind-3.9.0-ldso-supp.patch b/SOURCES/valgrind-3.9.0-ldso-supp.patch new file mode 100644 index 0000000..d7a42c7 --- /dev/null +++ b/SOURCES/valgrind-3.9.0-ldso-supp.patch @@ -0,0 +1,28 @@ +--- valgrind/glibc-2.X.supp.in.jj 2011-10-26 23:24:45.000000000 +0200 ++++ valgrind/glibc-2.X.supp.in 2012-05-07 10:55:20.395942656 +0200 +@@ -124,7 +124,7 @@ + glibc-2.5.x-on-SUSE-10.2-(PPC)-2a + Memcheck:Cond + fun:index +- obj:*ld-@GLIBC_VERSION@.*.so ++ obj:*ld-@GLIBC_VERSION@*.so + } + { + glibc-2.5.x-on-SuSE-10.2-(PPC)-2b +@@ -136,14 +136,14 @@ + glibc-2.5.5-on-SuSE-10.2-(PPC)-2c + Memcheck:Addr4 + fun:index +- obj:*ld-@GLIBC_VERSION@.*.so ++ obj:*ld-@GLIBC_VERSION@*.so + } + { + glibc-2.3.5-on-SuSE-10.1-(PPC)-3 + Memcheck:Addr4 + fun:*wordcopy_fwd_dest_aligned* + fun:mem*cpy +- obj:*lib*@GLIBC_VERSION@.*.so ++ obj:*lib*@GLIBC_VERSION@*.so + } + + { diff --git a/SPECS/valgrind.spec b/SPECS/valgrind.spec new file mode 100644 index 0000000..8a96553 --- /dev/null +++ b/SPECS/valgrind.spec @@ -0,0 +1,1326 @@ +%{?scl:%scl_package valgrind} + +Summary: Tool for finding memory management bugs in programs +Name: %{?scl_prefix}valgrind +Version: 3.15.0 +Release: 11%{?dist} +Epoch: 1 +License: GPLv2+ +URL: http://www.valgrind.org/ +Group: Development/Debuggers + +# Only necessary for RHEL, will be ignored on Fedora +BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) + +# Are we building for a Software Collection? +%{?scl:%global is_scl 1} +%{!?scl:%global is_scl 0} + +# We never want the openmpi subpackage when building a software collecton. +# We always want it for fedora. +# We only want it for older rhel. But not s390x for too old rhel. +%if %{is_scl} + %global build_openmpi 0 +%else + %if 0%{?fedora} + %global build_openmpi 1 + %endif + %if 0%{?rhel} + # We only ever build for these architectures. Historically s390x + # didn't have an openmpi implementation. + %ifarch %{ix86} x86_64 ppc ppc64 ppc64le %{arm} aarch64 + %global build_openmpi 1 + %else + %global build_openmpi 0 + %endif + %endif +%endif + +# We only want to build the valgrind-tools-devel package for Fedora proper +# as convenience. But not for DTS or RHEL. +%if %{is_scl} + %global build_tools_devel 0 +%else + %if 0%{?rhel} + %global build_tools_devel 0 + %else + %global build_tools_devel 1 + %endif +%endif + +# Whether to run the full regtest or only a limited set +# The full regtest includes gdb_server integration tests +# and experimental tools. +# Only run full regtests on fedora, but not on older rhel +# or when creating scl, the gdb_server tests might hang. +%if %{is_scl} + %global run_full_regtest 0 +%else + %if 0%{?fedora} + %global run_full_regtest 1 + %endif + %if 0%{?rhel} + %global run_full_regtest (%rhel >= 7) + %endif +%endif + +# Generating minisymtabs doesn't really work for the staticly linked +# tools. Note (below) that we don't strip the vgpreload libraries at all +# because valgrind might read and need the debuginfo in those (client) +# libraries for better error reporting and sometimes correctly unwinding. +# So those will already have their full symbol table. +%undefine _include_minidebuginfo + +Source0: ftp://sourceware.org/pub/valgrind/valgrind-%{version}.tar.bz2 + +# Needs investigation and pushing upstream +Patch1: valgrind-3.9.0-cachegrind-improvements.patch + +# KDE#211352 - helgrind races in helgrind's own mythread_wrapper +Patch2: valgrind-3.9.0-helgrind-race-supp.patch + +# Make ld.so supressions slightly less specific. +Patch3: valgrind-3.9.0-ldso-supp.patch + +# We want all executables and libraries in libexec instead of lib +# so they are only available for valgrind usage itself and so the +# same directory is used independent of arch. +Patch4: valgrind-3.15.0-pkglibexecdir.patch + +# KDE#398649 s390x z13 support doesn't build with older gcc/binutils +# Disable z13 support (on rhel6) +Patch5: valgrind-3.15.0-disable-s390x-z13.patch + +# Add some stack-protector +Patch6: valgrind-3.15.0-some-stack-protector.patch + +# KDE#406561 mcinfcallWSRU gdbserver_test fails on ppc64 +Patch7: valgrind-3.15.0-ppc64-filter_gdb.patch + +# KDE#407218 Add support for the copy_file_range syscall +Patch8: valgrind-3.15.0-copy_file_range.patch + +# KDE#407307 Intercept stpcpy also in ld.so for arm64 +Patch9: valgrind-3.15.0-arm64-ld-stpcpy.patch + +# commit 59784c aarch64 (arm64) isn't a supported architecture for exp-sgcheck. +Patch10: valgrind-3.15.0-exp-sgcheck-no-aarch64.patch + +# commit 917e42 Make memcheck/tests/arm64-linux/scalar work under root +Patch11: valgrind-3.15.0-scalar-arm64.patch + +# commit abc09f Make memcheck/tests/x86-linux/scalar test work under root. +Patch12: valgrind-3.15.0-scalar-x86.patch + +# KDE#407764 s390x: drd fails on z13 due to function wrapping issue +Patch13: valgrind-3.15.0-s390x-wrap-drd.patch + +# Add some -Wl,z,now. +Patch14: valgrind-3.15.0-some-Wl-z-now.patch + +# KDE#408009 Expose rdrand and f16c even on avx if host cpu supports them +Patch15: valgrind-3.15.0-avx-rdrand-f16c.patch + +# KDE#408091 Missing pkey syscalls +Patch16: valgrind-3.15.0-pkey.patch + +# KDE#408414 Add support for preadv2 and pwritev2 syscalls +Patch17: valgrind-3.15.0-preadv2-pwritev2.patch + +# Upstream commit 9616e9bc9a1950f70ab1abd1c6ca9abc3f26eb7f +Patch18: valgrind-3.15.0-arm-membarrier.patch + +# KDE#404406 s390x: z14 miscellaneous instructions not implemented +Patch19: valgrind-3.15.0-z14-misc.patch + + +# RHBZ#996927 Ignore PPC floating point phased out category. +# The result might differ on ppc vs ppc64 and config.h ends up as +# public header under /usr/include/valgrind causing multilib problems. +# The result would only be used for two test cases. +Patch7001: valgrind-3.11.0-ppc-fppo.patch + + +BuildRequires: glibc-devel + +%if %{build_openmpi} +BuildRequires: openmpi-devel +%endif + +%if %{run_full_regtest} +BuildRequires: gdb +%endif + +# gdbserver_tests/filter_make_empty uses ps in test +BuildRequires: procps + +# Some testcases require g++ to build +BuildRequires: gcc-c++ + +# check_headers_and_includes uses Getopt::Long +%if 0%{?fedora} +BuildRequires: perl-generators +%endif +BuildRequires: perl(Getopt::Long) + +# We always autoreconf +BuildRequires: automake +BuildRequires: autoconf + +%{?scl:Requires:%scl_runtime} + +# We need to fixup selinux file context when doing a scl build. +# In RHEL6 we might need to fix up the labels even though the +# meta package sets up a fs equivalence. See post. +%if 0%{?rhel} == 6 +%{?scl:Requires(post): /sbin/restorecon} +%endif + +# We could use %%valgrind_arches as defined in redhat-rpm-config +# But that is really for programs using valgrind, it defines the +# set of architectures that valgrind works correctly on. +ExclusiveArch: %{ix86} x86_64 ppc ppc64 ppc64le s390x armv7hl aarch64 + +# Define valarch, the architecture name that valgrind uses +# And only_arch, the configure option to only build for that arch. +%ifarch %{ix86} +%define valarch x86 +%define only_arch --enable-only32bit +%endif +%ifarch x86_64 +%define valarch amd64 +%define only_arch --enable-only64bit +%endif +%ifarch ppc +%define valarch ppc32 +%define only_arch --enable-only32bit +%endif +%ifarch ppc64 +%define valarch ppc64be +%define only_arch --enable-only64bit +%endif +%ifarch ppc64le +%define valarch ppc64le +%define only_arch --enable-only64bit +%endif +%ifarch s390x +%define valarch s390x +%define only_arch --enable-only64bit +%endif +%ifarch armv7hl +%define valarch arm +%define only_arch --enable-only32bit +%endif +%ifarch aarch64 +%define valarch arm64 +%define only_arch --enable-only64bit +%endif + +%description +Valgrind is an instrumentation framework for building dynamic analysis +tools. There are Valgrind tools that can automatically detect many +memory management and threading bugs, and profile your programs in +detail. You can also use Valgrind to build new tools. The Valgrind +distribution currently includes six production-quality tools: a memory +error detector (memcheck, the default tool), two thread error +detectors (helgrind and drd), a cache and branch-prediction profiler +(cachegrind), a call-graph generating cache and branch-prediction +profiler (callgrind), and a heap profiler (massif). + +%package devel +Summary: Development files for valgrind +Group: Development/Debuggers +Requires: %{?scl_prefix}valgrind = %{epoch}:%{version}-%{release} +Provides: %{name}-static = %{epoch}:%{version}-%{release} + +%description devel +Header files and libraries for development of valgrind aware programs +or valgrind plugins. + +%if %{build_openmpi} +%package openmpi +Summary: OpenMPI support for valgrind +Group: Development/Debuggers +Requires: %{?scl_prefix}valgrind = %{epoch}:%{version}-%{release} + +%description openmpi +A wrapper library for debugging OpenMPI parallel programs with valgrind. +See the section on Debugging MPI Parallel Programs with Valgrind in the +Valgrind User Manual for details. +%endif + +%prep +%setup -q -n %{?scl:%{pkg_name}}%{!?scl:%{name}}-%{version} + +%patch1 -p1 +%patch2 -p1 +%patch3 -p1 +%patch4 -p1 + +# Disable s390x z13 support on old rhel, binutils is just too old. +%if 0%{?rhel} == 6 +%patch5 -p1 +%endif + +# Old rhel gcc doesn't have -fstack-protector-strong. +%if 0%{?fedora} || 0%{?rhel} >= 7 +%patch6 -p1 +%endif + +%patch7 -p1 +%patch8 -p1 +%patch9 -p1 +%patch10 -p1 +%patch11 -p1 +%patch12 -p1 +%patch13 -p1 + +# This depends on patch6, old rhel gcc doesn't have -fstack-protector-strong. +%if 0%{?fedora} || 0%{?rhel} >= 7 +%patch14 -p1 +%endif + +%patch15 -p1 +%patch16 -p1 +%patch17 -p1 +%patch18 -p1 + +# Don't add s390x z14 support on old rhel, binutils is just too old. +%if 0%{?fedora} || 0%{?rhel} >= 7 +%patch19 -p1 +%endif + + +# RHEL7 specific patches +%patch7001 -p1 + + +%build + +# Some patches (might) touch Makefile.am or configure.ac files. +# Just always autoreconf so we don't need patches to prebuild files. +./autogen.sh + +# Old openmpi-devel has version depended paths for mpicc. +%if %{build_openmpi} +%if 0%{?fedora} >= 13 || 0%{?rhel} >= 6 +%define mpiccpath %{!?scl:%{_libdir}}%{?scl:%{_root_libdir}}/openmpi/bin/mpicc +%else +%define mpiccpath %{!?scl:%{_libdir}}%{?scl:%{_root_libdir}}/openmpi/*/bin/mpicc +%endif +%else +# We explicitly don't want the libmpi wrapper. So make sure that configure +# doesn't pick some random mpi compiler that happens to be installed. +%define mpiccpath /bin/false +%endif + +# Filter out "hardening" flags that don't make sense for valgrind. +# -fstack-protector just cannot work (valgrind would have to implement +# its own version since it doesn't link with glibc and handles stack +# setup itself). We patch some flags back in just for those helper +# programs where it does make sense. +# +# -Wl,-z,now doesn't make sense for static linked tools +# and would prevent using the vgpreload libraries on binaries that +# don't link themselves against libraries (like pthread) which symbols +# are needed (but only if the inferior itself would use them). +# +# -O2 doesn't work for the vgpreload libraries either. They are meant +# to not be optimized to show precisely what happened. valgrind adds +# -O2 itself wherever suitable. +# +# On ppc64[be] -fexceptions is troublesome. +# It might cause an undefined reference to `_Unwind_Resume' +# in libcoregrind-ppc64be-linux.a(libcoregrind_ppc64be_linux_a-readelf.o): +# In function `read_elf_symtab__ppc64be_linux. +# +# Also disable strict symbol checks because the vg_preload library +# will use hidden/undefined symbols from glibc like __libc_freeres. +%undefine _strict_symbol_defs_build + +%ifarch ppc64 +CFLAGS="`echo " %{optflags} " | sed 's/ -fstack-protector\([-a-z]*\) / / g;s/ -O2 / /g;s/ -fexceptions / /g;'`" +%else +CFLAGS="`echo " %{optflags} " | sed 's/ -fstack-protector\([-a-z]*\) / / g;s/ -O2 / /g;'`" +%endif +export CFLAGS + +# Older Fedora/RHEL only had __global_ldflags. +# Even older didn't even have that (so we don't need to scrub them). +%if 0%{?build_ldflags:1} +LDFLAGS="`echo " %{build_ldflags} " | sed 's/ -Wl,-z,now / / g;'`" +%else +%if 0%{?__global_ldflags:1} +LDFLAGS="`echo " %{__global_ldflags} " | sed 's/ -Wl,-z,now / / g;'`" +%endif +%endif +export LDFLAGS + +%configure \ + --with-mpicc=%{mpiccpath} \ + %{only_arch} \ + GDB=%{_bindir}/gdb + +make %{?_smp_mflags} + +%install +rm -rf $RPM_BUILD_ROOT +make DESTDIR=$RPM_BUILD_ROOT install +mkdir docs/installed +mv $RPM_BUILD_ROOT%{_datadir}/doc/valgrind/* docs/installed/ +rm -f docs/installed/*.ps + +# We want the MPI wrapper installed under the openmpi libdir so the script +# generating the MPI library requires picks them up and sets up the right +# openmpi libmpi.so requires. Install symlinks in the original/upstream +# location for backwards compatibility. +%if %{build_openmpi} +pushd $RPM_BUILD_ROOT%{_libdir} +mkdir -p openmpi/valgrind +cd valgrind +mv libmpiwrap-%{valarch}-linux.so ../openmpi/valgrind/ +ln -s ../openmpi/valgrind/libmpiwrap-%{valarch}-linux.so +popd +%endif + +%ifarch %{ix86} x86_64 +# To avoid multilib clashes in between i?86 and x86_64, +# tweak installed a little bit. +for i in HAVE_PTHREAD_CREATE_GLIBC_2_0 HAVE_PTRACE_GETREGS HAVE_AS_AMD64_FXSAVE64; do + sed -i -e 's,^\(#define '$i' 1\|/\* #undef '$i' \*/\)$,#ifdef __x86_64__\n# define '$i' 1\n#endif,' \ + $RPM_BUILD_ROOT%{_includedir}/valgrind/config.h +done +%endif + +# We don't want debuginfo generated for the vgpreload libraries. +# Turn off execute bit so they aren't included in the debuginfo.list. +# We'll turn the execute bit on again in %%files. +chmod 644 $RPM_BUILD_ROOT%{_libexecdir}/valgrind/vgpreload*-%{valarch}-*so + +%check +# Make sure some info about the system is in the build.log +# Add || true because rpm on copr EPEL6 acts weirdly and we don't want +# to break the build. +uname -a +rpm -q glibc gcc binutils || true +%if %{run_full_regtest} +rpm -q gdb || true +%endif + +LD_SHOW_AUXV=1 /bin/true +cat /proc/cpuinfo + +# Make sure a basic binary runs. There should be no errors. +./vg-in-place --error-exitcode=1 /bin/true --help + +# Build the test files with the software collection compiler if available. +%{?scl:PATH=%{_bindir}${PATH:+:${PATH}}} +# Make sure no extra CFLAGS, CXXFLAGS or LDFLAGS leak through, +# the testsuite sets all flags necessary. See also configure above. +make %{?_smp_mflags} CFLAGS="" CXXFLAGS="" LDFLAGS="" check + +# Workaround https://bugzilla.redhat.com/show_bug.cgi?id=1434601 +# for gdbserver tests. +export PYTHONCOERCECLOCALE=0 + +echo ===============TESTING=================== +%if %{run_full_regtest} + make regtest || : +%else + make nonexp-regtest || : +%endif + +# Make sure test failures show up in build.log +# Gather up the diffs (at most the first 20 lines for each one) +MAX_LINES=20 +diff_files=`find gdbserver_tests */tests -name '*.diff*' | sort` +if [ z"$diff_files" = z ] ; then + echo "Congratulations, all tests passed!" >> diffs +else + for i in $diff_files ; do + echo "=================================================" >> diffs + echo $i >> diffs + echo "=================================================" >> diffs + if [ `wc -l < $i` -le $MAX_LINES ] ; then + cat $i >> diffs + else + head -n $MAX_LINES $i >> diffs + echo "" >> diffs + fi + done +fi +cat diffs +echo ===============END TESTING=============== + +%files +%defattr(-,root,root) +%doc COPYING NEWS README_* +%doc docs/installed/html docs/installed/*.pdf +%{_bindir}/* +%dir %{_libexecdir}/valgrind +# Install everything in the libdir except the .so. +# The vgpreload so files might need file mode adjustment. +%{_libexecdir}/valgrind/*[^o] +# Turn on executable bit again for vgpreload libraries. +# Was disabled in %%install to prevent debuginfo stripping. +%attr(0755,root,root) %{_libexecdir}/valgrind/vgpreload*-%{valarch}-*so +%{_mandir}/man1/* + +%files devel +%defattr(-,root,root) +%{_includedir}/valgrind +%dir %{_libdir}/valgrind +%{_libdir}/valgrind/*.a +%{_libdir}/pkgconfig/* + +%if %{build_openmpi} +%files openmpi +%defattr(-,root,root) +%dir %{_libdir}/valgrind +%{_libdir}/openmpi/valgrind/libmpiwrap*.so +%{_libdir}/valgrind/libmpiwrap*.so +%endif + +%changelog +* Mon Aug 5 2019 Mark Wielaard - 3.15.0-11 +- Rebase to 3.15.0 plus backports and z14-misc support + +* Tue Mar 5 2019 Mark Wielaard - 3.14.0-16 +- Rebase to 3.14.0 plus backports and z13 support (#1519410) + +* Thu Jun 21 2018 Mark Wielaard - 3.13.0-13 +- Improved valgrind-3.13.0-arm64-hwcap.patch (#1593686) +- Add valgrind-3.13.0-arm64-ptrace.patch (#1593682) + +* Tue Jun 12 2018 Mark Wielaard - 3.13.0-12 +- Keep build_openmpi explicitly off for s390x (#1530219) + +* Tue Jun 12 2018 Mark Wielaard - 3.13.0-11 +- Make building of libmpi wrapper explicit (#1530219) +- Add valgrind-3.13.0-debug-alt-file.patch + and valgrind-3.13.0-build-id-phdrs.patch (#1589844) +- Add valgrind-3.13.0-s390-cgijnl.patch (#1589848) +- Add valgrind-3.13.0-ppc64-mtfprwa-constraint.patch (#1589852) + +* Thu Nov 2 2017 Mark Wielaard - 3.13.0-10 +- Add valgrind-3.13.0-ppc64-timebase.patch (#1508148) + +* Tue Oct 17 2017 Mark Wielaard - 3.13.0-9 +- valgrind 3.13.0 (fedora). +- Update description. +- Drop all upstreamed patches. +- Add valgrind-3.13.0-ppc64-check-no-vsx.patch +- Add valgrind-3.13.0-epoll_pwait.patch (#1462258) +- Add valgrind-3.13.0-ppc64-diag.patch +- Add valgrind-3.13.0-arm64-hwcap.patch (#1464211) +- Add valgrind-3.13.0-arm-index-hardwire.patch (#1466017) +- Add valgrind-3.13.0-ucontext_t.patch +- Add valgrind-3.13.0-gdb-8-testfix.patch +- Add valgrind-3.13.0-disable-vgdb-child.patch +- Add --error-exitcode=1 to /bin/true check. +- Add valgrind-3.13.0-xml-socket.patch +- Add valgrind-3.13.0-ppc64-vex-fixes.patch +- Add valgrind-3.13.0-amd64-eflags-tests.patch +- Add valgrind-3.13.0-suppress-dl-trampoline-sse-avx.patch +- Add valgrind-3.13.0-static-tls.patch +- Workaround gdb/python bug in testsuite (#1434601) + +* Thu Sep 21 2017 Mark Wielaard - 3.12.0-9 +- Add valgrind-3.12.0-ll-sc-fallback[1234].patch (#1492753) + +* Tue Mar 28 2017 Mark Wielaard - 3.12.0-8 +- Add valgrind-3.12.0-powerpc-register-pair.patch (#1437030) +- Add valgrind-3.12.0-ppc64-isa-3_00.patch (#1437032) + +* Sat Feb 18 2017 Mark Wielaard - 3.12.0-7 +- Rebase to 3.12.0 fedora backports (#1391217, #1385006, #1368706, #1270889) + +* Thu Jul 21 2016 Mark Wielaard - 3.11.0-24 +- Add valgrind-3.11.0-pcmpxstrx-0x70-0x19.patch (#1354557) + +* Tue Jun 21 2016 Mark Wielaard - 3.11.0-23 +- Update valgrind-3.11.0-ppoll-mask.patch (#1347626) + +* Mon May 30 2016 Mark Wielaard - 3.11.0-22 +- Add valgrind-3.11.0-arm64-handle_at.patch +- Add valgrind-3.11.0-ppc64-syscalls.patch + +* Fri Apr 29 2016 Mark Wielaard - 3.11.0-21 +- Add valgrind-3.11.0-deduppoolalloc.patch (#1328347) +- Add valgrind-3.11.0-ppc-bcd-addsub.patch (#1331738) +- Add valgrind-3.11.0-ppc64-vgdb-vr-regs.patch (#1331774) + +* Fri Apr 15 2016 Mark Wielaard - 3.11.0-20 +- Rebase to fedora 3.11.0 + (#1316512 #1306844 #1305962 #1298888 #1296318 #1271754 #1265566 #1265557) + +* Fri Aug 28 2015 Mark Wielaard - 3.10.0-16 +- Patch both 32 and 64 in valgrind-3.10.1-ppc32-tabortdc.patch (#1257623) + +* Thu Aug 27 2015 Mark Wielaard - 3.10.0-15 +- Add valgrind-3.10.1-ppc32-tabortdc.patch (#1257623) + +* Mon Aug 10 2015 Mark Wielaard - 3.10.0-14 +- Add setuid and setresgid to valgrind-3.10.1-aarch64-syscalls.patch (#1251181) + +* Mon Aug 03 2015 Mark Wielaard - 3.10.0-13 +- Add valgrind-3.10.1-ppc64-hwcap2.patch (#1249381) + +* Wed Jul 29 2015 Mark Wielaard - 3.10.0-12 +- Add valgrind-3.10.1-kernel-4.0.patch (#1247557) + +* Thu Jul 09 2015 Mark Wielaard - 3.10.0-11 +- Add valgrind-3.10.1-s390x-fiebra.patch (#1181993) + +* Tue Jul 07 2015 Mark Wielaard - 3.10.0-10 +- Add valgrind-3.10.1-di_notify_mmap.patch (#1237206) + +* Thu May 28 2015 Mark Wielaard - 3.10.0-9 +- Add valgrind-3.10-1-ppc64-sigpending.patch. (#1225964) + +* Thu May 28 2015 Mark Wielaard - 3.10.0-8 +- Add valgrind-3.10-s390-spechelper.patch. (#1190169) +- Add valgrind-3.10.1-aarch64-syscalls.patch. (#1188622) +- Add accept4 to valgrind-3.10.1-aarch64-syscalls.patch. (#1190660) +- Add valgrind-3.10.1-ppc64-accept4.patch. (#1190660) +- Add valgrind-3.10.1-send-recv-mmsg.patch. (#1192103) +- Add mount and umount2 to valgrind-3.10.1-aarch64-syscalls.patch. (#1193796) + +* Tue Jan 13 2015 Mark Wielaard - 3.10.0-7 +- Add valgrind-3.10.1-mempcpy.patch (#1178813) + +* Wed Nov 19 2014 Mark Wielaard - 3.10.0-6 +- Add getgroups/setgroups to valgrind-3.10.0-aarch64-syscalls.patch + +* Tue Nov 4 2014 Mark Wielaard - 3.10.0-5 +- Merge valgrind-3.10.0-aarch64-times.patch + and valgrind-3.10.0-aarch64-getsetsid.patch + into valgrind-3.10.0-aarch64-syscalls.patch + add fdatasync, msync, pread64, setreuid, setregid, + mknodat, fchdir, chroot, fchownat, fchmod and fchown. +- Add valgrind-3.10.0-aarch64-frint.patch +- Add valgrind-3.10.0-fcvtmu.patch +- Add valgrind-3.10.0-aarch64-fcvta.patch + +* Sat Oct 11 2014 Mark Wielaard - 3.10.0-4 +- Add valgrind-3.10.0-aarch64-times.patch +- Add valgrind-3.10.0-aarch64-getsetsid.patch +- Add valgrind-3.10.0-aarch64-dmb-sy.patch + +* Mon Sep 15 2014 Mark Wielaard - 3.10.0-3 +- Add valgrind-3.10.0-old-ppc32-instr-magic.patch. + +* Fri Sep 12 2014 Mark Wielaard - 3.10.0-2 +- Fix ppc32 multilib handling on ppc64[be]. +- Drop ppc64 secondary for ppc32 primary support. +- Except for armv7hl we don't support any other arm[32] arch. + +* Thu Sep 11 2014 Mark Wielaard - 3.10.0-1 +- Update to 3.10.0 final. +- Don't run dwz or generate minisymtab. +- Remove valgrind-3.9.0-s390x-ld-supp.patch fixed upstream. +- Add valgrind-openmpi for ppc64le. + +* Tue Sep 2 2014 Mark Wielaard - 3.10.0-0.1.BETA1 +- Update to official upstream 3.10.0 BETA1. + - Enables inlined frames in stacktraces. + +* Mon Mar 10 2014 Mark Wielaard - 3.9.0-6 +- Add valgrind-3.9.0-ppc64-priority.patch. (#1073613) + +* Fri Feb 21 2014 Mark Wielaard - 3.9.0-5 +- Add valgrind-3.9.0-s390-dup3.patch. (#1067486) + +* Fri Jan 24 2014 Daniel Mach - 1:3.9.0-4 +- Mass rebuild 2014-01-24 + +* Fri Dec 27 2013 Daniel Mach - 1:3.9.0-3 +- Mass rebuild 2013-12-27 + +* Thu Dec 12 2013 Mark Wielaard +- Add valgrind-3.9.0-manpage-memcheck-options.patch. (#1040914) +- Add valgrind-3.9.0-s390-fpr-pair.patch. (#1036615) + +* Thu Nov 28 2013 Mark Wielaard - 3.9.0-2.2 +- Add valgrind-3.9.0-s390x-ld-supp.patch. (#1032282) +- Add valgrind-3.9.0-xabort.patch. (#1035704) + +* Wed Nov 20 2013 Mark Wielaard - 3.9.0-2.1 +- Add valgrind-3.9.0-dwz-alt-buildid.patch. (#1029875) + +* Thu Nov 7 2013 Mark Wielaard - 3.9.0-1.2 +- Remove unnecessary and unapplied valgrind-3.8.1-movntdqa.patch +- Remove valgrind-3.9.0-s390x-workarounds.patch +- Add valgrind-3.9.0-s390-risbg.patch (#1018325) + +* Fri Nov 1 2013 Mark Wielaard - 3.9.0-1.1 +- Add s390x workarounds. (#1018325) + +* Fri Nov 1 2013 Mark Wielaard - 3.9.0-1 +- Upgrade to valgrind 3.9.0 final. +- Remove support for really ancient GCCs (valgrind-3.9.0-config_h.patch). +- Add valgrind-3.9.0-amd64_gen_insn_test.patch. +- Remove and cleanup fake 32-bit libgcc package. + +* Mon Oct 28 2013 Mark Wielaard - 3.9.0-0.1.TEST1 +- Upgrade to valgrind 3.9.0.TEST1 +- Remove patches that are now upstream: + - valgrind-3.8.1-abbrev-parsing.patch + - valgrind-3.8.1-af-bluetooth.patch + - valgrind-3.8.1-aspacemgr_VG_N_SEGs.patch + - valgrind-3.8.1-avx2-bmi-fma.patch.gz + - valgrind-3.8.1-avx2-prereq.patch + - valgrind-3.8.1-bmi-conf-check.patch + - valgrind-3.8.1-capget.patch + - valgrind-3.8.1-cfi_dw_ops.patch + - valgrind-3.8.1-dwarf-anon-enum.patch + - valgrind-3.8.1-filter_gdb.patch + - valgrind-3.8.1-find-buildid.patch + - valgrind-3.8.1-gdbserver_exit.patch + - valgrind-3.8.1-gdbserver_tests-syscall-template-source.patch + - valgrind-3.8.1-glibc-2.17-18.patch + - valgrind-3.8.1-index-supp.patch + - valgrind-3.8.1-initial-power-isa-207.patch + - valgrind-3.8.1-manpages.patch + - valgrind-3.8.1-memcheck-mc_translate-Iop_8HLto16.patch + - valgrind-3.8.1-mmxext.patch + - valgrind-3.8.1-movntdqa.patch + - valgrind-3.8.1-new-manpages.patch + - valgrind-3.8.1-openat.patch + - valgrind-3.8.1-overlap_memcpy_filter.patch + - valgrind-3.8.1-pie.patch + - valgrind-3.8.1-pkg-config.patch + - valgrind-3.8.1-power-isa-205-deprecation.patch + - valgrind-3.8.1-ppc-32-mode-64-bit-instr.patch + - valgrind-3.8.1-ppc-setxattr.patch + - valgrind-3.8.1-proc-auxv.patch + - valgrind-3.8.1-ptrace-include-configure.patch + - valgrind-3.8.1-ptrace-setgetregset.patch + - valgrind-3.8.1-ptrace-thread-area.patch + - valgrind-3.8.1-regtest-fixlets.patch + - valgrind-3.8.1-s390-STFLE.patch + - valgrind-3.8.1-s390_tsearch_supp.patch + - valgrind-3.8.1-sendmsg-flags.patch + - valgrind-3.8.1-sigill_diag.patch + - valgrind-3.8.1-static-variables.patch + - valgrind-3.8.1-stpncpy.patch + - valgrind-3.8.1-text-segment.patch + - valgrind-3.8.1-wcs.patch + - valgrind-3.8.1-x86_amd64_features-avx.patch + - valgrind-3.8.1-xaddb.patch + - valgrind-3.8.1-zero-size-sections.patch +- Remove special case valgrind-3.8.1-enable-armv5.patch. +- Remove valgrind-3.8.1-x86-backtrace.patch, rely on new upstream fp/cfi + try-cache mechanism. + +* Mon Oct 14 2013 Mark Wielaard - 3.8.1-31 +- Fix multilib issue with HAVE_PTRACE_GETREGS in config.h. + +* Thu Sep 26 2013 Mark Wielaard - 3.8.1-30 +- Add valgrind-3.8.1-index-supp.patch (#1011713) +- Ignore PPC floating point phased out category. (#996927). + +* Wed Sep 25 2013 Mark Wielaard - 3.8.1-29 +- Filter out -mcpu= so tests are compiled with the right flags. (#996927). + +* Mon Sep 23 2013 Mark Wielaard - 3.8.1-28 +- Implement SSE4 MOVNTDQA insn (valgrind-3.8.1-movntdqa.patch) +- Don't BuildRequire /bin/ps, just BuildRequire procps + (procps-ng provides procps). + +* Thu Sep 05 2013 Mark Wielaard - 3.8.1-27 +- Fix power_ISA2_05 testcase (valgrind-3.8.1-power-isa-205-deprecation.patch) +- Fix ppc32 make check build (valgrind-3.8.1-initial-power-isa-207.patch) +- Add valgrind-3.8.1-mmxext.patch + +* Wed Aug 21 2013 Mark Wielaard - 3.8.1-26 +- Allow building against glibc 2.18. (#999169) + +* Thu Aug 15 2013 Mark Wielaard - 3.8.1-25 +- Add valgrind-3.8.1-s390-STFLE.patch + s390 message-security assist (MSA) instruction extension not implemented. + +* Wed Aug 14 2013 Mark Wielaard - 3.8.1-24 +- Add valgrind-3.8.1-power-isa-205-deprecation.patch + Deprecation of some ISA 2.05 POWER6 instructions. +- Fixup auto-foo generation of new manpage doc patch. + +* Wed Aug 14 2013 Mark Wielaard - 3.8.1-23 +- tests/check_isa-2_07_cap should be executable. + +* Tue Aug 13 2013 Mark Wielaard - 3.8.1-22 +- Add valgrind-3.8.1-initial-power-isa-207.patch + Initial ISA 2.07 support for POWER8-tuned libc. + +* Thu Aug 08 2013 Mark Wielaard - 3.8.1-21 +- Don't depend on docdir location and version in openmpi subpackage + description (#993938). +- Enable openmpi subpackage also on arm. + +* Thu Aug 08 2013 Mark Wielaard - 3.8.1-20 +- Add valgrind-3.8.1-ptrace-include-configure.patch (#992847) + +* Sun Aug 04 2013 Fedora Release Engineering - 1:3.8.1-19 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_20_Mass_Rebuild + +* Thu Jul 18 2013 Petr Pisar - 1:3.8.1-18 +- Perl 5.18 rebuild + +* Mon Jul 08 2013 Mark Wielaard - 3.8.1-17 +- Add valgrind-3.8.1-dwarf-anon-enum.patch +- Cleanup valgrind-3.8.1-sigill_diag.patch .orig file changes (#949687). +- Add valgrind-3.8.1-ppc-setxattr.patch +- Add valgrind-3.8.1-new-manpages.patch +- Add valgrind-3.8.1-ptrace-thread-area.patch +- Add valgrind-3.8.1-af-bluetooth.patch + +* Tue May 28 2013 Michael Schwendt - 1:3.8.1-16 +- Provide virtual -static package in -devel subpackage (#609624). + +* Thu Apr 25 2013 Mark Wielaard 3.8.1-15 +- Add valgrind-3.8.1-zero-size-sections.patch. Resolves issues with zero + sized .eh_frame sections on ppc64. + +* Thu Apr 18 2013 Mark Wielaard 3.8.1-14 +- fixup selinux file context when doing a scl build. +- Enable regtest suite on ARM. +- valgrind-3.8.1-abbrev-parsing.patch, drop workaround, enable real fix. +- Fix -Ttext-segment configure check. Enables s390x again. +- BuildRequire ps for testsuite. + +* Tue Apr 02 2013 Mark Wielaard 3.8.1-13 +- Fix quoting in valgrind valgrind-3.8.1-enable-armv5.patch and + remove arm configure hunk from valgrind-3.8.1-text-segment.patch #947440 +- Replace valgrind-3.8.1-text-segment.patch with upstream variant. +- Add valgrind-3.8.1-regtest-fixlets.patch. + +* Wed Mar 20 2013 Mark Wielaard 3.8.1-12 +- Add valgrind-3.8.1-text-segment.patch +- Don't undefine _missing_build_ids_terminate_build. + +* Tue Mar 12 2013 Mark Wielaard 3.8.1-11 +- Add valgrind-3.8.1-manpages.patch + +* Fri Mar 01 2013 Mark Wielaard 3.8.1-10 +- Don't disable -debuginfo package generation, but do undefine + _missing_build_ids_terminate_build. + +* Thu Feb 28 2013 Mark Wielaard 3.8.1-9 +- Replace valgrind-3.8.1-sendmsg-flags.patch with upstream version. + +* Tue Feb 19 2013 Mark Wielaard 3.8.1-8 +- Add valgrind-3.8.1-sendmsg-flags.patch +- Add valgrind-3.8.1-ptrace-setgetregset.patch +- Add valgrind-3.8.1-static-variables.patch + +* Thu Feb 07 2013 Jon Ciesla 1:3.8.1-7 +- Merge review fixes, BZ 226522. + +* Wed Jan 16 2013 Mark Wielaard 3.8.1-6 +- Allow building against glibc-2.17. + +* Sun Nov 4 2012 Mark Wielaard 3.8.1-5 +- Add valgrind-3.8.1-stpncpy.patch (KDE#309427) +- Add valgrind-3.8.1-ppc-32-mode-64-bit-instr.patch (#810992, KDE#308573) +- Add valgrind-3.8.1-sigill_diag.patch (#810992, KDE#309425) + +* Tue Oct 16 2012 Mark Wielaard 3.8.1-4 +- Add valgrind-3.8.1-xaddb.patch (#866793, KDE#307106) + +* Mon Oct 15 2012 Mark Wielaard 3.8.1-3 +- Add valgrind-3.8.1-x86_amd64_features-avx.patch (KDE#307285) +- Add valgrind-3.8.1-gdbserver_tests-syscall-template-source.patch (KDE#307155) +- Add valgrind-3.8.1-overlap_memcpy_filter.patch (KDE#307290) +- Add valgrind-3.8.1-pkg-config.patch (#827219, KDE#307729) +- Add valgrind-3.8.1-proc-auxv.patch (KDE#253519) +- Add valgrind-3.8.1-wcs.patch (#755242, KDE#307828) +- Add valgrind-3.8.1-filter_gdb.patch (KDE#308321) +- Add valgrind-3.8.1-gdbserver_exit.patch (#862795, KDE#308341) +- Add valgrind-3.8.1-aspacemgr_VG_N_SEGs.patch (#730303, KDE#164485) +- Add valgrind-3.8.1-s390_tsearch_supp.patch (#816244, KDE#308427) + +* Fri Sep 21 2012 Mark Wielaard 3.8.1-2 +- Add valgrind-3.8.1-gdbserver_tests-mcinvoke-ppc64.patch +- Replace valgrind-3.8.1-cfi_dw_ops.patch with version as committed upstream. +- Remove erroneous printf change from valgrind-3.8.1-abbrev-parsing.patch. +- Add scalar testcase change to valgrind-3.8.1-capget.patch. + +* Thu Sep 20 2012 Mark Wielaard 3.8.1-1 +- Add partial backport of upstream revision 12884 + valgrind-3.8.0-memcheck-mc_translate-Iop_8HLto16.patch + without it AVX2 VPBROADCASTB insn is broken under memcheck. +- Add valgrind-3.8.0-cfi_dw_ops.patch (KDE#307038) + DWARF2 CFI reader: unhandled DW_OP_ opcode 0x8 (DW_OP_const1u and friends) +- Add valgrind-3.8.0-avx2-prereq.patch. +- Remove accidentially included diffs for gdbserver_tests and helgrind/tests + Makefile.in from valgrind-3.8.0-avx2-bmi-fma.patch.gz +- Remove valgrind-3.8.0-tests.patch tests no longer hang. +- Added SCL macros to support building as part of a Software Collection. +- Upgrade to valgrind 3.8.1. + +* Wed Sep 12 2012 Mark Wielaard 3.8.0-8 +- Add configure fixup valgrind-3.8.0-bmi-conf-check.patch + +* Wed Sep 12 2012 Mark Wielaard 3.8.0-7 +- Add valgrind-3.8.0-avx2-bmi-fma.patch (KDE#305728) + +* Tue Sep 11 2012 Mark Wielaard 3.8.0-6 +- Add valgrind-3.8.0-lzcnt-tzcnt-bugfix.patch (KDE#295808) +- Add valgrind-3.8.0-avx-alignment-check.patch (KDE#305926) + +* Mon Aug 27 2012 Mark Wielaard 3.8.0-5 +- Add valgrind-3.8.0-abbrev-parsing.patch for #849783 (KDE#305513). + +* Sun Aug 19 2012 Mark Wielaard 3.8.0-4 +- Add valgrind-3.8.0-find-buildid.patch workaround bug #849435 (KDE#305431). + +* Wed Aug 15 2012 Jakub Jelinek 3.8.0-3 +- fix up last change + +* Wed Aug 15 2012 Jakub Jelinek 3.8.0-2 +- tweak up to allow simultaneous installation + of valgrind-devel.{i686,x86_64} (#848146) + +* Fri Aug 10 2012 Jakub Jelinek 3.8.0-1 +- update to 3.8.0 release +- from CFLAGS/CXXFLAGS filter just fortification flags, not arch + specific flags +- on i?86 prefer to use CFI over %%ebp unwinding, as GCC 4.6+ + defaults to -fomit-frame-pointer + +* Tue Aug 07 2012 Mark Wielaard 3.8.0-0.1.TEST1.svn12858 +- Update to 3.8.0-TEST1 +- Clear CFLAGS CXXFLAGS LDFLAGS. +- Fix \ line continuation in configure line. + +* Fri Aug 03 2012 Mark Wielaard 3.7.0-7 +- Fixup shadowing warnings valgrind-3.7.0-dwz.patch +- Add valgrind-3.7.0-ref_addr.patch (#842659, KDE#298864) + +* Wed Jul 25 2012 Mark Wielaard 3.7.0-6 +- handle dwz DWARF compressor output (#842659, KDE#302901) +- allow glibc 2.16. + +* Sun Jul 22 2012 Fedora Release Engineering - 1:3.7.0-5 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_18_Mass_Rebuild + +* Mon May 7 2012 Jakub Jelinek 3.7.0-4 +- adjust suppressions so that it works even with ld-2.15.so (#806854) +- handle DW_TAG_unspecified_type and DW_TAG_rvalue_reference_type + (#810284, KDE#278313) +- handle .debug_types sections (#810286, KDE#284124) + +* Sun Mar 4 2012 Peter Robinson 3.7.0-2 +- Fix building on ARM platform + +* Fri Jan 27 2012 Jakub Jelinek 3.7.0-1 +- update to 3.7.0 (#769213, #782910, #772343) +- handle some further SCSI ioctls (#783936) +- handle fcntl F_SETOWN_EX and F_GETOWN_EX (#770746) + +* Wed Aug 17 2011 Adam Jackson 3.6.1-6 +- rebuild for rpm 4.9.1 trailing / bug + +* Thu Jul 21 2011 Jakub Jelinek 3.6.1-5 +- handle PLT unwind info (#723790, KDE#277045) + +* Mon Jun 13 2011 Jakub Jelinek 3.6.1-4 +- fix memcpy/memmove redirection on x86_64 (#705790) + +* Wed Jun 8 2011 Jakub Jelinek 3.6.1-3 +- fix testing against glibc 2.14 + +* Wed Jun 8 2011 Jakub Jelinek 3.6.1-2 +- fix build on ppc64 (#711608) +- don't fail if s390x support patch hasn't been applied, + move testing into %%check (#708522) +- rebuilt against glibc 2.14 + +* Wed Feb 23 2011 Jakub Jelinek 3.6.1-1 +- update to 3.6.1 + +* Mon Feb 07 2011 Fedora Release Engineering - 1:3.6.0-3 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_15_Mass_Rebuild + +* Fri Jan 28 2011 Jakub Jelinek 3.6.0-2 +- rebuilt against glibc 2.13 (#673046) +- hook in pwrite64 syscall on ppc64 (#672858) +- fix PIE handling on ppc/ppc64 (#665289) + +* Fri Nov 12 2010 Jakub Jelinek 3.6.0-1 +- update to 3.6.0 +- add s390x support (#632354) +- provide a replacement for str{,n}casecmp{,_l} (#626470) + +* Tue May 18 2010 Jakub Jelinek 3.5.0-18 +- rebuilt against glibc 2.12 + +* Mon Apr 12 2010 Jakub Jelinek 3.5.0-16 +- change pub_tool_basics.h not to include config.h (#579283) +- add valgrind-openmpi package for OpenMPI support (#565541) +- allow NULL second argument to capget (#450976) + +* Wed Apr 7 2010 Jakub Jelinek 3.5.0-15 +- handle i686 nopw insns with more than one data16 prefix (#574889) +- DWARF4 support +- handle getcpu and splice syscalls + +* Wed Jan 20 2010 Jakub Jelinek 3.5.0-14 +- fix build against latest glibc headers + +* Wed Jan 20 2010 Jakub Jelinek 3.5.0-13 +- DW_OP_mod is unsigned modulus instead of signed +- fix up valgrind.pc (#551277) + +* Mon Dec 21 2009 Jakub Jelinek 3.5.0-12 +- don't require offset field to be set in adjtimex's + ADJ_OFFSET_SS_READ mode (#545866) + +* Wed Dec 2 2009 Jakub Jelinek 3.5.0-10 +- add handling of a bunch of recent syscalls and fix some + other syscall wrappers (Dodji Seketeli) +- handle prelink created split of .bss into .dynbss and .bss + and similarly for .sbss and .sdynbss (#539874) + +* Wed Nov 4 2009 Jakub Jelinek 3.5.0-9 +- rebuilt against glibc 2.11 +- use upstream version of the ifunc support + +* Wed Oct 28 2009 Jakub Jelinek 3.5.0-8 +- add preadv/pwritev syscall support + +* Tue Oct 27 2009 Jakub Jelinek 3.5.0-7 +- add perf_counter_open syscall support (#531271) +- add handling of some sbb/adc insn forms on x86_64 (KDE#211410) + +* Fri Oct 23 2009 Jakub Jelinek 3.5.0-6 +- ppc and ppc64 fixes + +* Thu Oct 22 2009 Jakub Jelinek 3.5.0-5 +- add emulation of 0x67 prefixed loop* insns on x86_64 (#530165) + +* Wed Oct 21 2009 Jakub Jelinek 3.5.0-4 +- handle reading of .debug_frame in addition to .eh_frame +- ignore unknown DWARF3 expressions in evaluate_trivial_GX +- suppress helgrind race errors in helgrind's own mythread_wrapper +- fix compilation of x86 tests on x86_64 and ppc tests + +* Wed Oct 14 2009 Jakub Jelinek 3.5.0-3 +- handle many more DW_OP_* ops that GCC now uses +- handle the more compact form of DW_AT_data_member_location +- don't strip .debug_loc etc. from valgrind binaries + +* Mon Oct 12 2009 Jakub Jelinek 3.5.0-2 +- add STT_GNU_IFUNC support (Dodji Seketeli, #518247) +- wrap inotify_init1 syscall (Dodji Seketeli, #527198) +- fix mmap/mprotect handling in memcheck (KDE#210268) + +* Fri Aug 21 2009 Jakub Jelinek 3.5.0-1 +- update to 3.5.0 + +* Tue Jul 28 2009 Jakub Jelinek 3.4.1-7 +- handle futex ops newly added during last 4 years (#512121) + +* Sun Jul 26 2009 Fedora Release Engineering 3.4.1-6 +- Rebuilt for https://fedoraproject.org/wiki/Fedora_12_Mass_Rebuild + +* Mon Jul 13 2009 Jakub Jelinek 3.4.1-5 +- add support for DW_CFA_{remember,restore}_state + +* Mon Jul 13 2009 Jakub Jelinek 3.4.1-4 +- handle version 3 .debug_frame, .eh_frame, .debug_info and + .debug_line (#509197) + +* Mon May 11 2009 Jakub Jelinek 3.4.1-3 +- rebuilt against glibc 2.10.1 + +* Wed Apr 22 2009 Jakub Jelinek 3.4.1-2 +- redirect x86_64 ld.so strlen early (#495645) + +* Mon Mar 9 2009 Jakub Jelinek 3.4.1-1 +- update to 3.4.1 + +* Mon Feb 9 2009 Jakub Jelinek 3.4.0-3 +- update to 3.4.0 + +* Wed Apr 16 2008 Jakub Jelinek 3.3.0-3 +- add suppressions for glibc 2.8 +- add a bunch of syscall wrappers (#441709) + +* Mon Mar 3 2008 Jakub Jelinek 3.3.0-2 +- add _dl_start suppression for ppc/ppc64 + +* Mon Mar 3 2008 Jakub Jelinek 3.3.0-1 +- update to 3.3.0 +- split off devel bits into valgrind-devel subpackage + +* Thu Oct 18 2007 Jakub Jelinek 3.2.3-7 +- add suppressions for glibc >= 2.7 + +* Fri Aug 31 2007 Jakub Jelinek 3.2.3-6 +- handle new x86_64 nops (#256801, KDE#148447) +- add support for private futexes (KDE#146781) +- update License tag + +* Fri Aug 3 2007 Jakub Jelinek 3.2.3-5 +- add ppc64-linux symlink in valgrind ppc.rpm, so that when + rpm prefers 32-bit binaries over 64-bit ones 32-bit + /usr/bin/valgrind can find 64-bit valgrind helper binaries + (#249773) +- power5+ and power6 support (#240762) + +* Thu Jun 28 2007 Jakub Jelinek 3.2.3-4 +- pass GDB=%%{_prefix}/gdb to configure to fix default + --db-command (#220840) + +* Wed Jun 27 2007 Jakub Jelinek 3.2.3-3 +- add suppressions for glibc >= 2.6 +- avoid valgrind internal error if io_destroy syscall is + passed a bogus argument + +* Tue Feb 13 2007 Jakub Jelinek 3.2.3-2 +- fix valgrind.pc again + +* Tue Feb 13 2007 Jakub Jelinek 3.2.3-1 +- update to 3.2.3 + +* Wed Nov 8 2006 Jakub Jelinek 3.2.1-7 +- some cachegrind improvements (Ulrich Drepper) + +* Mon Nov 6 2006 Jakub Jelinek 3.2.1-6 +- fix valgrind.pc (#213149) +- handle Intel Core2 cache sizes in cachegrind (Ulrich Drepper) + +* Wed Oct 25 2006 Jakub Jelinek 3.2.1-5 +- fix valgrind on ppc/ppc64 where PAGESIZE is 64K (#211598) + +* Sun Oct 1 2006 Jakub Jelinek 3.2.1-4 +- adjust for glibc-2.5 + +* Wed Sep 27 2006 Jakub Jelinek 3.2.1-3 +- another DW_CFA_set_loc handling fix + +* Tue Sep 26 2006 Jakub Jelinek 3.2.1-2 +- fix openat handling (#208097) +- fix DW_CFA_set_loc handling + +* Tue Sep 19 2006 Jakub Jelinek 3.2.1-1 +- update to 3.2.1 bugfix release + - SSE3 emulation fixes, reduce memcheck false positive rate, + 4 dozens of bugfixes + +* Mon Aug 21 2006 Jakub Jelinek 3.2.0-5 +- handle the new i686/x86_64 nops (#203273) + +* Fri Jul 28 2006 Jeremy Katz - 1:3.2.0-4 +- rebuild to bring ppc back + +* Wed Jul 12 2006 Jesse Keating - 1:3.2.0-3.1 +- rebuild + +* Fri Jun 16 2006 Jakub Jelinek 3.2.0-3 +- handle [sg]et_robust_list syscall on ppc{32,64} + +* Fri Jun 16 2006 Jakub Jelinek 3.2.0-2 +- fix ppc64 symlink to 32-bit valgrind libdir +- handle a few extra ppc64 syscalls + +* Thu Jun 15 2006 Jakub Jelinek 3.2.0-1 +- update to 3.2.0 + - ppc64 support + +* Fri May 26 2006 Jakub Jelinek 3.1.1-3 +- handle [sg]et_robust_list syscalls on i?86/x86_64 +- handle *at syscalls on ppc +- ensure on x86_64 both 32-bit and 64-bit glibc{,-devel} are + installed in the buildroot (#191820) + +* Wed Apr 12 2006 Jakub Jelinek 3.1.1-2 +- handle many syscalls that were unhandled before, especially on ppc + +* Mon Apr 3 2006 Jakub Jelinek 3.1.1-1 +- upgrade to 3.1.1 + - many bugfixes + +* Mon Mar 13 2006 Jakub Jelinek 3.1.0-2 +- add support for DW_CFA_val_offset{,_sf}, DW_CFA_def_cfa_sf + and skip over DW_CFA_val_expression quietly +- adjust libc/ld.so filenames in glibc-2.4.supp for glibc 2.4 + release + +* Mon Jan 9 2006 Jakub Jelinek 3.1.0-1 +- upgrade to 3.1.0 (#174582) + - many bugfixes, ppc32 support + +* Thu Oct 13 2005 Jakub Jelinek 3.0.1-2 +- remove Obsoletes for valgrind-callgrind, as it has been + ported to valgrind 3.0.x already + +* Sun Sep 11 2005 Jakub Jelinek 3.0.1-1 +- upgrade to 3.0.1 + - many bugfixes +- handle xattr syscalls on x86-64 (Ulrich Drepper) + +* Fri Aug 12 2005 Jakub Jelinek 3.0.0-3 +- fix amd64 handling of cwtd instruction +- fix amd64 handling of e.g. sarb $0x4,val(%%rip) +- speedup amd64 insn decoding + +* Fri Aug 12 2005 Jakub Jelinek 3.0.0-2 +- lower x86_64 stage2 base from 112TB down to 450GB, so that + valgrind works even on 2.4.x kernels. Still way better than + 1.75GB that stock valgrind allows + +* Fri Aug 12 2005 Jakub Jelinek 3.0.0-1 +- upgrade to 3.0.0 + - x86_64 support +- temporarily obsolete valgrind-callgrind, as it has not been + ported yet + +* Tue Jul 12 2005 Jakub Jelinek 2.4.0-3 +- build some insn tests with -mmmx, -msse or -msse2 (#161572) +- handle glibc-2.3.90 the same way as 2.3.[0-5] + +* Wed Mar 30 2005 Jakub Jelinek 2.4.0-2 +- resurrect the non-upstreamed part of valgrind_h patch +- remove 2.1.2-4G patch, seems to be upstreamed +- resurrect passing -fno-builtin in memcheck tests + +* Sun Mar 27 2005 Colin Walters 2.4.0-1 +- New upstream version +- Update valgrind-2.2.0-regtest.patch to 2.4.0; required minor + massaging +- Disable valgrind-2.1.2-4G.patch for now; Not going to touch this, + and Fedora does not ship 4G kernel by default anymore +- Remove upstreamed valgrind-2.2.0.ioctls.patch +- Remove obsolete valgrind-2.2.0-warnings.patch; Code is no longer + present +- Remove upstreamed valgrind-2.2.0-valgrind_h.patch +- Remove obsolete valgrind-2.2.0-unnest.patch and + valgrind-2.0.0-pthread-stacksize.patch; valgrind no longer + includes its own pthread library + +* Thu Mar 17 2005 Jakub Jelinek 2.2.0-10 +- rebuilt with GCC 4 + +* Tue Feb 8 2005 Jakub Jelinek 2.2.0-8 +- avoid unnecessary use of nested functions for pthread_once + cleanup + +* Mon Dec 6 2004 Jakub Jelinek 2.2.0-7 +- update URL (#141873) + +* Tue Nov 16 2004 Jakub Jelinek 2.2.0-6 +- act as if NVALGRIND is defined when using + in non-m32/i386 programs (#138923) +- remove weak from VALGRIND_PRINTF*, make it static and + add unused attribute + +* Mon Nov 8 2004 Jakub Jelinek 2.2.0-4 +- fix a printout and possible problem with local variable + usage around setjmp (#138254) + +* Tue Oct 5 2004 Jakub Jelinek 2.2.0-3 +- remove workaround for buggy old makes (#134563) + +* Fri Oct 1 2004 Jakub Jelinek 2.2.0-2 +- handle some more ioctls (Peter Jones, #131967) + +* Thu Sep 2 2004 Jakub Jelinek 2.2.0-1 +- update to 2.2.0 + +* Thu Jul 22 2004 Jakub Jelinek 2.1.2-3 +- fix packaging of documentation + +* Tue Jul 20 2004 Jakub Jelinek 2.1.2-2 +- allow tracing of 32-bit binaries on x86-64 + +* Tue Jul 20 2004 Jakub Jelinek 2.1.2-1 +- update to 2.1.2 +- run make regtest as part of package build +- use glibc-2.3 suppressions instead of glibc-2.2 suppressions + +* Thu Apr 29 2004 Colin Walters 2.0.0-1 +- update to 2.0.0 + +* Tue Feb 25 2003 Jeff Johnson 1.9.4-0.20030228 +- update to 1.9.4 from CVS. +- dwarf patch from Graydon Hoare. +- sysinfo patch from Graydon Hoare, take 1. + +* Fri Feb 14 2003 Jeff Johnson 1.9.3-6.20030207 +- add return codes to syscalls. +- fix: set errno after syscalls. + +* Tue Feb 11 2003 Graydon Hoare 1.9.3-5.20030207 +- add handling for separate debug info (+fix). +- handle blocking readv/writev correctly. +- comment out 4 overly zealous pthread checks. + +* Tue Feb 11 2003 Jeff Johnson 1.9.3-4.20030207 +- move _pthread_desc to vg_include.h. +- implement pthread_mutex_timedlock(). +- implement pthread_barrier_wait(). + +* Mon Feb 10 2003 Jeff Johnson 1.9.3-3.20030207 +- import all(afaik) missing functionality from linuxthreads. + +* Sun Feb 9 2003 Jeff Johnson 1.9.3-2.20030207 +- import more missing functionality from linuxthreads in glibc-2.3.1. + +* Sat Feb 8 2003 Jeff Johnson 1.9.3-1.20030207 +- start fixing nptl test cases. + +* Fri Feb 7 2003 Jeff Johnson 1.9.3-0.20030207 +- build against current 1.9.3 with nptl hacks. + +* Tue Oct 15 2002 Alexander Larsson +- Update to 1.0.4 + +* Fri Aug 9 2002 Alexander Larsson +- Update to 1.0.0 + +* Wed Jul 3 2002 Alexander Larsson +- Update to pre4. + +* Tue Jun 18 2002 Alexander Larsson +- Add threadkeys and extra suppressions patches. Bump epoch. + +* Mon Jun 17 2002 Alexander Larsson +- Updated to 1.0pre1 + +* Tue May 28 2002 Alex Larsson +- Updated to 20020524. Added GLIBC_PRIVATE patch + +* Thu May 9 2002 Jonathan Blandford +- add missing symbol __pthread_clock_settime + +* Wed May 8 2002 Alex Larsson +- Update to 20020508 + +* Mon May 6 2002 Alex Larsson +- Update to 20020503b + +* Thu May 2 2002 Alex Larsson +- update to new snapshot + +* Mon Apr 29 2002 Alex Larsson 20020428-1 +- update to new snapshot + +* Fri Apr 26 2002 Jeremy Katz 20020426-1 +- update to new snapshot + +* Thu Apr 25 2002 Alex Larsson 20020424-5 +- Added stack patch. Commented out other patches. + +* Wed Apr 24 2002 Nalin Dahyabhai 20020424-4 +- filter out GLIBC_PRIVATE requires, add preload patch + +* Wed Apr 24 2002 Alex Larsson 20020424-3 +- Make glibc 2.2 and XFree86 4 the default supressions + +* Wed Apr 24 2002 Alex Larsson 20020424-2 +- Added patch that includes atomic.h + +* Wed Apr 24 2002 Alex Larsson 20020424-1 +- Initial build