Skip to content

Free games for graphing calculators: NumWorks, TI-Nspire CX, Casio fx-CG50 and soon TI-84 Plus CE. Balatro, Celeste, Hollow Knight, Minecraft and more.

Retro-Go: gwenesis' Mega Drive core, run on the computer

Mason3632434ca8c8891
diff --git a/games/retrogo/Makefile b/games/retrogo/Makefile
index 316eec49..96e3b65c 100644
--- a/games/retrogo/Makefile
+++ b/games/retrogo/Makefile
@@ -22,13 +22,14 @@ NES_SRC = $(addprefix src/nes/,nes6502.c nes_ppu.c nes_mmc.c mmclist.c nes_apu.c
$(sort $(wildcard src/nes/mappers/*.c))
SMS_SRC = src/sms/z80.c src/sms/sms.c src/sms/coleco_bios.c
GW_SRC = $(addprefix src/gw/,gw.c gw_state.c gw_system.c sm510base.c sm510core.c sm510op.c sm511core.c sm500core.c sm500op.c sm5acore.c)
-CORE_SRC = $(GB_SRC) $(NES_SRC) $(SMS_SRC) $(GW_SRC)
+MD_SRC = $(addprefix src/md/,md.c md_z80.c m68kcpu.c gwenesis_bus.c gwenesis_io.c gwenesis_vdp_mem.c gwenesis_vdp_gfx.c)
+CORE_SRC = $(GB_SRC) $(NES_SRC) $(SMS_SRC) $(GW_SRC) $(MD_SRC)
APP_SRC = src/main.c src/romtable.c src/pack.c
-CORE_H = $(wildcard src/*.h src/gb/*.h src/nes/*.h src/sms/*.h src/gw/*.h)
+CORE_H = $(wildcard src/*.h src/gb/*.h src/nes/*.h src/sms/*.h src/gw/*.h src/md/*.h) $(BUILD_DIR)/m68k_tab.h
HEADERS = $(CORE_H) ../common/epsilon_app.h ../common/epsilon_files.h ../common/np_text.h \
../../launcher/src/gfx.h ../../launcher/src/np.h ../../launcher/src/font.h
-CFLAGS = -std=gnu11 $(shell $(NWLINK) eadk-cflags-device) -Isrc/nes
+CFLAGS = -std=gnu11 $(shell $(NWLINK) eadk-cflags-device) -Isrc/nes -I$(BUILD_DIR)
CFLAGS += -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-implicit-fallthrough -Wno-missing-field-initializers
# (gnuboy and nofrendo as they were written)
CFLAGS += -Wno-old-style-declaration -Wno-misleading-indentation -Wno-unused-but-set-variable -Wno-maybe-uninitialized
@@ -67,6 +68,14 @@ $(BUILD_DIR)/font_data.o: ../../launcher/src/font_data.c ../../launcher/src/font
$(BUILD_DIR)/xfont.o: ../../launcher/src/xfont.c ../../launcher/src/np_xfont.h $(HEADERS)
$(Q) $(CC) $(CFLAGS) -Os -c $< -o $@
+# the 68000's opcode table (gwenesis' Musashi), made from its list of opcodes
+$(BUILD_DIR)/m68k_tab.h: tools/m68ktab.py src/md/m68kops.h
+ @mkdir -p $(BUILD_DIR)
+ $(Q) $(PY) tools/m68ktab.py src/md/m68kops.h $@
+# (gwenesis as it was written; its asserts off, as in Retro-Go)
+$(patsubst src/%.c,$(BUILD_DIR)/%.o,$(MD_SRC)) $(patsubst src/%.c,$(BUILD_DIR)/mod/%.o,$(MD_SRC)): CFLAGS += -DNDEBUG \
+ -Wno-unused-function -Wno-unused-variable -Wno-parentheses -Wno-unused-value -Wno-return-type -Wno-pointer-sign
+
# the games: tools/romtable.py makes the table, empty or with ROMS. It runs at every build and leaves
# the file as it is when it wouldn't change, so nothing is linked again for nothing.
$(BUILD_DIR)/roms.o: FORCE
@@ -106,7 +115,7 @@ $(BUILD_DIR)/sim-module.o: $(CORE_SRC) $(APP_SRC) $(HEADERS)
# ------------------------------------------------------------------ tests on this computer
HOST_CC = cc
-HOST_CFLAGS = -std=gnu11 -Isrc/nes -O1 -g -fsanitize=address,undefined -fno-sanitize-recover=undefined \
+HOST_CFLAGS = -std=gnu11 -Isrc/nes -I$(BUILD_DIR) -O1 -g -fsanitize=address,undefined -fno-sanitize-recover=undefined -fno-sanitize=alignment,shift \
-Wall -Wextra -Wno-unused-parameter -Wno-sign-compare -Wno-implicit-fallthrough -Wno-missing-field-initializers
TEST_ROMS ?= $(HOME)/Documents/Assets/gamesrc/retrogo/roms
$(BUILD_DIR)/host/core: tests/host_core.c $(CORE_SRC) $(CORE_H)
diff --git a/games/retrogo/src/md/LICENSE b/games/retrogo/src/md/LICENSE
new file mode 100644
index 00000000..0ad25db4
--- /dev/null
+++ b/games/retrogo/src/md/LICENSE
@@ -0,0 +1,661 @@
+ GNU AFFERO GENERAL PUBLIC LICENSE
+ Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+ A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate. Many developers of free software are heartened and
+encouraged by the resulting cooperation. However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+ The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community. It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server. Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+ An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals. This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU Affero General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Remote Network Interaction; Use with the GNU General Public License.
+
+ Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software. This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time. Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU Affero General Public License as published
+ by the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU Affero General Public License for more details.
+
+ You should have received a copy of the GNU Affero General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source. For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code. There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.
diff --git a/games/retrogo/src/md/gwenesis_bus.c b/games/retrogo/src/md/gwenesis_bus.c
new file mode 100644
index 00000000..6889ddae
--- /dev/null
+++ b/games/retrogo/src/md/gwenesis_bus.c
@@ -0,0 +1,688 @@
+/*
+Gwenesis : Genesis & megadrive Emulator.
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = "bzhxx"
+__contact__ = "https://github.com/bzhxx"
+__license__ = "GPLv3"
+
+*/
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+#include <ctype.h>
+
+#include "m68k.h"
+
+#include "z80inst.h"
+#include "gwenesis_bus.h"
+#include "gwenesis_io.h"
+#include "gwenesis_vdp.h"
+#include "gwenesis_savestate.h"
+
+/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound
+ chips' writes go nowhere; and nothing printed) */
+#define YM2612Read(clk) 0
+#define YM2612Write(a, v, clk) ((void)0)
+#define YM2612Init() ((void)0)
+#define YM2612Config(x) ((void)0)
+#define YM2612ResetChip() ((void)0)
+#define gwenesis_SN76489_Write(v, clk) ((void)0)
+#define gwenesis_SN76489_Init(a, b, c) ((void)0)
+#define gwenesis_SN76489_Reset() ((void)0)
+#define printf(...) ((void)0)
+#define vfprintf(...) ((void)0)
+/* (the Z80's 8 KB of RAM in two pages of 4 KB, md.c) */
+extern unsigned char *md_zram[2];
+#define ZRAM_AT(a) (md_zram[((a) >> 12) & 1][(a) & 0xFFF])
+
+#if GNW_TARGET_MARIO !=0 || GNW_TARGET_ZELDA!=0
+ #pragma GCC optimize("Ofast")
+#endif
+
+#define BUS_DISABLE_LOGGING 1
+
+#if !BUS_DISABLE_LOGGING
+#include <stdarg.h>
+void bus_log(const char *subs, const char *fmt, ...) {
+ extern int frame_counter;
+ extern int scan_line;
+
+ va_list va;
+
+ printf("%06d:%03d :[%s] vc:%04x hc:%04x hv:%04x ", frame_counter, scan_line, subs,gwenesis_vdp_vcounter(),gwenesis_vdp_hcounter(),gwenesis_vdp_hvcounter());
+
+ va_start(va, fmt);
+ vfprintf(stdout, fmt, va);
+ va_end(va);
+ printf("\n");
+}
+#else
+ #define bus_log(...) do {} while(0)
+#endif
+
+// Setup M68k memories ROM & RAM
+#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0
+
+#include "rom_manager.h"
+unsigned char *M68K_RAM=(void *)(uint32_t)(0); // 68K RAM
+#else
+
+unsigned char *ROM_DATA; // 68K Main Program (uncompressed)
+unsigned int md_rom_mask; // (NumPlay: the ROM's size rounded up to a power of two, less one)
+#endif
+
+
+// Setup Z80 Memory
+unsigned char TMSS[0x4];
+extern unsigned short gwenesis_vdp_status;
+
+// TMSS
+int tmss_state = 0;
+int tmss_count = 0;
+
+/******************************************************************************
+ *
+ * Load a Sega Genesis Cartridge into CPU Memory
+ *
+ ******************************************************************************/
+
+
+#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0
+
+void load_cartridge()
+{
+ // Clear all volatile memory
+ memset(M68K_RAM, 0, MAX_RAM_SIZE);
+ memset(ZRAM, 0, MAX_Z80_RAM_SIZE);
+
+ // Set Z80 Memory as Z80_RAM
+ z80_set_memory(ZRAM);
+
+ z80_pulse_reset();
+
+ set_region();
+
+}
+#else
+
+void load_cartridge(unsigned char *buffer, size_t size)
+{
+ /* (NumPlay: the RAMs are cleared by md.c, which places them; the ROM is read in place, made
+ plain and its bytes swapped when it went in, tools/romtable.py) */
+ z80_pulse_reset();
+ ROM_DATA = buffer;
+ md_rom_mask = 1;
+ while (md_rom_mask < size) md_rom_mask <<= 1;
+ md_rom_mask--;
+ set_region();
+}
+
+#endif
+
+/******************************************************************************
+ *
+ * Power ON the CPU
+ * Initialize 68K, Z80 and YM2612 Cores
+ *
+ ******************************************************************************/
+void power_on() {
+ // Set M68K CPU as original MOTOROLA 68000
+ //m68k_set_cpu_type(M68K_CPU_TYPE_68000);
+ // Initialize M68K CPU
+ m68k_init();
+ // Initialize Z80 CPU
+ z80_start();
+ // Initialize YM2612 chip
+ YM2612Init();
+ YM2612Config(9);
+ // Initialize PSG SN76489 chip
+ //CLOCK_NTSC = 3579545,
+ //CLOCK_PAL = 3546895,
+ // CLOCK_NTSC_SMS1 = 3579527
+
+// if (mode_pal) {
+// gwenesis_SN76489_Init(3546895, GWENESIS_AUDIO_BUFFER_LENGTH_PAL*50,AUDIO_FREQ_DIVISOR);
+// } else{
+// gwenesis_SN76489_Init(3579545, GWENESIS_AUDIO_BUFFER_LENGTH_NTSC*60,AUDIO_FREQ_DIVISOR);
+// }
+
+ gwenesis_SN76489_Init(3579545, 888*60,AUDIO_FREQ_DIVISOR);
+
+}
+
+/******************************************************************************
+ *
+ * Reset the CPU Emulation
+ * Send a pulse reset to 68K, Z80 and YM2612 Cores
+ *
+ ******************************************************************************/
+void reset_emulation() {
+ // Send a reset pulse to Z80 CPU
+ z80_pulse_reset();
+ // Send a reset pulse to Z80 M68K
+ m68k_pulse_reset();
+ // Send a reset pulse to YM2612 chip
+ YM2612ResetChip();
+ // Send a reset pulse to SEGA 315-5313 chip
+ gwenesis_vdp_reset();
+ gwenesis_SN76489_Reset();
+}
+
+/******************************************************************************
+ *
+ * Set Region
+ * Look at ROM to set console compatible region
+ *
+ ******************************************************************************/
+void set_region()
+{
+ /*
+ old style : JUE characters
+ J : Domestic 60Hz (Asia)
+ U : Oversea 60Hz (USA)
+ E : Oversea 50Hz (Europe)
+
+ new style : 1st character
+ bit 0 : +1 Domestic 60Hz (Asia)
+ bit 1 : +2 Domestc 50Hz (Asia)
+ bit 2: +4 Oversea 60Hz (USA)
+ bit 3: +4 Oversea 50Hz (Europe)
+ */
+
+ // extern int mode_pal;
+
+ int country = 0;
+
+ char rom_str[3];
+
+ printf("ROM game : ");
+ for (int j=0; j < 48;j++) printf("%c",(char)FETCH8ROM(0x150+j));
+ printf("\n");
+
+ rom_str[0]=FETCH8ROM(0x1F0);
+ rom_str[1]=FETCH8ROM(0x1F1);
+ rom_str[2]=FETCH8ROM(0x1F2);
+
+ printf("ROM region:%c%c%c (0x%02x 0x%02x 0x%02x)\n", rom_str[0],rom_str[1],rom_str[2],rom_str[0],rom_str[1],rom_str[2]);
+
+ /* from Gens */
+ if (!memcmp(rom_str, "eur", 3)) country |= 8;
+ else if (!memcmp(rom_str, "EUR", 3)) country |= 8;
+ else if (!memcmp(rom_str, "Europe", 3)) country |= 8;
+ else if (!memcmp(rom_str, "jap", 3)) country |= 1;
+ else if (!memcmp(rom_str, "JAP", 3)) country |= 1;
+ else if (!memcmp(rom_str, "usa", 3)) country |= 4;
+ else if (!memcmp(rom_str, "USA", 3)) country |= 4;
+ else
+ {
+ int i;
+ unsigned char c;
+
+ /* look for each characters */
+ for(i = 0; i < 3; i++)
+ {
+ c = rom_str[i];
+
+ if (c == 'U') country |= 4;
+ else if (c == 'E' || c == 'e' ) country |= 8;
+ else if (c == 'J' || c == 'j' ) country |= 1;
+ else if (c == 'K' || c == 'k' ) country |= 1;
+ else if (c < 16) country |= c;
+ else if ((c >= '0') && (c <= '9')) country |= c - '0';
+ else if ((c >= 'A') && (c <= 'F')) country |= c - 'A' + 10;
+ }
+ }
+ printf("country code=%01x : ",country);
+ /* set default console region (USA > EUROPE > JAPAN) */
+ /*
+ IO REG0 : MODE VMOD DISK RSV VER3 VER2 VER1 VER0
+ MODE (R) 0: Domestic Model
+ 1: Overseas Model
+ VMOD (R) 0: NTSC CPU clock 7.67 MHz
+ 1: PAL CPU clock 7.60 MHz
+ */
+
+ /* USA 60Hz*/
+ if (country & 4){
+ printf("Oversea-NTSC USA 60Hz\n");
+ gwenesis_io_set_reg(0, 0x81);
+ // gwenesis_vdp_status &= 0xFFFE;
+ // mode_pal = 0;
+ return;
+ }
+ /* EUROPE 50Hz */
+ if (country & 8){
+ printf("Oversea-PAL Europe 50Hz\n");
+ gwenesis_io_set_reg(0, 0xC1);
+ // gwenesis_vdp_status |= 0x1;
+ //mode_pal = 1;
+ return;
+ }
+ /* set Asia 60HZ */
+ if (country & 1){
+ printf("Domestic-NTSC Asia 60Hz\n");
+ gwenesis_io_set_reg(0, 0x1);
+ // gwenesis_vdp_status &= 0xFFFE;
+ //mode_pal = 0;
+ return;
+ }
+ printf("Oversea-NTSC USA 60Hz no detection>> default mode\n");
+ gwenesis_io_set_reg(0, 0x81);
+ // gwenesis_vdp_status &= 0xFFFE;
+ // mode_pal = 0;
+
+}
+/******************************************************************************
+ *
+ * Main memory address mapper
+ * Map all main memory region address for CPU program
+ * 68K Access to Z80 Memory
+ *
+ ******************************************************************************/
+static inline unsigned int gwenesis_bus_map_z80_address(unsigned int address) {
+
+ unsigned int range = (address & 0xF000);
+ switch (range) {
+ case 0:
+ case 0x1000:
+ return Z80_RAM_ADDR;
+ case 0x2000:
+ case 0x3000:
+ return Z80_RAM_ADDR1K;
+ case 0x4000:
+ return Z80_YM2612_ADDR;
+ case 0x6000:
+ return Z80_BANK_ADDR;
+ case 0x7000:
+ return Z80_SN76489_ADDR;
+ default:
+ bus_log(__FUNCTION__,"no map Z80 %x",address);
+ assert(0);
+ return NONE;
+ }
+}
+
+/******************************************************************************
+ *
+ * IO memory address mapper
+ * Map all input/output region address for CPU program
+ *
+ ******************************************************************************/
+static inline unsigned int gwenesis_bus_map_io_address(unsigned int address)
+{
+ unsigned int range = (address & 0x1000) ;
+ switch (range) {
+ case 0: return IO_CTRL;
+ case 0x1000: return Z80_CTRL;
+ default:
+ // if (address >= 0xa14000 && address < 0xa11404)
+ // return (tmss_state == 0) ? TMSS_CTRL : NONE;
+ bus_log(__FUNCTION__,"no map io %x",address);
+
+ return NONE;
+ }
+}
+
+/******************************************************************************
+ *
+ * Main memory address mapper
+ * Map all main memory region address for CPU program
+ *
+ ******************************************************************************/
+
+static inline
+unsigned int gwenesis_bus_map_address(unsigned int address) {
+ // Mask address page
+ unsigned int range = (address & 0xFF0000) >> 16;
+
+ // Check mask and select memory type
+ if (range < 0x80) // ROM ADDRESS 0x000000 - 0x3FFFFF
+ return ROM_ADDR;
+
+ else if (range == 0xA0) // Z80 ADDRESS 0xA00000 - 0xA0FFFF
+ return gwenesis_bus_map_z80_address(address);
+
+
+ else if (range == 0xA1) // IO ADDRESS 0xA10000 - 0xA1FFFF
+ return gwenesis_bus_map_io_address(address);
+
+ else if (range == 0xC0) // VDP ADDRESS 0xC00000 - 0xDFFFFFF
+ return VDP_ADDR;
+ else if (range == 0xFF) // RAM ADDRESS 0xE00000 - 0xFFFFFFF
+ return RAM_ADDR;
+ // If not a valid address return 0
+ bus_log(__FUNCTION__,"M68K > ?? unnmap address %x", address);
+ //assert(0);
+ return NONE;
+}
+/******************************************************************************
+ *
+ * Main read address routine
+ * Write an value to memory mapped on specified address
+ *
+ ******************************************************************************/
+static inline unsigned int gwenesis_bus_read_memory_8(unsigned int address) {
+ bus_log(__FUNCTION__,"read8 %x", address);
+
+ switch (gwenesis_bus_map_address(address)) {
+
+ case VDP_ADDR:
+ return gwenesis_vdp_read_memory_8(address);
+
+ case ROM_ADDR:
+ return FETCH8ROM(address);
+
+ case RAM_ADDR:
+ return FETCH8RAM(address);
+
+ case IO_CTRL:
+ return gwenesis_io_read_ctrl(address & 0x1F);
+
+ case Z80_CTRL:
+ return z80_read_ctrl(address & 0xFFFF);
+
+ case Z80_RAM_ADDR:
+ case Z80_RAM_ADDR1K:
+ return ZRAM_AT(address);
+
+ case Z80_YM2612_ADDR:
+ return YM2612Read(m68k_cycles_master());
+
+ case Z80_SN76489_ADDR:
+ return 0xff;
+
+ case Z80_BANK_ADDR:
+ return 0xff;
+
+ case TMSS_CTRL:
+ bus_log(__FUNCTION__,"TMS");
+ if (tmss_state == 0)
+ return TMSS[address & 0x4];
+ return 0xFF;
+
+ default:
+ bus_log(__FUNCTION__," default read 8 %x", address);
+ return 0x00;
+ }
+ return 0x00;
+}
+
+static inline unsigned int gwenesis_bus_read_memory_16(unsigned int address) {
+ bus_log(__FUNCTION__,"read16 %x", address);
+ unsigned int ret_value;
+
+ switch (gwenesis_bus_map_address(address)) {
+
+ case VDP_ADDR:
+ return gwenesis_vdp_read_memory_16(address);
+
+ case RAM_ADDR:
+ return FETCH16RAM(address);
+
+ case ROM_ADDR:
+ return FETCH16ROM(address);
+
+ case IO_CTRL:
+ return gwenesis_io_read_ctrl(address & 0x1F);
+
+ case Z80_CTRL:
+ // ret_value = z80_read_ctrl(address & 0xFFFF);
+ // return ret_value | ret_value << 8;
+ address &=0xFFFF;
+ return (z80_read_ctrl(address) << 8) | z80_read_ctrl(address | 1);
+
+
+ case Z80_RAM_ADDR:
+ case Z80_RAM_ADDR1K:
+ return ZRAM_AT(address) | (ZRAM_AT(address) << 8);
+
+ case Z80_YM2612_ADDR:
+ ret_value = YM2612Read(m68k_cycles_master());
+ return ret_value | ret_value << 8;
+
+
+ case Z80_SN76489_ADDR:
+ return 0xff;
+
+ case Z80_BANK_ADDR:
+ return 0xff;
+
+ default:
+ bus_log(__FUNCTION__,"read mem 16 default %x", address);
+ return (gwenesis_bus_read_memory_8(address) << 8) |
+ gwenesis_bus_read_memory_8(address + 1);
+ }
+ return 0x00;
+}
+
+/******************************************************************************
+ *
+ * Main write address routine
+ * Write an value to memory mapped on specified address
+ *
+ ******************************************************************************/
+static inline void gwenesis_bus_write_memory_8(unsigned int address,
+ unsigned int value) {
+ bus_log(__FUNCTION__,"write8 @%x:%x", address,value);
+
+ switch (gwenesis_bus_map_address(address)) {
+
+ case VDP_ADDR:
+ gwenesis_vdp_write_memory_16(address & ~1, (value << 8) | value);
+ return;
+
+ case RAM_ADDR:
+ WRITE8RAM(address, value);
+ return;
+
+ case IO_CTRL:
+ gwenesis_io_write_ctrl(address & 0x1F, value);
+ return;
+
+ case Z80_CTRL:
+ z80_write_ctrl(address & 0x1FFF, value);
+ return;
+
+ case Z80_RAM_ADDR:
+ case Z80_RAM_ADDR1K:
+ ZRAM_AT(address) = value;
+ return;
+
+ case Z80_YM2612_ADDR:
+ bus_log(__FUNCTION__,"CPUZ80PSG8 ,m68kclk= %d", m68k_cycles_master());
+ YM2612Write(address & 0x3, value & 0Xff,m68k_cycles_master());
+ return;
+
+ case Z80_SN76489_ADDR:
+ bus_log(__FUNCTION__,"CPUZ80FM8 ,m68kclk= %d", m68k_cycles_master());
+ gwenesis_SN76489_Write( value & 0Xff, m68k_cycles_master());
+ return;
+
+ case Z80_BANK_ADDR:
+ //TODO
+ return;
+
+ case TMSS_CTRL:
+
+ if (tmss_state == 0) {
+ TMSS[address & 0x4] = value;
+ tmss_count++;
+ if (tmss_count == 4)
+ tmss_state = 1;
+ }
+ return;
+
+
+
+ default:
+ //printf("write(%x, %x)\n", address, value);
+ return;
+ }
+ return;
+}
+
+static inline void gwenesis_bus_write_memory_16(unsigned int address,
+ unsigned int value) {
+ bus_log(__FUNCTION__,"write16 @%x:%x", address,value);
+
+ switch (gwenesis_bus_map_address(address)) {
+
+ case VDP_ADDR:
+ gwenesis_vdp_write_memory_16(address, value);
+ return;
+
+ case RAM_ADDR:
+ WRITE16RAM(address, value);
+ return;
+
+ case Z80_RAM_ADDR:
+ case Z80_RAM_ADDR1K:
+ ZRAM_AT(address) = value >> 8;
+ return;
+
+ case IO_CTRL:
+ gwenesis_io_write_ctrl(address & 0x1F, value);
+ return;
+
+ case Z80_CTRL:
+ z80_write_ctrl(address & 0xFFFF, value >> 8) ;
+ return;
+
+ case Z80_YM2612_ADDR:
+ bus_log(__FUNCTION__,"CZYM16 ,mclk=%d", m68k_cycles_master());
+ YM2612Write(address & 0x3, value >> 8,m68k_cycles_master() );
+ return;
+
+ case Z80_SN76489_ADDR:
+ bus_log(__FUNCTION__,"CZSN16 ,mclk=%d", m68k_cycles_master());
+ gwenesis_SN76489_Write(value >> 8,m68k_cycles_master() );
+ return;
+
+ default:
+ bus_log(__FUNCTION__,"write mem 16 default %x ", address);
+ gwenesis_bus_write_memory_8(address, (value >> 8) & 0xff);
+ gwenesis_bus_write_memory_8(address + 1, (value)&0xff);
+
+ return;
+ }
+ return;
+}
+
+/******************************************************************************
+ *
+ * 68K CPU read address R8
+ * Read an address from memory mapped and return value as byte
+ *
+ ******************************************************************************/
+unsigned int m68k_read_memory_8(unsigned int address)
+{
+ // if ((address & 0xFF0000 ) == 0xFF0000) return FETCH8RAM(address);
+ return gwenesis_bus_read_memory_8(address);
+}
+
+/******************************************************************************
+ *
+ * 68K CPU read address R16
+ * Read an address from memory mapped and return value as word
+ *
+ ******************************************************************************/
+ unsigned int m68k_read_memory_16(unsigned int address)
+{
+ // if ((address & 0xFF0000 ) == 0xFF0000) return FETCH16RAM(address);
+ return gwenesis_bus_read_memory_16(address);
+}
+
+/******************************************************************************
+ *
+ * 68K CPU read address R32
+ * Read an address from memory mapped and return value as long
+ *
+ ******************************************************************************/
+ unsigned int m68k_read_memory_32(unsigned int address)
+{
+ // if ((address & 0xFF0000 ) == 0xFF0000) return FETCH32RAM(address);
+ return (gwenesis_bus_read_memory_16(address) << 16) | gwenesis_bus_read_memory_16(address + 2);
+}
+
+/******************************************************************************
+ *
+ * 68K CPU write address W8
+ * Write an value as byte to memory mapped on specified address
+ *
+ ******************************************************************************/
+void m68k_write_memory_8(unsigned int address, unsigned int value) {
+ // if ((address & 0xFF0000) == 0xFF0000) {
+ // WRITE8RAM(address, value);
+ // return;
+ // }
+ gwenesis_bus_write_memory_8(address, value);
+ return;
+}
+
+/******************************************************************************
+ *
+ * 68K CPU write address W16
+ * Write an value as word to memory mapped on specified address
+ *
+ ******************************************************************************/
+void m68k_write_memory_16(unsigned int address, unsigned int value) {
+ // if ((address & 0xFF0000) == 0xFF0000) {
+ // WRITE16RAM(address, value);
+ // return;
+ // }
+ gwenesis_bus_write_memory_16(address, value);
+ return;
+}
+/******************************************************************************
+ *
+ * 68K CPU write address W32
+ * Write an value as word to memory mapped on specified address
+ *
+ ******************************************************************************/
+void m68k_write_memory_32(unsigned int address, unsigned int value) {
+
+ // if ((address & 0xFF0000) == 0xFF0000) {
+ // WRITE32RAM(address, value);
+ // return;
+ // }
+ gwenesis_bus_write_memory_16(address, (value >> 16) & 0xffff);
+ gwenesis_bus_write_memory_16(address + 2, (value)&0xffff);
+
+ return;
+}
+
+unsigned int m68k_read_disassembler_16(unsigned int address)
+{
+ return m68k_read_memory_16(address);
+}
+unsigned int m68k_read_disassembler_32(unsigned int address)
+{
+ return m68k_read_memory_32(address);
+}
+
+void gwenesis_bus_save_state() {
+ SaveState* state;
+ state = saveGwenesisStateOpenForWrite("bus");
+ /* (the RAMs are parts of the state of their own, md.c) */
+ saveGwenesisStateSetBuffer(state, "TMSS", TMSS, sizeof(TMSS));
+ saveGwenesisStateSet(state, "tmss_state", tmss_state);
+ saveGwenesisStateSet(state, "tmss_count", tmss_count);
+}
+
+void gwenesis_bus_load_state() {
+ SaveState* state = saveGwenesisStateOpenForRead("bus");
+ saveGwenesisStateGetBuffer(state, "TMSS", TMSS, sizeof(TMSS));
+ tmss_state = saveGwenesisStateGet(state, "tmss_state");
+ tmss_count = saveGwenesisStateGet(state, "tmss_count");
+}
\ No newline at end of file
diff --git a/games/retrogo/src/md/gwenesis_bus.h b/games/retrogo/src/md/gwenesis_bus.h
new file mode 100644
index 00000000..43ddc9ff
--- /dev/null
+++ b/games/retrogo/src/md/gwenesis_bus.h
@@ -0,0 +1,101 @@
+/*
+Gwenesis : Genesis & megadrive Emulator.
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = "bzhxx"
+__contact__ = "https://github.com/bzhxx"
+__license__ = "GPLv3"
+
+*/
+#ifndef _gwenesis_bus_H_
+#define _gwenesis_bus_H_
+
+#pragma once
+
+#include <stdio.h>
+#include <string.h>
+
+#define MAX_ROM_SIZE 0x800000
+#define MAX_RAM_SIZE 0x10000
+#define MAX_Z80_RAM_SIZE 8192
+
+// NTSC PAL timings
+#define MCLOCK_PAL 53203424
+#define MCLOCK_NTSC 53693175
+
+#define MCYCLES_PER_FRAME_NTSC 896040
+#define MCYCLES_PER_FRAME_PAL 1067040
+#define LINES_PER_FRAME_NTSC 262
+#define LINES_PER_FRAME_PAL 313
+
+#define GWENESIS_REFRESH_RATE_NTSC 60
+#define GWENESIS_AUDIO_FREQ_NTSC 53267
+
+#define GWENESIS_REFRESH_RATE_PAL 50
+#define GWENESIS_AUDIO_FREQ_PAL 52781
+
+#define GWENESIS_AUDIO_ACCURATE 1
+
+#define Z80_FREQ_DIVISOR 14 // Frequency divisor to Z80 clock
+#define VDP_CYCLES_PER_LINE 3420// VDP Cycles per Line
+#define SCREEN_WIDTH 320
+
+#define AUDIO_FREQ_DIVISOR 1009
+#define GWENESIS_AUDIO_BUFFER_LENGTH_NTSC 888
+#define GWENESIS_AUDIO_BUFFER_LENGTH_PAL 1056
+
+/* Audio buffer length */
+
+enum mapped_address
+{
+ NONE = 0,
+ ROM_ADDR,
+ ROM_ADDR_MIRROR,
+ Z80_RAM_ADDR,
+ Z80_RAM_ADDR1K,
+ Z80_YM2612_ADDR,
+ Z80_BANK_ADDR,
+ Z80_VDP_ADDR,
+ Z80_SN76489_ADDR,
+ IO_CTRL,
+ Z80_CTRL,
+ TMSS_CTRL,
+ VDP_ADDR,
+ RAM_ADDR
+};
+
+enum gwenesis_bus_pad_button
+{
+ PAD_UP,
+ PAD_DOWN,
+ PAD_LEFT,
+ PAD_RIGHT,
+ PAD_B,
+ PAD_C,
+ PAD_A,
+ PAD_S
+};
+
+#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0
+void load_cartridge();
+#else
+void load_cartridge(unsigned char *buffer, size_t size);
+#endif
+
+void power_on();
+void reset_emulation();
+void set_region();
+
+void gwenesis_bus_save_state();
+void gwenesis_bus_load_state();
+
+#endif
\ No newline at end of file
diff --git a/games/retrogo/src/md/gwenesis_io.c b/games/retrogo/src/md/gwenesis_io.c
new file mode 100644
index 00000000..2f8d2b1c
--- /dev/null
+++ b/games/retrogo/src/md/gwenesis_io.c
@@ -0,0 +1,252 @@
+/*
+Gwenesis : Genesis & megadrive Emulator.
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = "bzhxx"
+__contact__ = "https://github.com/bzhxx"
+__license__ = "GPLv3"
+
+*/
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+#include "gwenesis_io.h"
+#include "gwenesis_savestate.h"
+
+/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound
+ chips' writes go nowhere; and nothing printed) */
+#define YM2612Read(clk) 0
+#define YM2612Write(a, v, clk) ((void)0)
+#define YM2612Init() ((void)0)
+#define YM2612Config(x) ((void)0)
+#define YM2612ResetChip() ((void)0)
+#define gwenesis_SN76489_Write(v, clk) ((void)0)
+#define gwenesis_SN76489_Init(a, b, c) ((void)0)
+#define gwenesis_SN76489_Reset() ((void)0)
+#define printf(...) ((void)0)
+#define vfprintf(...) ((void)0)
+
+unsigned char button_state[3]= {0xff,0xff,0xff};
+
+/* Button mapping
+ 7 6 5 4 3 2 1 0
+Start A B C R L D U
+*/
+static unsigned char gwenesis_io_pad_state[3] = {0x33,0x33,0x33};
+
+#define GWENESIS_IO_VERSION 0x81 /* oversea NTSC model version 81 */
+/*
+$A10003 : MODE VMOD DISK RSV VER3 VER2 VER1 VER0
+MODE (R) 0: Domestic Model
+ 1: Overseas Model
+VMOD (R) 0: NTSC CPU clock 7.67 MHz
+ 1: PAL CPU clock 7.60 MHz
+RSV (R) Currently not used
+VER3-0 (R) MEGA DRIVE version is indicated by $0-$F. The present hardware version is indicated by $0.
+$A10003 : DATA 1 ( CTRL1 )
+$A10005 : DATA 2 ( CTRL2 )
+$A10007 : DATA 3 ( EXP )
+$A10009 : CTRL 1
+$A1000B : CTRL 2
+$A1000D : CTRL 3
+$A1000F : TxDATA 1
+$A10011 : RxDATA 1
+$A10013 : S-CTRL 1
+$A10015 : TxDATA 2
+$A10017 : RxDATA 2
+$A10019 : S-CTRL 2
+$A1001B : TxDATA 3
+$A1001D : RxDATA 3
+$A1001F : S-CTRL 3
+
+DATA shows the status of each port. The I/O direction of each bit is set by CTRL and S-CTRL.
+DATA = PD7 PD6 PD5 PD4 PD3 PD2 PD1 PD0
+
+PD7 (RW)
+PD6 (RW) TH
+PD5 (RW) TR
+PD4 (RW) TL
+PD3 (RW) RIGHT
+PD2 (RW) LEFT
+PD1 (RW) DOWN
+PD0 (RW) UP
+
+TH = 0
+PD7 0
+PD6 TH=0
+PD5 Start
+PD4 A
+PD3 0
+PD2 0
+PD1 DOWN
+PD0 UP
+
+TH = 1
+PD7 0
+PD6 TH=1
+PD5 B
+PD4 C
+PD3 RIGHT
+PD2 LEFT
+PD1 DOWN
+PD0 UP
+
+
+CTRL designates the I/O direction of each port and the INTERRUPT CONTROL of TH.
+CTRL = INT PC6 PC5 PC4 PC3 PC2 PC1 PC0
+
+INT (RW) 0: TH-INT PROHIBITED
+ 1: TH-INT ALLOWED
+PC6 (RW) 0: PD6 INPUT MODE
+ 1: OUTPUT MODE
+PC5 (RW) 0: PD5 INPUT MODE
+ 1: OUTPUT MODE
+PC4 (RW) 0: PD4 INPUT MODE
+ 1: OUTPUT MODE
+PC3 (RW) 0: PD3 INPUT MODE
+ 1: OUTPUT MODE
+PC2 (RW) 0: PD2 INPUT MODE
+ 1: OUTPUT MODE
+PC1 (RW) 0: PD1 INPUT MODE
+ 1: OUTPUT MODE
+PC0 (RW) 0: PD0 INPUT MODE
+ 1: OUTPUT MODE
+
+S-CTRL is for the status, etc. of each port's mode change, baud rate and SERIAL.
+
+S-CTRL = BPS1 BPS0 SIN SOUT RINT RERR RRDY TFUL
+
+SIN (RW) 0: TR-PARALLEL MODE
+ 1: SERIAL IN
+SOUT (RW) 0: TL-PARALLEL MODE
+ 1: SERIAL OUT
+RINT (RW) 0: Rxd READY INTERRUPT PROHIBITED
+ 1: Rxd READY INTERRUPT ALLOWED
+RERR (R) 0:
+ 1: Rxd ERROR
+RRDY (R) 0:
+ 1: Rxd READY
+TFUL (R) 0:
+ 1: Txd FULL
+*/
+
+unsigned char io_reg[16] = {GWENESIS_IO_VERSION, /* 0x1 Version */
+ 0x7f, 0x7f, 0x7f, /* 0x3-5-7 JOYPAD DATA 1 2 & EXT */
+ 0x00, 0x00, 0x00, /* 0x9-A-C JOYPAD CTRL 1 2 & EXT */
+ 0xff, 0, 0, /* PORT 1 */
+ 0xff, 0, 0, /* PORT 2 */
+ 0xff, 0, 0}; /* PORT 3 */
+
+void gwenesis_io_pad_release_button(int pad, int button)
+{
+ button_state[pad] |= (1 << button);
+}
+
+void gwenesis_io_pad_press_button(int pad, int button)
+{
+ button_state[pad] &= ~(1 << button);
+}
+
+static inline void gwenesis_io_pad_write(int pad, int value)
+{
+ unsigned char mask = io_reg[pad + 4];
+
+ gwenesis_io_pad_state[pad] &= ~mask;
+ gwenesis_io_pad_state[pad] |= value & mask;
+
+}
+
+static inline unsigned char gwenesis_io_pad_read(int pad)
+{
+ unsigned char value;
+
+ /* get host button */
+ gwenesis_io_get_buttons();
+
+ value = gwenesis_io_pad_state[pad] & 0x40;
+ value |= 0x3f;
+
+ if (value & 0x40)
+ {
+ value &= (button_state[pad] & 0x3f);
+ }
+ else
+ {
+ value &= ((button_state[pad] & 3) | ((button_state[pad] >> 2) & 0x30));
+ }
+ return value;
+}
+
+void gwenesis_io_write_ctrl(unsigned int address, unsigned int value)
+{
+
+ address >>= 1;
+
+ // JOYPAD DATA
+ if (address >= 0x1 && address <= 0x3)
+ {
+
+ io_reg[address] = value;
+ gwenesis_io_pad_write(address - 1, value);
+ return;
+ }
+ // JOYPAD CTRL
+ else if (address >= 0x4 && address <= 0x6)
+ {
+ if (io_reg[address] != value)
+ {
+ io_reg[address] = value;
+ gwenesis_io_pad_write(address - 4, io_reg[address - 3]);
+ }
+ return;
+ }
+
+ return;
+}
+
+unsigned int gwenesis_io_read_ctrl(unsigned int address)
+{
+ address >>= 1;
+ if (address >= 0x1 && address < 0x4)
+ {
+ unsigned char mask = 0x80 | io_reg[address + 3];
+ unsigned char value;
+ value = io_reg[address] & mask;
+ value |= gwenesis_io_pad_read(address - 1) & ~mask;
+
+ return value;
+ }
+ else
+ {
+ return io_reg[address];
+ }
+}
+
+void gwenesis_io_set_reg(unsigned int reg, unsigned int value) {
+ io_reg[reg] = value;
+ return;
+}
+
+void gwenesis_io_save_state() {
+ SaveState* state;
+ state = saveGwenesisStateOpenForWrite("io");
+ saveGwenesisStateSetBuffer(state, "button_state", button_state, sizeof(button_state));
+ saveGwenesisStateSetBuffer(state, "gwenesis_io_pad_state", gwenesis_io_pad_state, sizeof(gwenesis_io_pad_state));
+ saveGwenesisStateSetBuffer(state, "io_reg", io_reg, sizeof(io_reg));
+}
+
+void gwenesis_io_load_state() {
+ SaveState* state = saveGwenesisStateOpenForRead("io");
+ saveGwenesisStateGetBuffer(state, "button_state", button_state, sizeof(button_state));
+ saveGwenesisStateGetBuffer(state, "gwenesis_io_pad_state", gwenesis_io_pad_state, sizeof(gwenesis_io_pad_state));
+ saveGwenesisStateGetBuffer(state, "io_reg", io_reg, sizeof(io_reg));
+}
diff --git a/games/retrogo/src/md/gwenesis_io.h b/games/retrogo/src/md/gwenesis_io.h
new file mode 100644
index 00000000..a1a1b753
--- /dev/null
+++ b/games/retrogo/src/md/gwenesis_io.h
@@ -0,0 +1,36 @@
+/*
+Gwenesis : Genesis & megadrive Emulator.
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = "bzhxx"
+__contact__ = "https://github.com/bzhxx"
+__license__ = "GPLv3"
+
+*/
+#ifndef _gwenesis_io_H_
+#define _gwenesis_io_H_
+
+#pragma once
+
+void gwenesis_io_pad_press_button(int pad, int button);
+void gwenesis_io_pad_release_button(int pad, int button);
+
+void gwenesis_io_write_ctrl(unsigned int address, unsigned int value);
+unsigned int gwenesis_io_read_ctrl(unsigned int address);
+
+void gwenesis_io_set_reg(unsigned int reg, unsigned int value);
+void gwenesis_io_get_buttons();
+
+void gwenesis_io_save_state();
+void gwenesis_io_load_state();
+
+#endif
\ No newline at end of file
diff --git a/games/retrogo/src/md/gwenesis_savestate.h b/games/retrogo/src/md/gwenesis_savestate.h
new file mode 100644
index 00000000..0709ec8b
--- /dev/null
+++ b/games/retrogo/src/md/gwenesis_savestate.h
@@ -0,0 +1,45 @@
+/*
+Gwenesis : Genesis & megadrive Emulator.
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = "bzhxx"
+__contact__ = "https://github.com/bzhxx"
+__license__ = "GPLv3"
+
+*/
+#ifndef _gwenesis_savestate_H_
+#define _gwenesis_savestate_H_
+
+#pragma once
+
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+
+typedef struct SaveState SaveState;
+
+bool initLoadGwenesisState(unsigned char *srcBuffer);
+int saveGwenesisState(unsigned char *destBuffer, int save_size);
+int loadGwenesisState(unsigned char *srcBuffer);
+
+SaveState* saveGwenesisStateOpenForRead(const char* fileName);
+SaveState* saveGwenesisStateOpenForWrite(const char* fileName);
+
+int saveGwenesisStateGet(SaveState* state, const char* tagName);
+void saveGwenesisStateSet(SaveState* state, const char* tagName, int value);
+
+void saveGwenesisStateGetBuffer(SaveState* state, const char* tagName, void* buffer, int length);
+void saveGwenesisStateSetBuffer(SaveState* state, const char* tagName, void* buffer, int length);
+
+void gwenesis_save_state();
+void gwenesis_load_state();
+#endif
\ No newline at end of file
diff --git a/games/retrogo/src/md/gwenesis_vdp.h b/games/retrogo/src/md/gwenesis_vdp.h
new file mode 100644
index 00000000..dcdaa6ef
--- /dev/null
+++ b/games/retrogo/src/md/gwenesis_vdp.h
@@ -0,0 +1,153 @@
+/*
+Gwenesis : Genesis & megadrive Emulator.
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = "bzhxx"
+__contact__ = "https://github.com/bzhxx"
+__license__ = "GPLv3"
+
+*/
+#ifndef _gwenesis_vdp_H_
+#define _gwenesis_vdp_H_
+
+#pragma once
+
+#define BIT(v, idx) (((v) >> (idx)) & 1)
+#define BITS(v, idx, n) (((v) >> (idx)) & ((1 << (n)) - 1))
+
+// VDP registers
+#define REG0_DISABLE_DISPLAY (gwenesis_vdp_regs[0] & 1)
+#define REG0_HVLATCH BIT(gwenesis_vdp_regs[0], 1)
+#define REG0_LINE_INTERRUPT BIT(gwenesis_vdp_regs[0], 4)
+#define REG1_PAL BIT(gwenesis_vdp_regs[1], 3)
+#define REG1_240_LINE ((gwenesis_vdp_regs[1] & 0x08) >> 3)
+#define REG1_DMA_ENABLED BIT(gwenesis_vdp_regs[1], 4)
+#define REG1_VBLANK_INTERRUPT BIT(gwenesis_vdp_regs[1], 5)
+#define REG1_DISP_ENABLED BIT(gwenesis_vdp_regs[1], 6)
+#define REG2_NAMETABLE_A (BITS(gwenesis_vdp_regs[2], 3, 3) << 13)
+#define REG3_NAMETABLE_W BITS(gwenesis_vdp_regs[3], 1, 5)
+#define REG4_NAMETABLE_B (BITS(gwenesis_vdp_regs[4], 0, 3) << 13)
+//#define REG5_SAT_ADDRESS ((gwenesis_vdp_regs[5] & (mode_h40 ? 0x7E : 0x7F)) << 9)
+//#define REG5_SAT_SIZE (mode_h40 ? (1 << 10) : (1 << 9))
+#define REG5_SAT_ADDRESS ((gwenesis_vdp_regs[5] & ((gwenesis_vdp_regs[12] & 0x01) ? 0x7E : 0x7F)) << 9)
+#define REG5_SAT_SIZE ((gwenesis_vdp_regs[12] & 0x01) ? (1 << 10) : (1 << 9))
+#define REG10_LINE_COUNTER BITS(gwenesis_vdp_regs[10], 0, 8)
+#define REG10_COLUMN_COUNTER BITS(gwenesis_vdp_regs[10], 8, 15)
+#define REG11_HSCROLL_MODE ((gwenesis_vdp_regs[11] & 3))
+#define REG11_VSCROLL_MODE ((gwenesis_vdp_regs[11] & 4) >> 2)
+#define REG12_RS0 (gwenesis_vdp_regs[12] & 0x80) >> 7
+#define REG12_RS1 (gwenesis_vdp_regs[12] & 0x01) >> 0
+#define REG12_MODE_H40 (gwenesis_vdp_regs[12] & 1)
+#define REG13_HSCROLL_ADDRESS (gwenesis_vdp_regs[13] << 10)
+#define REG15_DMA_INCREMENT gwenesis_vdp_regs[15]
+#define REG16_UNUSED1 ((gwenesis_vdp_regs[16] & 0xc0) >> 6)
+#define REG16_VSCROLL_SIZE ((gwenesis_vdp_regs[16] >> 4) & 3)
+#define REG16_UNUSED2 ((gwenesis_vdp_regs[16] & 0x0c) >> 2)
+#define REG16_HSCROLL_SIZE (gwenesis_vdp_regs[16] & 3)
+#define REG17_WINDOW_HPOS BITS(gwenesis_vdp_regs[17], 0, 5)
+#define REG17_WINDOW_RIGHT ((gwenesis_vdp_regs[17] & 0x80) >> 7)
+#define REG18_WINDOW_DOWN ((gwenesis_vdp_regs[0x12] & 0x80) >> 7)
+#define REG18_WINDOW_VPOS BITS(gwenesis_vdp_regs[18], 0, 5)
+#define REG19_DMA_LENGTH (gwenesis_vdp_regs[19] | (gwenesis_vdp_regs[20] << 8))
+#define REG21_DMA_SRCADDR_LOW (gwenesis_vdp_regs[21] | (gwenesis_vdp_regs[22] << 8))
+#define REG23_DMA_SRCADDR_HIGH ((gwenesis_vdp_regs[23] & 0x7F) << 16)
+#define REG23_DMA_TYPE BITS(gwenesis_vdp_regs[23], 6, 2)
+
+//VDP status register
+#define STATUS_FIFO_EMPTY (1 << 9)
+#define STATUS_FIFO_FULL (1 << 8)
+#define STATUS_VIRQPENDING (1 << 7)
+#define STATUS_SPRITEOVERFLOW (1 << 6)
+#define STATUS_SPRITECOLLISION (1 << 5)
+#define STATUS_ODDFRAME (1 << 4)
+#define STATUS_VBLANK (1 << 3)
+#define STATUS_HBLANK (1 << 2)
+#define STATUS_DMAPROGRESS (1 << 1)
+#define STATUS_PAL (1 << 0)
+
+#define VRAM_MAX_SIZE 0x10000 // VRAM maximum size
+#define CRAM_MAX_SIZE 0x40 // CRAM maximum size
+#define VSRAM_MAX_SIZE 0x40 // VSRAM maximum size
+#define SAT_CACHE_MAX_SIZE 0x400 // SAT CACHE maximum size
+#define REG_SIZE 0x20 // REGISTERS total
+#define FIFO_SIZE 0x4 // FIFO maximum size
+
+#define COLOR_3B_TO_8B(c) (((c) << 5) | ((c) << 2) | ((c) >> 1))
+#define CRAM_R(c) COLOR_3B_TO_8B(BITS((c), 1, 3))
+#define CRAM_G(c) COLOR_3B_TO_8B(BITS((c), 5, 3))
+#define CRAM_B(c) COLOR_3B_TO_8B(BITS((c), 9, 3))
+
+#define MODE_SHI BITS(gwenesis_vdp_regs[12], 3, 1)
+
+#define SHADOW_COLOR(r,g,b) \
+ do { r >>= 1; g >>= 1; b >>= 1; } while (0)
+#define HIGHLIGHT_COLOR(r,g,b) \
+ do { SHADOW_COLOR(r,g,b); r |= 0x80; g |= 0x80; b |= 0x80; } while(0)
+
+// While we draw the planes, we use bit 0x80 on each pixel to save the
+// high-priority flag, so that we can later prioritize.
+#define PIXATTR_HIPRI 0x80
+#define PIXATTR_LOWPRI 0x00
+#define PIXATTR_SPRITE 0x40
+#define PIXATTR_SPRITE_HIPRI 0xC0
+
+
+// After mixing code, we use free bits 0x80 and 0x40 to indicate the
+// shadow/highlight effect to apply on each pixel. Notice that we use
+// 0x80 to indicate normal drawing and 0x00 to indicate shadowing,
+// which does match exactly the semantic of PIXATTR_HIPRI. This simplifies
+// mixing code quite a bit.
+#define SHI_NORMAL(x) ((x) | 0x80)
+#define SHI_HIGHLIGHT(x) ((x) | 0x40)
+#define SHI_SHADOW(x) ((x) & 0x3F)
+
+#define SHI_IS_SHADOW(x) (!((x) & 0x80))
+#define SHI_IS_HIGHLIGHT(x) ((x) & 0x40)
+
+void gwenesis_vdp_reset();
+void gwenesis_vdp_set_hblank();
+void gwenesis_vdp_clear_hblank();
+void gwenesis_vdp_set_vblank();
+void gwenesis_vdp_clear_vblank();
+
+unsigned int gwenesis_vdp_get_reg(int reg);
+void gwenesis_vdp_set_reg(int reg, unsigned char value);
+
+unsigned int gwenesis_vdp_read_memory_8(unsigned int address);
+unsigned int gwenesis_vdp_read_memory_16(unsigned int address);
+
+void gwenesis_vdp_write_memory_8(unsigned int address, unsigned int value);
+void gwenesis_vdp_write_memory_16(unsigned int address, unsigned int value);
+
+void gwenesis_vdp_set_buffers(unsigned char *screen_buffer, unsigned char *scaled_buffer);
+void gwenesis_vdp_set_buffer(unsigned short *ptr_screen_buffer);
+void gwenesis_vdp_render_line(int line);
+
+void gwenesis_vdp_render_config();
+
+unsigned int gwenesis_vdp_get_status();
+void gwenesis_vdp_get_debug_status(char *s);
+unsigned short gwenesis_vdp_get_cram(int index);
+void gwenesis_vdp_get_vram(unsigned char *raw_buffer, int palette);
+void gwenesis_vdp_get_vram_raw(unsigned char *raw_buffer);
+void gwenesis_vdp_get_cram_raw(unsigned char *raw_buffer);
+
+int gwenesis_vdp_vcounter();
+int gwenesis_vdp_hcounter();
+unsigned short gwenesis_vdp_hvcounter();
+
+void gwenesis_vdp_gfx_save_state();
+void gwenesis_vdp_gfx_load_state();
+void gwenesis_vdp_mem_save_state();
+void gwenesis_vdp_mem_load_state();
+
+#endif
\ No newline at end of file
diff --git a/games/retrogo/src/md/gwenesis_vdp_gfx.c b/games/retrogo/src/md/gwenesis_vdp_gfx.c
new file mode 100644
index 00000000..4b25f0de
--- /dev/null
+++ b/games/retrogo/src/md/gwenesis_vdp_gfx.c
@@ -0,0 +1,1139 @@
+/*
+Gwenesis : Genesis & megadrive Emulator.
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = "bzhxx"
+__contact__ = "https://github.com/bzhxx"
+__license__ = "GPLv3"
+
+*/
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include "m68k.h"
+#include "gwenesis_vdp.h"
+#include "gwenesis_io.h"
+#include "gwenesis_bus.h"
+#include "gwenesis_savestate.h"
+
+/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound
+ chips' writes go nowhere; and nothing printed) */
+#define YM2612Read(clk) 0
+#define YM2612Write(a, v, clk) ((void)0)
+#define YM2612Init() ((void)0)
+#define YM2612Config(x) ((void)0)
+#define YM2612ResetChip() ((void)0)
+#define gwenesis_SN76489_Write(v, clk) ((void)0)
+#define gwenesis_SN76489_Init(a, b, c) ((void)0)
+#define gwenesis_SN76489_Reset() ((void)0)
+#define printf(...) ((void)0)
+#define vfprintf(...) ((void)0)
+
+//#include <assert.h>
+
+#if GNW_TARGET_MARIO !=0 || GNW_TARGET_ZELDA!=0
+ #pragma GCC optimize("Ofast")
+#endif
+
+#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+#include "stm32h7b0xx.h"
+extern unsigned char* VRAM;
+
+#else
+
+#include <stdint.h>
+extern unsigned char *VRAM;
+
+#endif
+
+extern unsigned short CRAM[]; // CRAM - Palettes
+extern unsigned char SAT_CACHE[]__attribute__((aligned(4))); // Sprite cache
+extern unsigned char gwenesis_vdp_regs[]; // Registers
+
+extern unsigned short CRAM565[]; // CRAM - Palettes
+
+extern unsigned short VSRAM[]; // VSRAM - Scrolling
+
+// Define screen buffers: original and scaled for host RGB
+unsigned char *screen, *scaled_screen;
+
+// Define screen buffers for embedded 565 format
+static uint8_t *screen_buffer_line=0;
+static uint8_t *screen_buffer=0;
+
+ // Overflow is the maximum size we can draw outside to avoid
+ // wasting time and code in clipping. The maximum object is a 4x4 sprite,
+ // so 32 pixels (on both side) is enough.
+
+enum { PIX_OVERFLOW = 32 };
+
+static uint8_t render_buffer[SCREEN_WIDTH + PIX_OVERFLOW*2];
+static uint8_t sprite_buffer[SCREEN_WIDTH + PIX_OVERFLOW*2];
+
+// Define VIDEO MODE
+static int mode_h40;
+int mode_pal;
+
+// Define screen W/H
+int screen_width;
+int screen_height;
+
+int gwenesis_H32upscaler;
+
+int sprite_overflow;
+bool sprite_collision;
+
+// Window Plane and A plane spearation
+static int base_w;
+static int PlanA_firstcol;
+static int PlanA_lastcol;
+
+static int Window_firstcol;
+static int Window_lastcol;
+
+// 16 bits access to VRAM
+// #define FETCH16VRAM(A) ({size_t addr = (A); (VRAM[addr+1]) | (VRAM[addr] << 8);})
+#define FETCH16VRAM(A) ( (VRAM[(A)+1]) | (VRAM[(A)] << 8) )
+#define VDP_GFX_DISABLE_LOGGING 1
+
+#if !VDP_GFX_DISABLE_LOGGING
+#include <stdarg.h>
+void vdpg_log(const char *subs, const char *fmt, ...) {
+ extern int frame_counter;
+ extern int scan_line;
+
+ va_list va;
+
+ printf("%06d:%03d :[%s] vc:%03x hc:%03x", frame_counter, scan_line, subs,gwenesis_vdp_vcounter(),gwenesis_vdp_hcounter());
+
+ va_start(va, fmt);
+ vfprintf(stdout, fmt, va);
+ va_end(va);
+ printf("\n");
+}
+#else
+ #define vdpg_log(...) do {} while(0)
+#endif
+/******************************************************************************
+ *
+ * set screen buffers in which the rendering occurs
+ * Set original and scaled screen buffer for host
+ *
+ ******************************************************************************/
+//host
+void gwenesis_vdp_set_buffers(unsigned char *screen_buffer, unsigned char *scaled_buffer)
+{
+ screen = screen_buffer;
+ scaled_screen = scaled_buffer;
+}
+//embedded
+void gwenesis_vdp_set_buffer(unsigned short *ptr_screen_buffer)
+{
+ screen_buffer_line = ptr_screen_buffer;
+ screen_buffer = ptr_screen_buffer;
+}
+
+/******************************************************************************
+ *
+ * Draw Sprite character /8pixels in row
+ * without checking overdraw for pixels collision detection
+ * with Horizontal flip variation
+ * for Shadow/highlight :
+ * draw in fresh line buffer using draw_pattern_xxfliph_sprite(..)
+ * otherwise:
+ * draw over dirty planes using draw_pattern_xxfliph_sprite_over_planes(..)
+ *
+ ******************************************************************************/
+
+ #define PIX0(P) ( ((P) & 0x000000F0 ) >> 4 )
+ #define PIX1(P) ( ((P) & 0x0000000F ) >> 0 )
+ #define PIX2(P) ( ((P) & 0x0000F000 ) >> 12 )
+ #define PIX3(P) ( ((P) & 0x00000F00 ) >> 8 )
+ #define PIX4(P) ( ((P) & 0x00F00000 ) >> 20 )
+ #define PIX5(P) ( ((P) & 0x000F0000 ) >> 16 )
+ #define PIX6(P) ( ((P) & 0xF0000000 ) >> 28 )
+ #define PIX7(P) ( ((P) & 0x0F000000 ) >> 24 )
+
+static inline __attribute__((always_inline))
+void draw_pattern_nofliph_sprite(uint8_t *scr, uint32_t p, uint8_t attrs)
+{
+ if (p == 0) return;
+
+ /* not transparent pixel to write AND not already a sprite*/
+ if (((PIX0(p))) && ((scr[0] & PIXATTR_SPRITE) == 0)) scr[0] = attrs | (PIX0(p));
+ if (((PIX1(p))) && ((scr[1] & PIXATTR_SPRITE) == 0)) scr[1] = attrs | (PIX1(p));
+ if (((PIX2(p))) && ((scr[2] & PIXATTR_SPRITE) == 0)) scr[2] = attrs | (PIX2(p));
+ if (((PIX3(p))) && ((scr[3] & PIXATTR_SPRITE) == 0)) scr[3] = attrs | (PIX3(p));
+ if (((PIX4(p))) && ((scr[4] & PIXATTR_SPRITE) == 0)) scr[4] = attrs | (PIX4(p));
+ if (((PIX5(p))) && ((scr[5] & PIXATTR_SPRITE) == 0)) scr[5] = attrs | (PIX5(p));
+ if (((PIX6(p))) && ((scr[6] & PIXATTR_SPRITE) == 0)) scr[6] = attrs | (PIX6(p));
+ if (((PIX7(p))) && ((scr[7] & PIXATTR_SPRITE) == 0)) scr[7] = attrs | (PIX7(p));
+}
+
+static inline __attribute__((always_inline))
+void draw_pattern_fliph_sprite(uint8_t *scr, uint32_t p, uint8_t attrs)
+{
+ if (p == 0) return;
+
+ /* not transparent pixel to write AND not already a sprite*/
+ if (((PIX7(p))) && ((scr[0] & PIXATTR_SPRITE) == 0)) scr[0] = attrs | (PIX7(p));
+ if (((PIX6(p))) && ((scr[1] & PIXATTR_SPRITE) == 0)) scr[1] = attrs | (PIX6(p));
+ if (((PIX5(p))) && ((scr[2] & PIXATTR_SPRITE) == 0)) scr[2] = attrs | (PIX5(p));
+ if (((PIX4(p))) && ((scr[3] & PIXATTR_SPRITE) == 0)) scr[3] = attrs | (PIX4(p));
+ if (((PIX3(p))) && ((scr[4] & PIXATTR_SPRITE) == 0)) scr[4] = attrs | (PIX3(p));
+ if (((PIX2(p))) && ((scr[5] & PIXATTR_SPRITE) == 0)) scr[5] = attrs | (PIX2(p));
+ if (((PIX1(p))) && ((scr[6] & PIXATTR_SPRITE) == 0)) scr[6] = attrs | (PIX1(p));
+ if (((PIX0(p))) && ((scr[7] & PIXATTR_SPRITE) == 0)) scr[7] = attrs | (PIX0(p));
+
+}
+
+static inline __attribute__((always_inline))
+void draw_pattern_nofliph_sprite_over_planes(uint8_t *scr, uint32_t p, uint8_t attrs)
+{
+ if (p == 0) return;
+
+ /* High priority */
+ if (attrs & PIXATTR_HIPRI) {
+
+ /* not transparent pixel to write AND not already a sprite*/
+ if (((PIX0(p))) && ((scr[0] & PIXATTR_SPRITE) == 0)) scr[0] = attrs | (PIX0(p));
+ if (((PIX1(p))) && ((scr[1] & PIXATTR_SPRITE) == 0)) scr[1] = attrs | (PIX1(p));
+ if (((PIX2(p))) && ((scr[2] & PIXATTR_SPRITE) == 0)) scr[2] = attrs | (PIX2(p));
+ if (((PIX3(p))) && ((scr[3] & PIXATTR_SPRITE) == 0)) scr[3] = attrs | (PIX3(p));
+ if (((PIX4(p))) && ((scr[4] & PIXATTR_SPRITE) == 0)) scr[4] = attrs | (PIX4(p));
+ if (((PIX5(p))) && ((scr[5] & PIXATTR_SPRITE) == 0)) scr[5] = attrs | (PIX5(p));
+ if (((PIX6(p))) && ((scr[6] & PIXATTR_SPRITE) == 0)) scr[6] = attrs | (PIX6(p));
+ if (((PIX7(p))) && ((scr[7] & PIXATTR_SPRITE) == 0)) scr[7] = attrs | (PIX7(p));
+
+ }
+ /* Low priority */
+ else {
+
+ /* not transparent pixel to write AND not already a sprite or higher priority*/
+ if (((PIX0(p))) && ((scr[0] & PIXATTR_SPRITE_HIPRI) == 0)) scr[0] = attrs | (PIX0(p));
+ if (((PIX1(p))) && ((scr[1] & PIXATTR_SPRITE_HIPRI) == 0)) scr[1] = attrs | (PIX1(p));
+ if (((PIX2(p))) && ((scr[2] & PIXATTR_SPRITE_HIPRI) == 0)) scr[2] = attrs | (PIX2(p));
+ if (((PIX3(p))) && ((scr[3] & PIXATTR_SPRITE_HIPRI) == 0)) scr[3] = attrs | (PIX3(p));
+ if (((PIX4(p))) && ((scr[4] & PIXATTR_SPRITE_HIPRI) == 0)) scr[4] = attrs | (PIX4(p));
+ if (((PIX5(p))) && ((scr[5] & PIXATTR_SPRITE_HIPRI) == 0)) scr[5] = attrs | (PIX5(p));
+ if (((PIX6(p))) && ((scr[6] & PIXATTR_SPRITE_HIPRI) == 0)) scr[6] = attrs | (PIX6(p));
+ if (((PIX7(p))) && ((scr[7] & PIXATTR_SPRITE_HIPRI) == 0)) scr[7] = attrs | (PIX7(p));
+
+ }
+}
+
+static inline __attribute__((always_inline))
+void draw_pattern_fliph_sprite_over_planes(uint8_t *scr, uint32_t p, uint8_t attrs)
+{
+ if (p == 0) return;
+
+ /* High priority */
+ if (attrs & PIXATTR_HIPRI) {
+
+ /* not transparent pixel to write AND not already a sprite*/
+ if (((PIX7(p))) && ((scr[0] & PIXATTR_SPRITE) == 0)) scr[0] = attrs | (PIX7(p));
+ if (((PIX6(p))) && ((scr[1] & PIXATTR_SPRITE) == 0)) scr[1] = attrs | (PIX6(p));
+ if (((PIX5(p))) && ((scr[2] & PIXATTR_SPRITE) == 0)) scr[2] = attrs | (PIX5(p));
+ if (((PIX4(p))) && ((scr[3] & PIXATTR_SPRITE) == 0)) scr[3] = attrs | (PIX4(p));
+ if (((PIX3(p))) && ((scr[4] & PIXATTR_SPRITE) == 0)) scr[4] = attrs | (PIX3(p));
+ if (((PIX2(p))) && ((scr[5] & PIXATTR_SPRITE) == 0)) scr[5] = attrs | (PIX2(p));
+ if (((PIX1(p))) && ((scr[6] & PIXATTR_SPRITE) == 0)) scr[6] = attrs | (PIX1(p));
+ if (((PIX0(p))) && ((scr[7] & PIXATTR_SPRITE) == 0)) scr[7] = attrs | (PIX0(p));
+
+ }
+ /* Low priority */
+ else {
+
+ /* not transparent pixel to write AND not already a sprite or higher priority*/
+ if (((PIX7(p))) && ((scr[0] & PIXATTR_SPRITE_HIPRI) == 0)) scr[0] = attrs | (PIX7(p));
+ if (((PIX6(p))) && ((scr[1] & PIXATTR_SPRITE_HIPRI) == 0)) scr[1] = attrs | (PIX6(p));
+ if (((PIX5(p))) && ((scr[2] & PIXATTR_SPRITE_HIPRI) == 0)) scr[2] = attrs | (PIX5(p));
+ if (((PIX4(p))) && ((scr[3] & PIXATTR_SPRITE_HIPRI) == 0)) scr[3] = attrs | (PIX4(p));
+ if (((PIX3(p))) && ((scr[4] & PIXATTR_SPRITE_HIPRI) == 0)) scr[4] = attrs | (PIX3(p));
+ if (((PIX2(p))) && ((scr[5] & PIXATTR_SPRITE_HIPRI) == 0)) scr[5] = attrs | (PIX2(p));
+ if (((PIX1(p))) && ((scr[6] & PIXATTR_SPRITE_HIPRI) == 0)) scr[6] = attrs | (PIX1(p));
+ if (((PIX0(p))) && ((scr[7] & PIXATTR_SPRITE_HIPRI) == 0)) scr[7] = attrs | (PIX0(p));
+
+ }
+
+}
+
+/******************************************************************************
+ *
+ * Draw characters/8pixels in row
+ * without checking overdraw for pixels collision detection
+ * with Horizontal flip variation for plane A & B
+ *
+ ******************************************************************************/
+
+
+static inline __attribute__((always_inline)) void
+draw_pattern_nofliph_planeB(uint8_t *scr, uint32_t p, uint8_t attrs) {
+
+ const uint8_t back = gwenesis_vdp_regs[7];
+
+ if (p == 0) {
+
+ scr[0] = back;
+ scr[1] = back;
+ scr[2] = back;
+ scr[3] = back;
+ scr[4] = back;
+ scr[5] = back;
+ scr[6] = back;
+ scr[7] = back;
+
+ return;
+ }
+
+ scr[0] = PIX0(p) ? attrs | (PIX0(p)) : back;
+ scr[1] = PIX1(p) ? attrs | (PIX1(p)) : back;
+ scr[2] = PIX2(p) ? attrs | (PIX2(p)) : back;
+ scr[3] = PIX3(p) ? attrs | (PIX3(p)) : back;
+ scr[4] = PIX4(p) ? attrs | (PIX4(p)) : back;
+ scr[5] = PIX5(p) ? attrs | (PIX5(p)) : back;
+ scr[6] = PIX6(p) ? attrs | (PIX6(p)) : back;
+ scr[7] = PIX7(p) ? attrs | (PIX7(p)) : back;
+}
+
+static inline __attribute__((always_inline)) void
+draw_pattern_fliph_planeB(uint8_t *scr, uint32_t p, uint8_t attrs) {
+
+ const uint8_t back = gwenesis_vdp_regs[7];
+ if (p == 0) {
+
+ scr[0] = back;
+ scr[1] = back;
+ scr[2] = back;
+ scr[3] = back;
+ scr[4] = back;
+ scr[5] = back;
+ scr[6] = back;
+ scr[7] = back;
+
+ return;
+ }
+
+ scr[0] = PIX7(p) ? attrs | (PIX7(p)) : back;
+ scr[1] = PIX6(p) ? attrs | (PIX6(p)) : back;
+ scr[2] = PIX5(p) ? attrs | (PIX5(p)) : back;
+ scr[3] = PIX4(p) ? attrs | (PIX4(p)) : back;
+ scr[4] = PIX3(p) ? attrs | (PIX3(p)) : back;
+ scr[5] = PIX2(p) ? attrs | (PIX2(p)) : back;
+ scr[6] = PIX1(p) ? attrs | (PIX1(p)) : back;
+ scr[7] = PIX0(p) ? attrs | (PIX0(p)) : back;
+
+
+}
+
+static inline __attribute__((always_inline)) void
+draw_pattern_nofliph_planeAoverB(uint8_t *scr, uint32_t p, uint8_t attrs) {
+
+ if (p == 0) return;
+
+ if (attrs & PIXATTR_HIPRI) {
+
+ if (PIX0(p)) scr[0] = attrs | (PIX0(p));
+ if (PIX1(p)) scr[1] = attrs | (PIX1(p));
+ if (PIX2(p)) scr[2] = attrs | (PIX2(p));
+ if (PIX3(p)) scr[3] = attrs | (PIX3(p));
+ if (PIX4(p)) scr[4] = attrs | (PIX4(p));
+ if (PIX5(p)) scr[5] = attrs | (PIX5(p));
+ if (PIX6(p)) scr[6] = attrs | (PIX6(p));
+ if (PIX7(p)) scr[7] = attrs | (PIX7(p));
+
+ } else {
+
+ if (PIX0(p) && ((scr[0] & PIXATTR_HIPRI) == 0)) scr[0] = attrs | (PIX0(p));
+ if (PIX1(p) && ((scr[1] & PIXATTR_HIPRI) == 0)) scr[1] = attrs | (PIX1(p));
+ if (PIX2(p) && ((scr[2] & PIXATTR_HIPRI) == 0)) scr[2] = attrs | (PIX2(p));
+ if (PIX3(p) && ((scr[3] & PIXATTR_HIPRI) == 0)) scr[3] = attrs | (PIX3(p));
+ if (PIX4(p) && ((scr[4] & PIXATTR_HIPRI) == 0)) scr[4] = attrs | (PIX4(p));
+ if (PIX5(p) && ((scr[5] & PIXATTR_HIPRI) == 0)) scr[5] = attrs | (PIX5(p));
+ if (PIX6(p) && ((scr[6] & PIXATTR_HIPRI) == 0)) scr[6] = attrs | (PIX6(p));
+ if (PIX7(p) && ((scr[7] & PIXATTR_HIPRI) == 0)) scr[7] = attrs | (PIX7(p));
+
+ }
+}
+
+static inline __attribute__((always_inline)) void
+draw_pattern_fliph_planeAoverB(uint8_t *scr, uint32_t p, uint8_t attrs) {
+
+ if (p == 0) return;
+
+ if (attrs & PIXATTR_HIPRI) {
+
+ if (PIX7(p)) scr[0] = attrs | (PIX7(p));
+ if (PIX6(p)) scr[1] = attrs | (PIX6(p));
+ if (PIX5(p)) scr[2] = attrs | (PIX5(p));
+ if (PIX4(p)) scr[3] = attrs | (PIX4(p));
+ if (PIX3(p)) scr[4] = attrs | (PIX3(p));
+ if (PIX2(p)) scr[5] = attrs | (PIX2(p));
+ if (PIX1(p)) scr[6] = attrs | (PIX1(p));
+ if (PIX0(p)) scr[7] = attrs | (PIX0(p));
+
+ } else {
+
+ if (PIX7(p) && ((scr[0] & PIXATTR_HIPRI) == 0)) scr[0] = attrs | (PIX7(p));
+ if (PIX6(p) && ((scr[1] & PIXATTR_HIPRI) == 0)) scr[1] = attrs | (PIX6(p));
+ if (PIX5(p) && ((scr[2] & PIXATTR_HIPRI) == 0)) scr[2] = attrs | (PIX5(p));
+ if (PIX4(p) && ((scr[3] & PIXATTR_HIPRI) == 0)) scr[3] = attrs | (PIX4(p));
+ if (PIX3(p) && ((scr[4] & PIXATTR_HIPRI) == 0)) scr[4] = attrs | (PIX3(p));
+ if (PIX2(p) && ((scr[5] & PIXATTR_HIPRI) == 0)) scr[5] = attrs | (PIX2(p));
+ if (PIX1(p) && ((scr[6] & PIXATTR_HIPRI) == 0)) scr[6] = attrs | (PIX1(p));
+ if (PIX0(p) && ((scr[7] & PIXATTR_HIPRI) == 0)) scr[7] = attrs | (PIX0(p));
+
+ }
+
+}
+
+/******************************************************************************
+ *
+ * Draw characters/8pixels in row
+ * with/without checking overdraw for pixels collision detection
+ * used for sprites and planes drawing
+ *
+ ******************************************************************************/
+static inline __attribute__((always_inline))
+void draw_pattern_sprite(uint8_t *scr, uint16_t name, int paty) {
+
+ // uint16_t pat_addr = name << 5; //name * 32;
+ // uint8_t pat_palette = BITS(name, 13, 2);
+ // //unsigned int is_pat_pri = name & 0x8000;
+ // uint8_t *pattern = VRAM + pat_addr;
+ // uint8_t attrs = (pat_palette << 4) | ((name & 0x8000) ? PIXATTR_SPRITE_HIPRI : PIXATTR_SPRITE);
+ uint8_t attrs = ( (name & 0x6000 ) >> 9 ) + ((name & 0x8000) >> 8) + PIXATTR_SPRITE;
+
+ unsigned int pattern;
+
+ // Vertical flip ?
+ // if (name & 0x1000)
+ // pattern += (7 - paty) * 4;
+ // else
+ // pattern += paty * 4;
+
+ // unsigned int pattern;
+
+ // Vertical flip ?
+ if (name & 0x1000)
+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + ((7 - paty) * 4)); //) pat_addr;
+ else
+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + (paty * 4));
+
+ // Horizontal flip ?
+ if (name & 0x0800)
+ draw_pattern_fliph_sprite(scr, pattern, attrs);
+ else
+ draw_pattern_nofliph_sprite(scr, pattern, attrs);
+}
+
+static inline __attribute__((always_inline))
+void draw_pattern_sprite_over_planes(uint8_t *scr, uint16_t name, int paty) {
+
+ // uint16_t pat_addr = name << 5 ; //* 32;
+ // int pat_palette = BITS(name, 13, 2);
+ // int is_pat_pri = name & 0x8000;
+ // uint8_t *pattern = VRAM + pat_addr;
+ // uint8_t attrs = (pat_palette << 4) | (is_pat_pri ? PIXATTR_SPRITE_HIPRI : PIXATTR_SPRITE);
+
+ // Vertical flip ?
+ // if (name & 0x1000)
+ // pattern += (7 - paty) * 4;
+ // else
+ // pattern += paty * 4;
+
+ //uint8_t attrs = ( (name & 0x6000 ) >> 9 ) | ((name & 0x8000) ? PIXATTR_SPRITE_HIPRI : PIXATTR_SPRITE);
+ uint8_t attrs = ( (name & 0x6000 ) >> 9 ) + ((name & 0x8000) >> 8) + PIXATTR_SPRITE;
+ //uint8_t attrs = ( (name >>9) & 0x70 ) | PIXATTR_SPRITE;
+
+ unsigned int pattern;
+
+ // Vertical flip ?
+ if (name & 0x1000)
+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + ((7 - paty) * 4)); //) pat_addr;
+ else
+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + (paty * 4));
+
+ // Horizontal flip ?
+ if (name & 0x0800)
+ draw_pattern_fliph_sprite_over_planes (scr, pattern, attrs);
+ else
+ draw_pattern_nofliph_sprite_over_planes (scr, pattern, attrs);
+}
+
+static inline __attribute__((always_inline))
+void draw_pattern_planeB(uint8_t *scr, uint16_t name, int paty) {
+ // uint16_t pat_addr = name << 5; // * 32;
+ // uint8_t pat_palette = BITS(name, 13, 2);
+ // unsigned int is_pat_pri = name & 0x8000;
+ //uint8_t *pattern = VRAM + pat_addr;
+
+ uint8_t attrs = ( (name & 0x6000 ) >> 9 ) + ((name & 0x8000) >> 8);
+
+ unsigned int pattern;
+
+ // Vertical flip ?
+ if (name & 0x1000)
+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + ((7 - paty) * 4)); //) pat_addr;
+ else
+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + (paty * 4));
+
+// if ((*(unsigned int *)pattern) == 0 ) return;
+ // uint8_t *pattern = VRAM + ((name << 5) & 0xFFFF); //) pat_addr;
+ //uint32_t pattern = VRAM[(name & 0x07FF) << 5]; //) pat_addr;
+
+ // Horizontal flip ?
+ if (name & 0x0800)
+ draw_pattern_fliph_planeB(scr, pattern, attrs);
+
+ else
+ draw_pattern_nofliph_planeB(scr, pattern, attrs);
+
+}
+
+static inline __attribute__((always_inline))
+void draw_pattern_planeA(uint8_t *scr, uint16_t name, int paty) {
+ // uint16_t pat_addr = name << 5; //* 32;
+ // uint8_t pat_palette = BITS(name, 13, 2);
+ // unsigned int is_pat_pri = name & 0x8000;
+ // uint8_t *pattern = VRAM + pat_addr;
+
+ uint8_t attrs = ( (name & 0x6000 ) >> 9 ) + ((name & 0x8000) >> 8);
+
+
+
+
+ unsigned int pattern;
+
+ // Vertical flip ?
+ // if (name & 0x1000)
+ // pattern += (7 - paty) * 4;
+ // else
+ // pattern += paty * 4;
+
+ // Vertical flip ?
+ if (name & 0x1000)
+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + ((7 - paty) * 4)); //) pat_addr;
+ else
+ pattern = *(unsigned int *)(VRAM + ((name & 0x07FF) << 5) + (paty * 4));
+
+ // Horizontal flip ?
+ if (name & 0x0800)
+ draw_pattern_fliph_planeAoverB(scr, pattern, attrs);
+
+ else
+ draw_pattern_nofliph_planeAoverB(scr, pattern, attrs);
+
+}
+
+static uint16_t ntwidth_x2;
+static uint16_t ntw_mask, nth_mask;
+
+/******************************************************************************
+ *
+ * Return the Horizontal scrolling
+ *
+ ******************************************************************************/
+
+static inline __attribute__((always_inline))
+unsigned int get_hscroll_vram(int line)
+{
+
+ int mode = REG11_HSCROLL_MODE;
+ unsigned int table = REG13_HSCROLL_ADDRESS ;
+ int idx;
+
+ switch (mode)
+ {
+ case 0: // Full screen scrolling
+ idx = 0;
+ break;
+ case 1: // First 8 lines
+ idx = (line & 7);
+ break;
+ case 2: // Every row
+ idx = (line & ~7);
+ break;
+ case 3: // Every line
+ idx = line;
+ break;
+ }
+
+ return table + idx*4;
+}
+/******************************************************************************
+ *
+ * Render PLANE B on screen line
+ *
+ ******************************************************************************/
+ //__attribute__((optimize("unroll-loops")))
+static inline __attribute__((always_inline))
+void draw_line_b(int line)
+{
+ uint8_t *scr = &render_buffer[PIX_OVERFLOW];
+
+ unsigned int ntaddr = REG4_NAMETABLE_B;
+ uint16_t scrollx=FETCH16VRAM(get_hscroll_vram(line) + 2) & 0x3FF;
+ uint16_t *vsram = &VSRAM[1];
+ uint8_t *end = scr + screen_width;
+
+ //bool column_scrolling = BIT(gwenesis_vdp_regs[11], 2);
+ const unsigned int column_scrolling = gwenesis_vdp_regs[11] & 0x4;
+
+ // Invert horizontal scrolling (because it goes right, but we need to offset
+ // of the first screen pixel)
+ scrollx = -scrollx;
+ uint8_t col = (scrollx >> 3) & ntw_mask;
+ uint8_t patx = scrollx & 7;
+
+ unsigned int numcell = 0;
+ scr -= patx;
+ while (scr < end) {
+ // Calculate vertical scrolling for the current line
+ uint16_t scrolly = *vsram + line;
+ uint8_t row = (scrolly >> 3) & nth_mask;
+ uint8_t paty = scrolly & 7;
+
+ // unsigned int nt = ntaddr + row * (2 * ntwidth);
+ unsigned int nt = ntaddr + row * ntwidth_x2;
+
+ draw_pattern_planeB(scr, FETCH16VRAM(nt + col * 2), paty);
+ col = (col + 1) & ntw_mask;
+ scr += 8;
+ numcell++;
+
+ // If per-column scrolling is active, increment VSRAM pointer
+ if (column_scrolling && (numcell & 1) == 0)
+ vsram += 2;
+ }
+}
+/******************************************************************************
+ *
+ * Render PLANE A and Window on screen line
+ *
+ ******************************************************************************/
+//_attribute__((optimize("unroll-loops")))
+static inline __attribute__((always_inline))
+void draw_line_aw(int line) {
+
+ uint8_t *scr = &render_buffer[PIX_OVERFLOW];
+
+ unsigned int ntaddr = REG2_NAMETABLE_A;
+ uint16_t scrollx=FETCH16VRAM(get_hscroll_vram(line) + 0) & 0x3FF;
+ uint16_t *vsram = &VSRAM[0];
+
+ // Check if we are in the window region only
+ // if it's the case, we cancel the plane A drawing
+ int Window_line = REG18_WINDOW_VPOS * 8;
+ //bool window_down = BIT(gwenesis_vdp_regs[18], 7);
+ int window_down = gwenesis_vdp_regs[18] & 0x80;
+
+ int PlanA_first = PlanA_firstcol;
+ int PlanA_last = PlanA_lastcol;
+ int Window_last = Window_lastcol;
+ int Window_first = Window_firstcol;
+
+ if (window_down) {
+ if (line > Window_line) {
+ PlanA_first = PlanA_last = 0;
+ Window_last = screen_width;
+ Window_first = 0;
+ }
+ } else {
+
+ if (line < Window_line) {
+ PlanA_first = PlanA_last = 0;
+ Window_last = screen_width;
+ Window_first = 0;
+ }
+ }
+
+ // First draw A plane
+ uint8_t *pos = scr + PlanA_first; // scr + screen_width;
+ uint8_t *end = scr + PlanA_last; // scr + screen_width
+
+ //bool column_scrolling = BIT(gwenesis_vdp_regs[11], 2);
+ const unsigned int column_scrolling = gwenesis_vdp_regs[11] & 0x4;
+
+ // Invert horizontal scrolling (because it goes right, but we need to offset
+ // of the first screen pixel)
+ scrollx = -scrollx;
+ uint8_t col = (scrollx >> 3) & ntw_mask;
+ uint8_t patx = scrollx & 7;
+
+ unsigned int numcell = 0;
+ pos -= patx;
+ while (pos < end) {
+ // Calculate vertical scrolling for the current line
+ uint16_t scrolly = *vsram + line;
+ uint8_t row = (scrolly >> 3) & nth_mask;
+ uint8_t paty = scrolly & 7;
+
+ // unsigned int nt = ntaddr + row * (2 * ntwidth);
+ unsigned int nt = ntaddr + row * ntwidth_x2;
+
+ draw_pattern_planeA(pos, FETCH16VRAM(nt + col * 2), paty);
+
+ col = (col + 1) & ntw_mask;
+ pos += 8;
+ numcell++;
+
+ // If per-column scrolling is active, increment VSRAM pointer
+ if (column_scrolling && (numcell & 1) == 0)
+ vsram += 2;
+ }
+
+ // Second Draw Window Plane
+ int row = line >> 3;
+ int paty = line & 7;
+ //int wdwidth = (screen_width == 320 ? 64 : 32);
+ //unsigned int nt = base_w + row * 2 * wdwidth + Window_first / 4;
+
+ int wdwidth_x2 = (screen_width == 320 ? 128 : 64);
+
+ unsigned int nt = base_w + row * wdwidth_x2 + Window_first / 4;
+
+ /* (NumPlay: the window drawn from its own first column, not from plane A's end: a window on
+ the left was drawn past the line) */
+ uint8_t *w = scr + Window_first;
+ for (int i = Window_first / 8; i < Window_last / 8; ++i) {
+ draw_pattern_planeA(w, FETCH16VRAM(nt), paty);
+ nt += 2;
+ w += 8;
+ }
+}
+
+/******************************************************************************
+ *
+ * Render SPRITES on screen line
+ *
+ ******************************************************************************/
+
+//__attribute__((optimize("unroll-loops")))
+static inline __attribute__((always_inline))
+void draw_sprites_over_planes(int line)
+{
+ uint8_t *scr;
+
+ scr = &render_buffer[PIX_OVERFLOW];
+
+ // uint8_t mask = mode_h40 ? 0x7E : 0x7F;
+ // uint8_t *start_table = VRAM + ((gwenesis_vdp_regs[5] & mask) << 9);
+
+ uint8_t *start_table = VRAM + REG5_SAT_ADDRESS;
+
+ // This is both the size of the table as seen by the VDP
+ // *and* the maximum number of sprites that are processed
+ // (important in case of infinite loops in links).
+ const int SPRITE_TABLE_SIZE = (screen_width == 320) ? 80 : 64;
+ const int MAX_SPRITES_PER_LINE = (screen_width == 320) ? 20 : 16;
+ const int MAX_PIXELS_PER_LINE = (screen_width == 320) ? 320 : 256;
+
+ bool masking = false, one_sprite_nonzero = false; // overdraw = false;
+ int sidx = 0, num_sprites = 0, num_pixels = 0;
+ for (int i = 0; (i < SPRITE_TABLE_SIZE) && sidx < (SPRITE_TABLE_SIZE); ++i)
+ {
+ uint8_t *table = start_table + sidx*8;
+ uint8_t *cache = SAT_CACHE + sidx*8;
+ //uint8_t *cache = start_table + sidx*8;
+
+
+ int sy = ((cache[0] & 0x3) << 8) | cache[1];
+ int sx = ((table[6] & 0x3) << 8) | table[7];
+ uint16_t name = (table[4] << 8) | table[5];
+
+
+ int sh = BITS(cache[2], 0, 2) + 1;
+ int link = BITS(cache[3], 0, 7);
+
+ int isflipv = table[4] & 0x10;
+ int isfliph = table[4] & 0x8;
+
+ int sw = BITS(table[2], 2, 2) + 1;
+
+ sy -= 128;
+ if ((line >= sy) && (line < sy+sh*8))
+ {
+ // Sprite masking: a sprite on column 0 masks
+ // any lower-priority sprite, but with the following conditions
+ // * it only works from the second visible sprite on each line
+ // * if the previous line had a sprite pixel overflow, it
+ // works even on the first sprite
+ // Notice that we need to continue parsing the table after masking
+ // to see if we reach a pixel overflow (because it would affect masking
+ // on next line).
+ if (sx == 0)
+ {
+ if (one_sprite_nonzero || (sprite_overflow == line-1))
+ masking = true;
+ }
+ else
+ one_sprite_nonzero = true;
+
+ int row = (line - sy) >> 3;
+ int paty = (line - sy) & 7;
+ if (isflipv)
+ row = sh - row - 1;
+
+ sx -= 128;
+ if ((sx > (-sw * 8)) && (sx < screen_width) && !masking) {
+
+ name += row;
+
+ if (isfliph) {
+ name += sh * (sw - 1);
+ for (int p = 0; (p < sw) && (num_pixels < MAX_PIXELS_PER_LINE); p++) {
+
+ draw_pattern_sprite_over_planes(scr + sx + p * 8, name, paty);
+ name -= sh;
+ num_pixels += 8;
+
+ }
+ } else {
+ for (int p = 0; (p < sw) && (num_pixels < MAX_PIXELS_PER_LINE); p++) {
+
+ draw_pattern_sprite_over_planes(scr + sx + p * 8, name, paty);
+ name += sh;
+ num_pixels += 8;
+
+ }
+ }
+ }
+ else
+ num_pixels += sw*8;
+
+ if (num_pixels >= MAX_PIXELS_PER_LINE)
+ {
+ sprite_overflow = line;
+ break;
+ }
+ if (++num_sprites >= MAX_SPRITES_PER_LINE)
+ break;
+ }
+
+ if (link == 0) break;
+ sidx = link;
+ }
+
+ // if (overdraw)
+ // sprite_collision = true;
+}
+static inline __attribute__((always_inline))
+void draw_sprites(int line)
+{
+ uint8_t *scr;
+
+ scr = &sprite_buffer[PIX_OVERFLOW];
+
+ // uint8_t mask = mode_h40 ? 0x7E : 0x7F;
+ // uint8_t *start_table = VRAM + ((gwenesis_vdp_regs[5] & mask) << 9);
+
+ uint8_t *start_table = VRAM + REG5_SAT_ADDRESS;
+
+ // This is both the size of the table as seen by the VDP
+ // *and* the maximum number of sprites that are processed
+ // (important in case of infinite loops in links).
+ const int SPRITE_TABLE_SIZE = (screen_width == 320) ? 80 : 64;
+ const int MAX_SPRITES_PER_LINE = (screen_width == 320) ? 20 : 16;
+ const int MAX_PIXELS_PER_LINE = (screen_width == 320) ? 320 : 256;
+
+ bool masking = false, one_sprite_nonzero = false; // overdraw = false;
+ int sidx = 0, num_sprites = 0, num_pixels = 0;
+ for (int i = 0; i < SPRITE_TABLE_SIZE && sidx < SPRITE_TABLE_SIZE; ++i) {
+ uint8_t *table = start_table + sidx * 8;
+ uint8_t *cache = start_table + sidx * 8;
+
+ //uint8_t *cache = SAT_CACHE + sidx * 8;
+
+ int sy = ((cache[0] & 0x3) << 8) | cache[1];
+ int sx = ((table[6] & 0x3) << 8) | table[7];
+ uint16_t name = (table[4] << 8) | table[5];
+
+ int sh = BITS(cache[2], 0, 2) + 1;
+ int link = BITS(cache[3], 0, 7);
+
+ int isflipv = table[4] & 0x10;
+ int isfliph = table[4] & 0x8;
+
+ int sw = BITS(table[2], 2, 2) + 1;
+
+ sy -= 128;
+ if (line >= sy && line < sy + sh * 8) {
+ // Sprite masking: a sprite on column 0 masks
+ // any lower-priority sprite, but with the following conditions
+ // * it only works from the second visible sprite on each line
+ // * if the previous line had a sprite pixel overflow, it
+ // works even on the first sprite
+ // Notice that we need to continue parsing the table after masking
+ // to see if we reach a pixel overflow (because it would affect masking
+ // on next line).
+ if (sx == 0) {
+ if (one_sprite_nonzero || sprite_overflow == line - 1)
+ masking = true;
+ } else
+ one_sprite_nonzero = true;
+
+ int row = (line - sy) >> 3;
+ int paty = (line - sy) & 7;
+ if (isflipv)
+ row = sh - row - 1;
+
+ sx -= 128;
+ if (sx > -sw * 8 && sx < screen_width && !masking) {
+
+ name += row;
+
+ if (isfliph) {
+ name += sh * (sw - 1);
+ for (int p = 0; p < sw && num_pixels < MAX_PIXELS_PER_LINE; p++) {
+
+ draw_pattern_sprite(scr + sx + p * 8, name, paty);
+ name -= sh;
+ num_pixels += 8;
+ }
+ } else {
+ for (int p = 0; p < sw && num_pixels < MAX_PIXELS_PER_LINE; p++) {
+
+ draw_pattern_sprite(scr + sx + p * 8, name, paty);
+ name += sh;
+ num_pixels += 8;
+ }
+ }
+ } else
+ num_pixels += sw * 8;
+
+ if (num_pixels >= MAX_PIXELS_PER_LINE) {
+ sprite_overflow = line;
+ break;
+ }
+ if (++num_sprites >= MAX_SPRITES_PER_LINE)
+ break;
+ }
+
+ if (link == 0)
+ break;
+ sidx = link;
+ }
+
+ // if (overdraw)
+ // sprite_collision = true;
+}
+/******************************************************************************
+ *
+ * Parse PLANE A/B size,scrolling at the start of image rendering
+ *
+ ******************************************************************************/
+//static unsigned short current_line[320];
+
+void gwenesis_vdp_render_config()
+{
+ mode_h40 = REG12_MODE_H40;
+ mode_pal = REG1_PAL;
+
+ int ntwidth = BITS(gwenesis_vdp_regs[16], 0, 2);
+ int ntheight = BITS(gwenesis_vdp_regs[16], 4, 2);
+ ntwidth = (ntwidth + 1) * 32;
+ ntheight = (ntheight + 1) * 32;
+ ntw_mask = ntwidth - 1;
+ nth_mask = ntheight - 1;
+ ntwidth_x2= ntwidth *2;
+
+ // Window & A planes separation
+
+ if (mode_h40)
+ base_w = ((REG3_NAMETABLE_W & 0x1e) << 11);
+ else
+ base_w = ((REG3_NAMETABLE_W & 0x1f) << 11);
+
+
+ bool window_right = BIT(gwenesis_vdp_regs[17], 7);
+
+ // int window_is_bugged = 0;
+ PlanA_firstcol = 0;
+ PlanA_lastcol = screen_width;
+
+ Window_firstcol = 0;
+ Window_lastcol = 0;
+
+ if (window_right) {
+
+ Window_firstcol = REG17_WINDOW_HPOS * 16;
+ Window_lastcol = screen_width;
+
+ if (Window_firstcol > Window_lastcol)
+ Window_firstcol = Window_lastcol;
+
+ PlanA_firstcol = 0;
+ PlanA_lastcol = Window_firstcol;
+
+ } else {
+ Window_firstcol = 0;
+ Window_lastcol = REG17_WINDOW_HPOS * 16;
+ if (Window_lastcol > screen_width)
+ Window_lastcol = screen_width;
+
+ PlanA_firstcol = Window_lastcol;
+ PlanA_lastcol = screen_width;
+ // if (Window_lastcol != 0)
+ // window_is_bugged = 1;
+ }
+}
+
+/******************************************************************************
+ *
+ * Render a line on screen
+ * Get selected line and render it on screen processing each plane.
+ *
+ ******************************************************************************/
+
+//#define CONV(b) ((0b11 1110 0000 0000 0000 0000 0000 & b)>>10) | ((0b00000 1111 1100 0000 0000 & b)>>5) | ((0b0000000000011111 & b))
+//#define SPACE(c) ((0b00 0000 0000 1111 1000 0000 0000 & c)<<10) | ((0b00000 0000 0111 1110 0000 & c)<<5) | ((0b0000000000011111 & c))
+
+#define CONV(b) ((0x3e00000 & b)>>10) | ((0xfc00 & b)>>5) | ((0x1f & b))
+#define SPACE(c) ((0xe800 & c)<<10) | ((0x7e0 & c)<<5) | ((0x1f & c))
+
+/* Function unused
+
+__attribute__((optimize("unroll-loops"))) static void
+blit_4to5_line(uint16_t *in, uint16_t *out) {
+
+ uint16_t *src_row = in;
+ uint16_t *dest_row = out;
+ for (int x_src = 0, x_dst = 0; x_src < 256; x_src += 4, x_dst += 5) {
+ uint32_t b0 = SPACE(src_row[x_src]);
+ uint32_t b1 = SPACE(src_row[x_src + 1]);
+ uint32_t b2 = SPACE(src_row[x_src + 2]);
+ uint32_t b3 = SPACE(src_row[x_src + 3]);
+
+ dest_row[x_dst] = CONV(b0);
+ dest_row[x_dst + 1] = CONV((b0 + b0 + b0 + b1) >> 2);
+ dest_row[x_dst + 2] = CONV((b1 + b2) >> 1);
+ dest_row[x_dst + 3] = CONV((b2 + b2 + b2 + b3) >> 2);
+ dest_row[x_dst + 4] = CONV(b3);
+ }
+}
+*/
+
+/* (NumPlay: the line in RGB565, with the shadow and highlight modes as gwenesis' computer
+ version draws them, handed to Retro-Go's screens, rg_line) */
+void rg_line(int y, const uint16_t *px);
+static uint16_t md_line[SCREEN_WIDTH];
+
+void gwenesis_vdp_render_line(int line)
+{
+ mode_h40 = REG12_MODE_H40;
+
+ // interlace mode not implemented
+ if (BITS(gwenesis_vdp_regs[12], 1, 2) != 0)
+ return;
+
+ if (line >= (REG1_PAL ? 240 : 224))
+ return;
+
+ uint16_t *out = md_line;
+ if (REG0_DISABLE_DISPLAY) {
+ memset(out, 0, sizeof md_line);
+ rg_line(line, out);
+ return;
+ }
+
+ uint8_t *pb = &render_buffer[PIX_OVERFLOW];
+ uint8_t *ps = &sprite_buffer[PIX_OVERFLOW];
+
+ if (MODE_SHI)
+ memset(ps, 0, 320);
+
+ draw_line_b(line);
+ draw_line_aw(line);
+
+ if (MODE_SHI)
+ draw_sprites(line);
+ else
+ draw_sprites_over_planes(line);
+
+ /* Mode Highlight/shadow is enabled */
+ if (MODE_SHI) {
+ for (int x = 0; x < screen_width; x++) {
+ uint8_t plane = pb[x];
+ uint8_t sprite = ps[x];
+ uint16_t rgb565;
+
+ if ((plane & 0xC0) < (sprite & 0xC0) ) {
+ switch (sprite & 0x3F) {
+ // Palette=3, Sprite=14 :> draw plane, force highlight
+ case 0x3E:
+ rgb565 = 0x8410 | ((CRAM565[plane] >> 1) & 0x7BEF);
+ break;
+ // Palette=3, Sprite=15 :> draw plane, force shadow
+ case 0x3F:
+ rgb565 = (CRAM565[plane] >> 1) & 0x7BEF;
+ break;
+ // draw sprite, normal
+ default:
+ rgb565 = CRAM565[sprite];
+ break;
+ }
+ } else {
+ rgb565 = CRAM565[plane];
+ }
+ out[x] = rgb565;
+ }
+
+ /* Normal mode*/
+ } else {
+ for (int x = 0; x < screen_width; x++)
+ out[x] = CRAM565[pb[x]];
+ }
+ rg_line(line, out);
+}
+
+void gwenesis_vdp_gfx_save_state() {
+ /*
+ SaveState* state;
+ state = saveGwenesisStateOpenForWrite("vdp_gfx");
+ saveGwenesisStateSetBuffer(state, "render_buffer", render_buffer, sizeof(render_buffer));
+ saveGwenesisStateSetBuffer(state, "sprite_buffer", sprite_buffer, sizeof(sprite_buffer));
+ saveGwenesisStateSet(state, "mode_h40", mode_h40);
+ saveGwenesisStateSet(state, "mode_pal", mode_pal);
+ saveGwenesisStateSet(state, "screen_width", screen_width);
+ saveGwenesisStateSet(state, "screen_height", screen_height);
+ saveGwenesisStateSet(state, "sprite_overflow", sprite_overflow);
+ saveGwenesisStateSet(state, "sprite_collision", sprite_collision);
+ saveGwenesisStateSet(state, "base_w", base_w);
+ saveGwenesisStateSet(state, "PlanA_firstcol", PlanA_firstcol);
+ saveGwenesisStateSet(state, "PlanA_lastcol", PlanA_lastcol);
+ saveGwenesisStateSet(state, "Window_firstcol", Window_firstcol);
+ saveGwenesisStateSet(state, "Window_lastcol", Window_lastcol);
+ */
+}
+
+void gwenesis_vdp_gfx_load_state() {
+ /*
+ SaveState* state = saveGwenesisStateOpenForRead("vdp_gfx");
+ saveGwenesisStateGetBuffer(state, "render_buffer", render_buffer, sizeof(render_buffer));
+ saveGwenesisStateGetBuffer(state, "sprite_buffer", sprite_buffer, sizeof(sprite_buffer));
+ mode_h40 = saveGwenesisStateGet(state, "mode_h40");
+ mode_pal = saveGwenesisStateGet(state, "mode_pal");
+ screen_width = saveGwenesisStateGet(state, "screen_width");
+ screen_height = saveGwenesisStateGet(state, "screen_height");
+ sprite_overflow = saveGwenesisStateGet(state, "sprite_overflow");
+ sprite_collision = saveGwenesisStateGet(state, "sprite_collision");
+ base_w = saveGwenesisStateGet(state, "base_w");
+ PlanA_firstcol = saveGwenesisStateGet(state, "PlanA_firstcol");
+ PlanA_lastcol = saveGwenesisStateGet(state, "PlanA_lastcol");
+ Window_firstcol = saveGwenesisStateGet(state, "Window_firstcol");
+ Window_lastcol = saveGwenesisStateGet(state, "Window_lastcol");
+ */
+}
diff --git a/games/retrogo/src/md/gwenesis_vdp_mem.c b/games/retrogo/src/md/gwenesis_vdp_mem.c
new file mode 100644
index 00000000..4e0949e4
--- /dev/null
+++ b/games/retrogo/src/md/gwenesis_vdp_mem.c
@@ -0,0 +1,1043 @@
+/*
+Gwenesis : Genesis & megadrive Emulator.
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = "bzhxx"
+__contact__ = "https://github.com/bzhxx"
+__license__ = "GPLv3"
+
+*/
+
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include "m68k.h"
+#include "gwenesis_vdp.h"
+#include "gwenesis_io.h"
+#include "gwenesis_bus.h"
+#include "gwenesis_savestate.h"
+
+/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound
+ chips' writes go nowhere; and nothing printed) */
+#define YM2612Read(clk) 0
+#define YM2612Write(a, v, clk) ((void)0)
+#define YM2612Init() ((void)0)
+#define YM2612Config(x) ((void)0)
+#define YM2612ResetChip() ((void)0)
+#define gwenesis_SN76489_Write(v, clk) ((void)0)
+#define gwenesis_SN76489_Init(a, b, c) ((void)0)
+#define gwenesis_SN76489_Reset() ((void)0)
+#define printf(...) ((void)0)
+#define vfprintf(...) ((void)0)
+
+#include <assert.h>
+
+#if GNW_TARGET_MARIO !=0 || GNW_TARGET_ZELDA!=0
+ #pragma GCC optimize("Ofast")
+#endif
+
+#define VDP_MEM_DISABLE_LOGGING 1
+
+#if !VDP_MEM_DISABLE_LOGGING
+#include <stdarg.h>
+void vdpm_log(const char *subs, const char *fmt, ...) {
+ extern int frame_counter;
+ extern int scan_line;
+
+ va_list va;
+
+ printf("%06d:%03d :[%s] vc:%04x hc:%04x hv:%04x ", frame_counter, scan_line, subs,gwenesis_vdp_vcounter(),gwenesis_vdp_hcounter(),gwenesis_vdp_hvcounter());
+
+ va_start(va, fmt);
+ vfprintf(stdout, fmt, va);
+ va_end(va);
+ printf("\n");
+}
+#else
+ #define vdpm_log(...) do {} while(0)
+#endif
+
+//#define _DMA_TRACE_
+
+/* Setup VDP Memories */
+
+
+#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0
+ extern uint8_t emulator_framebuffer[1024*64];
+ unsigned char* VRAM = &emulator_framebuffer[0];
+#else
+ unsigned char *VRAM;
+#endif
+
+unsigned short CRAM[CRAM_MAX_SIZE]; // CRAM - Palettes
+unsigned char SAT_CACHE[SAT_CACHE_MAX_SIZE]; // Sprite cache
+unsigned char gwenesis_vdp_regs[REG_SIZE]; // Registers
+unsigned short fifo[FIFO_SIZE]; // Fifo
+unsigned short CRAM565[CRAM_MAX_SIZE * 4]; // CRAM - Palettes
+unsigned short VSRAM[VSRAM_MAX_SIZE]; // VSRAM - Scrolling
+
+// Define VDP control code and set initial code
+static unsigned char code_reg = 0;
+// Define VDP control address and set initial address
+static unsigned short address_reg = 0;
+// Define VDP control pending and set initial state
+int command_word_pending = 0;
+// Define VDP status and set initial status value
+unsigned short gwenesis_vdp_status = 0x3C00;
+
+extern int scan_line;
+
+// Define DMA
+//static unsigned int dma_length;
+//static unsigned int dma_source;
+// Define and set DMA FILL pending as initial state
+ int dma_fill_pending = 0;
+
+// Define HVCounter latch and set initial state
+static int hvcounter_latch = 0;
+static int hvcounter_latched = 0;
+
+int hint_pending;
+
+
+// Define VIDEO MODE
+extern int mode_pal;
+
+extern int sprite_overflow;
+extern bool sprite_collision;
+
+// Store last address r/w
+//static unsigned int gwenesis_vdp_laddress_r=0;
+//unsigned int gwenesis_vdp_laddress_w=0;
+
+//static int DMA_RUN=0;
+
+// 16 bits access to VRAM
+#define FETCH16(A) ( ( (*(unsigned short *)&VRAM[(A)]) >> 8 ) | ( (*(unsigned short *)&VRAM[(A)]) << 8 ) )
+
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 Reset
+ * Clear all volatile memory
+ *
+ ******************************************************************************/
+
+int m68k_irq_acked(int irq) {
+
+ /* VINT has higher priority (Fatal Rewind) */
+ if (REG1_VBLANK_INTERRUPT && (gwenesis_vdp_status & STATUS_VIRQPENDING))
+ {
+ /* Clear VINT pending flag */
+ gwenesis_vdp_status &= ~STATUS_VIRQPENDING;
+
+ if (hint_pending && REG0_LINE_INTERRUPT)
+ m68k_set_irq(4);
+ else
+ m68k_set_irq(0);
+
+ }
+ else
+ {
+ /* Clear HINT pending flag */
+ hint_pending = 0;
+
+ /* Update IRQ status */
+ m68k_set_irq(0);
+ }
+
+ return M68K_INT_ACK_AUTOVECTOR;
+}
+
+
+void gwenesis_vdp_reset() {
+ memset(VRAM, 0, VRAM_MAX_SIZE);
+ memset(SAT_CACHE, 0, sizeof(SAT_CACHE));
+ memset(CRAM, 0, sizeof(CRAM));
+ memset(CRAM565, 0, sizeof(CRAM565));
+ memset(VSRAM, 0, sizeof(VSRAM));
+ memset(gwenesis_vdp_regs, 0, sizeof(gwenesis_vdp_regs));
+ command_word_pending = 0;
+ address_reg = 0;
+ code_reg = 0;
+ hint_pending = 0;
+ // _vcounter = 0;
+ gwenesis_vdp_status = 0x3C00;
+ // //line_counter_interrupt = 0;
+ hvcounter_latched = 0;
+
+ // register the M68K interrupt
+ m68k_set_int_ack_callback(m68k_irq_acked);
+}
+
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 HCOUNTER
+ * Process SEGA 315-5313 HCOUNTER based on M68K Cycles
+ *
+ ******************************************************************************/
+//static inline __attribute__((always_inline))
+int gwenesis_vdp_hcounter()
+{
+ int mclk = m68k_cycles_run() ;
+ int pixclk;
+
+ // Accurate 9-bit hcounter emulation, from timing posted here:
+ // http://gendev.spritesmind.net/forum/viewtopic.php?p=17683#17683
+ if (REG12_MODE_H40)
+ {
+ pixclk = mclk * 420 / VDP_CYCLES_PER_LINE;
+ pixclk += 0xD;
+ if (pixclk >= 0x16D)
+ pixclk += 0x1C9 - 0x16D;
+ }
+ else
+ {
+ pixclk = mclk * 342 / VDP_CYCLES_PER_LINE;
+ pixclk += 0xB;
+ if (pixclk >= 0x128)
+ pixclk += 0x1D2 - 0x128;
+ }
+
+ return pixclk & 0x1FF;
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 VCOUNTER
+ * Process SEGA 315-5313 VCOUNTER based on M68K Cycles
+ *
+ ******************************************************************************/
+//static inline __attribute__((always_inline))
+int gwenesis_vdp_vcounter()
+{
+
+ int vc = scan_line;
+ int VERSION_PAL = gwenesis_vdp_status & 1;
+
+ /*
+ if (VERSION_PAL && mode_pal && (vc >= 0x10B))
+ vc += 0x1D2 - 0x10B;
+ else if (VERSION_PAL && (mode_pal==0) && (vc >= 0x103))
+ vc += 0x1CA - 0x103;
+ else if ((VERSION_PAL ==0 ) && (vc >= 0xEB))
+ vc += 0x1E5 - 0xEB;
+ assert(vc < 0x200);
+ */
+ if (VERSION_PAL && mode_pal && (vc >= 267))
+ vc = scan_line - 58;
+ else if (VERSION_PAL && (mode_pal==0) && (vc >= 259))
+ vc = scan_line - 42;
+ else if ((VERSION_PAL == 0 ) && (vc >= 235))
+ vc = scan_line -6;
+ assert(vc < 0x200);
+
+ // printf("VERSION_PAL:%d , mode_pal:%d,line:%d,vc:%d\n",VERSION_PAL,mode_pal,scan_line,vc);
+ return vc;
+}
+/******************************************************************************
+ *
+ * SEGA 315-5313 HVCOUNTER
+ * Process SEGA 315-5313 HVCOUNTER based on HCOUNTER and VCOUNTER
+ *
+ ******************************************************************************/
+//static inline __attribute__((always_inline))
+unsigned short gwenesis_vdp_hvcounter()
+{
+ /* H/V Counter */
+ if (hvcounter_latched == 1)
+ return hvcounter_latch;
+
+ int hc = gwenesis_vdp_hcounter();
+ int vc = gwenesis_vdp_vcounter();
+ assert(vc < 512);
+ assert(hc < 512);
+
+ return ((vc & 0xFF) << 8) | (hc >> 1);
+
+}
+
+//static inline __attribute__((always_inline))
+bool vblank(void)
+{
+ int vc = gwenesis_vdp_vcounter();
+ // printf("vc=%d,REG1_DISP_ENABLED=%d,VBLAN?%d\n",vc,REG1_DISP_ENABLED,
+ // mode_pal?((vc >= 0xF0) && (vc < 0x1FF)):((vc >= 0xE0) && (vc < 0x1FF)));
+
+ if (REG1_DISP_ENABLED ==0)
+ return true;
+
+ if (mode_pal)
+ return ((vc >= 0xF0) && (vc < 0x1FF));
+ else
+ return ((vc >= 0xE0) && (vc < 0x1FF));
+
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 Set Register
+ * Write an value to specified register
+ *
+ ******************************************************************************/
+static inline __attribute__((always_inline)) void gwenesis_vdp_register_w(int reg, unsigned char value)
+{
+ // Mode4 is not emulated yet. Anyway, access to registers > 0xA is blocked.
+ if ((BIT(gwenesis_vdp_regs[0x1], 2)==0) && reg > 0xA)
+ return;
+
+ gwenesis_vdp_regs[reg] = value;
+ vdpm_log(__FUNCTION__, "reg:%02d <- %02x", reg, value);
+
+
+ // Writing a register clear the first command word
+ // (see sonic3d intro wrong colors, and vdpfifotesting)
+ code_reg &= ~0x3;
+ address_reg &= ~0x3FFF;
+
+ switch (reg)
+ {
+ case 0:
+
+ if (REG0_HVLATCH && (hvcounter_latched == 0))
+ {
+ hvcounter_latch = gwenesis_vdp_hvcounter();
+ hvcounter_latched = 1;
+ //printf("HVcounter latched:%x\n",hvcounter_latch);
+ }
+ else if ((REG0_HVLATCH ==0) && (hvcounter_latched == 1)){
+ //printf("HVcounter released\n");
+ hvcounter_latched = 0;
+ }
+
+ break;
+ }
+}
+
+/******************************************************************************
+ *
+ * Simulate FIFO
+ *
+ ******************************************************************************/
+ static inline __attribute__((always_inline))
+void push_fifo(unsigned int value)
+{
+ fifo[3] = fifo[2];
+ fifo[2] = fifo[1];
+ fifo[1] = fifo[0];
+ fifo[0] = value;
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 VRAM Write
+ * Write an value to VRAM on specified address
+ *
+ ******************************************************************************/
+static inline __attribute__((always_inline))
+void gwenesis_vdp_vram_write(unsigned int address, unsigned int value)
+{
+ VRAM[address] = value;
+
+ // Update internal SAT Cache
+ // used in Castlevania Bloodlines
+ if (address >= REG5_SAT_ADDRESS && address < REG5_SAT_ADDRESS + REG5_SAT_SIZE)
+ SAT_CACHE[address - REG5_SAT_ADDRESS] = value;
+}
+
+static inline __attribute__((always_inline))
+unsigned short status_register_r(void)
+{
+ unsigned short status = gwenesis_vdp_status; // & 0xF800;
+ // unsigned short status = gwenesis_vdp_status;// & 0xFC00;
+
+ int hc = gwenesis_vdp_hcounter();
+ // int vc = gwenesis_vdp_vcounter();
+
+ // TODO: FIFO not emulated
+ status |= STATUS_FIFO_EMPTY;
+
+ // VBLANK bit
+ if (vblank())
+ status |= STATUS_VBLANK;
+
+ // HBLANK bit (see Nemesis doc, as linked in hcounter())
+ if (REG12_MODE_H40)
+ {
+ if (hc < 0xA || hc >= 0x166)
+ status |= STATUS_HBLANK;
+ }
+ else
+ {
+ if (hc < 0x9 || hc >= 0x126)
+ status |= STATUS_HBLANK;
+ }
+
+ if (sprite_overflow)
+ status |= STATUS_SPRITEOVERFLOW;
+ if (sprite_collision)
+ status |= STATUS_SPRITECOLLISION;
+
+ if (mode_pal)
+ status |= STATUS_PAL;
+
+ // reading the status clears the pending flag for command words
+ command_word_pending = 0;
+
+ //gwenesis_vdp_status = status;
+
+ // printf("VDP status read:%04X H?%d V?%d line=%d\n",status, status & STATUS_HBLANK ,status & STATUS_VBLANK,scan_line);
+ return status;
+}
+/******************************************************************************
+ *
+ * SEGA 315-5313 Get Register
+ * Read an value from specified register
+ *
+ ******************************************************************************/
+unsigned int gwenesis_vdp_get_reg(int reg)
+{
+ return gwenesis_vdp_regs[reg];
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 DMA Fill
+ * DMA process to fill memory
+ *
+ ******************************************************************************/
+static inline __attribute__((always_inline))
+void gwenesis_vdp_dma_fill(unsigned short value)
+{
+ //vdpm_log(__FUNCTION__,"@%x len:%x val:%x",REG21_DMA_SRCADDR_LOW,REG19_DMA_LENGTH,value);
+ int dma_length = REG19_DMA_LENGTH;
+
+ // This address is not required for fills,
+ // but it's still updated by the DMA engine.
+ unsigned short src_addr_low = REG21_DMA_SRCADDR_LOW;
+
+ if (dma_length == 0)
+ dma_length = 0xFFFF;
+
+ /*
+ vdpm_log(__FUNCTION__, "DMA %s fill: dst:%04x, length:%d, increment:%d, value=%02x",
+ (code_reg&0xF)==1 ? "VRAM" : ( (code_reg&0xF)==3 ? "CRAM" : "VSRAM"),
+ address_reg, dma_length, REG15_DMA_INCREMENT, value>>8);
+ */
+
+ switch (code_reg & 0xF) {
+ case 0x1:
+ do {
+ gwenesis_vdp_vram_write((address_reg ^ 1) & 0xFFFF, value >> 8);
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr_low++;
+ } while (--dma_length);
+ break;
+ case 0x3: // undocumented and buggy, see vdpfifotesting
+ do {
+ CRAM[(address_reg & 0x7f) >> 1] = fifo[3];
+
+ unsigned short pixel;
+ // Blue >> 9 << 2
+ pixel = (fifo[3] & 0xe00) >> 7;
+ // Green >> 5 << 5 << 3
+ pixel |= (fifo[3] & 0x0e0) << 3;
+ // Red >>1 << 11 << 2
+ pixel |= (fifo[3] & 0x00e) << 12;
+
+ // pixel_shadow = pixel >> 1;
+ // pixel_highlight = pixel_shadow | 0x8410;
+
+ // Normal pixel values when SHI is not enabled
+ CRAM565[(address_reg & 0x7f) >> 1] = pixel;
+ CRAM565[0x40 + ((address_reg & 0x7f) >> 1)] = pixel;
+ CRAM565[0x80 + ((address_reg & 0x7f) >> 1)] = pixel;
+ CRAM565[0xC0 + ((address_reg & 0x7f) >> 1)] = pixel;
+
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr_low++;
+ } while (--dma_length);
+ break;
+ case 0x5: // undocumented and buggy, see vdpfifotesting:
+ do {
+ VSRAM[(address_reg & 0x7f) >> 1] = fifo[3] & 0x03FF;
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr_low++;
+ } while (--dma_length);
+ break;
+ default:
+ printf("Invalid code during DMA fill\n");
+ }
+
+
+ // Clear DMA length at the end of transfer
+ gwenesis_vdp_regs[19] = gwenesis_vdp_regs[20] = 0;
+
+ // Update DMA source address after end of transfer
+ gwenesis_vdp_regs[21] = src_addr_low & 0xFF;
+ gwenesis_vdp_regs[22] = src_addr_low >> 8;
+
+ // gwenesis_vdp_regs[21] = src_addr_low >> 1 & 0xFF;
+ // gwenesis_vdp_regs[22] = src_addr_low >> 9 & 0xFF;
+ // gwenesis_vdp_regs[23] = src_addr_low >> 17 & 0xFF;
+
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 DMA M68K
+ * DMA process to copy from m68k to memory
+ *
+ ******************************************************************************/
+static inline __attribute__((always_inline))
+void gwenesis_vdp_dma_m68k()
+{
+
+ int dma_length = REG19_DMA_LENGTH;
+
+ // This address is not required for fills,
+ // but it's still updated by the DMA engine.
+ unsigned short src_addr_low = REG21_DMA_SRCADDR_LOW;
+ unsigned int src_addr_high = REG23_DMA_SRCADDR_HIGH;
+ unsigned int src_addr = (src_addr_high | src_addr_low) << 1;
+ unsigned int value;
+
+ if (dma_length == 0)
+ dma_length = 0xFFFF;
+
+ /*
+ vdpm_log(__FUNCTION__,"DMA M68k->%s copy: src:%04x, dst:%04x, length:%d, increment:%d",
+ (code_reg&0xF)==1 ? "VRAM" : ( (code_reg&0xF)==3 ? "CRAM" : "VSRAM"),
+ (src_addr_high | src_addr_low) << 1, address_reg, dma_length, REG15_DMA_INCREMENT);
+ */
+
+ /* Source is :
+ 68K_RAM if dma_source_high == 0x00FF : FETCH16RAM(dma_source_low << 1)
+ 68K_ROM otherwise : FETCH16ROM((dma_source_high | dma_source_low) << 1))
+ */
+
+ /* Source is 68K RAM */
+ if ( src_addr & 0x800000) {
+
+ switch (code_reg & 0xF) {
+
+ case 0x1: // dest is VRAM
+ do {
+ value = FETCH16RAM( src_addr );
+ push_fifo(value);
+ gwenesis_vdp_vram_write((address_reg)&0xFFFF, value >> 8);
+ gwenesis_vdp_vram_write((address_reg ^ 1) & 0xFFFF, value & 0xFF);
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr += 2;
+ } while (--dma_length);
+ break;
+
+ case 0x3: // dest is CRAM
+ do {
+ value = FETCH16RAM( src_addr );
+ push_fifo(value);
+ CRAM[(address_reg & 0x7f) >> 1] = value;
+
+ unsigned short pixel;
+ // unsigned short pixel_shadow, pixel_highlight;
+ // Blue >> 9 << 2
+ pixel = (value & 0xe00) >> 7;
+ // Green >> 5 << 5 << 3
+ pixel |= (value & 0x0e0) << 3;
+ // Red >>1 << 11 << 2
+ pixel |= (value & 0x00e) << 12;
+
+ // Normal pixel values when SHI is not enabled
+ // add mirror 0x80 when high priority flag is set
+ CRAM565[(address_reg & 0x7f) >> 1] = pixel;
+ CRAM565[0x40 + ((address_reg & 0x7f) >> 1)] = pixel;
+ CRAM565[0x80 + ((address_reg & 0x7f) >> 1)] = pixel;
+ CRAM565[0xC0 + ((address_reg & 0x7f) >> 1)] = pixel;
+
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr += 2;
+ } while (--dma_length);
+ break;
+
+ case 0x5: // dest is VSRAM
+
+ do {
+ value = FETCH16RAM( src_addr );
+ push_fifo(value);
+ VSRAM[(address_reg & 0x7f) >> 1] = value & 0x03FF;
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr += 2;
+ } while (--dma_length);
+ break;
+ default: // dest in unknown
+ break;
+ }
+
+ /* source is 68K ROM */
+ } else {
+
+ // unsigned int dma_source_address = (dma_source_high | dma_source_low) << 1;
+
+ switch (code_reg & 0xF) {
+
+ case 0x1: // dest is VRAM
+
+ do {
+ value = FETCH16ROM(src_addr);
+ push_fifo(value);
+ gwenesis_vdp_vram_write((address_reg)&0xFFFF, value >> 8);
+ gwenesis_vdp_vram_write((address_reg ^ 1) & 0xFFFF, value & 0xFF);
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr += 2;
+ } while (--dma_length);
+ break;
+
+ case 0x3: // dest is CRAM
+
+ do {
+ value = FETCH16ROM(src_addr);
+ push_fifo(value);
+ CRAM[(address_reg & 0x7f) >> 1] = value;
+
+ unsigned short pixel;
+ // unsigned short pixel_shadow, pixel_highlight;
+ // Blue >> 9 << 2
+ pixel = (value & 0xe00) >> 7;
+ // Green >> 5 << 5 << 3
+ pixel |= (value & 0x0e0) << 3;
+ // Red >>1 << 11 << 2
+ pixel |= (value & 0x00e) << 12;
+
+ // pixel_shadow = pixel >> 1;
+ // pixel_highlight = pixel_shadow | 0x8410;
+
+ // Normal pixel values when SHI is not enabled
+ // add mirror 0x80 when high priority flag is set
+ CRAM565[(address_reg & 0x7f) >> 1] = pixel;
+ CRAM565[0x40 + ((address_reg & 0x7f) >> 1)] = pixel;
+ CRAM565[0x80 + ((address_reg & 0x7f) >> 1)] = pixel;
+ CRAM565[0xC0 + ((address_reg & 0x7f) >> 1)] = pixel;
+
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr += 2;
+ } while (--dma_length);
+ break;
+
+ case 0x5: // dest is VSRAM
+
+ do {
+ value = FETCH16ROM(src_addr);
+ push_fifo(value);
+ VSRAM[(address_reg & 0x7f) >> 1] = value & 0x03FF;
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr += 2;
+ } while (--dma_length);
+ break;
+ default: // dest in unknown
+ break;
+ }
+
+ }
+
+ // Update DMA source address after end of transfer
+ gwenesis_vdp_regs[21] = src_addr & 0xFF; //src_addr_low & 0xFF;
+ gwenesis_vdp_regs[22] = (src_addr >> 8 ) & 0xFF; //src_addr_low >> 8;
+
+ // Clear DMA length at the end of transfer
+ gwenesis_vdp_regs[19] = gwenesis_vdp_regs[20] = 0;
+
+}
+/******************************************************************************
+ *
+ * SEGA 315-5313 DMA Copy
+ * DMA process to copy from memory to memory
+ *
+ ******************************************************************************/
+static inline __attribute__((always_inline))
+void gwenesis_vdp_dma_copy()
+{
+ // DMA_RUN=1;
+
+ int dma_length = REG19_DMA_LENGTH;
+ unsigned short src_addr_low = REG21_DMA_SRCADDR_LOW;
+ //vdpm_log(__FUNCTION__,"length:%x src:%x",dma_length,src_addr_low);
+
+ do
+ {
+ unsigned short value = VRAM[src_addr_low ^ 1];
+ gwenesis_vdp_vram_write((address_reg ^ 1) & 0xFFFF, value);
+
+ address_reg += REG15_DMA_INCREMENT;
+ src_addr_low++;
+ } while (--dma_length);
+
+ // Update DMA source address after end of transfer
+ gwenesis_vdp_regs[21] = src_addr_low & 0xFF;
+ gwenesis_vdp_regs[22] = src_addr_low >> 8;
+
+ // Clear DMA length at the end of transfer
+ gwenesis_vdp_regs[19] = gwenesis_vdp_regs[20] = 0;
+
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 read data R16
+ * Read an data value from mapped memory on specified address
+ * and return as word
+ *
+ ******************************************************************************/
+static inline __attribute__((always_inline))
+unsigned int gwenesis_vdp_read_data_port_16()
+{
+ enum
+ {
+ CRAM_BITMASK = 0x0EEE,
+ VSRAM_BITMASK = 0x07FF,
+ VRAM8_BITMASK = 0x00FF
+ };
+ unsigned int value;
+ command_word_pending = 0;
+
+ //if (code_reg & 1) /* check if write is set */
+ // {
+ switch (code_reg & 0xF)
+ {
+ case 0x0:
+ // No byteswapping here
+ value = VRAM[(address_reg)&0xFFFE] << 8;
+ value |= VRAM[(address_reg | 1) & 0xFFFF];
+ address_reg += REG15_DMA_INCREMENT;
+ address_reg &= 0xFFFF;
+ //vdpm_log(__FUNCTION__,"%04x",value);
+
+ return value;
+ case 0x4:
+ if (((address_reg & 0x7f) >> 1) >= 0x28)
+ value = VSRAM[0];
+ else
+ value = VSRAM[(address_reg & 0x7f) >> 1];
+ value = (value & VSRAM_BITMASK) | (fifo[3] & ~VSRAM_BITMASK);
+ address_reg += REG15_DMA_INCREMENT;
+ address_reg &= 0x7F;
+ // vdpm_log(__FUNCTION__,"%04x",value);
+
+ return value;
+ case 0x8:
+ value = CRAM[(address_reg & 0x7f) >> 1];
+ value = (value & CRAM_BITMASK) | (fifo[3] & ~CRAM_BITMASK);
+ address_reg += REG15_DMA_INCREMENT;
+ address_reg &= 0x7F;
+ // vdpm_log(__FUNCTION__,"%04x",value);
+
+ return value;
+ case 0xC: /* 8-Bit memory access */
+ value = VRAM[(address_reg ^ 1) & 0xFFFF];
+ value = (value & VRAM8_BITMASK) | (fifo[3] & ~VRAM8_BITMASK);
+ address_reg += REG15_DMA_INCREMENT;
+ address_reg &= 0xFFFF;
+ // vdpm_log(__FUNCTION__,"%04x",value);
+
+ return value;
+ default:
+ printf("unhandled gwenesis_vdp_read_data_port_16(%x)\n", address_reg);
+ return 0xFF;
+ }
+ // }
+ // return 0x00;
+}
+
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 write to control port
+ * Write an control value to SEGA 315-5313 control port
+ *
+ ******************************************************************************/
+static inline __attribute__((always_inline))
+void gwenesis_vdp_control_port_write(unsigned int value)
+{
+ //vdpm_log(__FUNCTION__,"%04x",value);
+
+ if (command_word_pending == 1) {
+ // second half of the command word
+ code_reg &= ~0x3C;
+ code_reg |= (value >> 2) & 0x3C;
+ address_reg &= 0x3FFF;
+ address_reg |= value << 14;
+ command_word_pending = 0;
+ //vdpm_log(__FUNCTION__,"command word 2nd code:%x address:%x", code_reg, address_reg);
+
+
+ // DMA trigger
+ if (code_reg & (1<<5)) {
+
+ // Check master DMA enable, otherwise skip
+ if (REG1_DMA_ENABLED == 0)
+ return;
+
+ // gwenesis_vdp_status |= 0x2;
+ switch (REG23_DMA_TYPE) {
+ case 0:
+ case 1:
+
+ gwenesis_vdp_dma_m68k();
+ break;
+
+ case 2:
+
+ // VRAM fill will trigger on next data port write
+ dma_fill_pending = 1;
+ break;
+
+ case 3:
+
+ gwenesis_vdp_dma_copy();
+ break;
+ }
+ }
+ return;
+ }
+ if ((value >> 14) == 2) {
+
+ gwenesis_vdp_register_w((value >> 8) & 0x1F, value & 0xFF);
+ return;
+ }
+
+ // Anything else is treated as first half of the command word
+ // We directly update the code reg and address reg
+ code_reg &= ~0x3;
+ code_reg |= value >> 14;
+ address_reg &= ~0x3FFF;
+ address_reg |= value & 0x3FFF;
+ command_word_pending = 1;
+ // vdpm_log(__FUNCTION__,"command word 1st code:%x address:%x", code_reg, address_reg);
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 write data W16
+ * Write an data value to mapped memory on specified address
+ *
+ ******************************************************************************/
+static inline __attribute__((always_inline))
+void gwenesis_vdp_write_data_port_16(unsigned int value)
+{
+ vdpm_log(__FUNCTION__,"%04x",value);
+
+ command_word_pending = 0;
+
+ push_fifo(value);
+
+ switch (code_reg & 0xF)
+ {
+ case 0x1: /* VRAM write */
+ //vdpm_log(__FUNCTION__,"VRAM write : addr:%x increment:%d value:%04x",
+ // address_reg, REG15_DMA_INCREMENT, value);
+ gwenesis_vdp_vram_write(address_reg& 0xFFFF, (value >> 8) & 0xFF);
+ gwenesis_vdp_vram_write((address_reg^1)& 0xFFFF, (value)&0xFF);
+ address_reg += REG15_DMA_INCREMENT;
+ address_reg &= 0xFFFF;
+
+ break;
+ case 0x3: /* CRAM write */
+ //vdpm_log(__FUNCTION__,"CRAM write : addr:%x increment:%d value:%04x",
+ // address_reg, REG15_DMA_INCREMENT, value);
+ CRAM[(address_reg & 0x7f) >> 1] = value;
+
+ unsigned short pixel;
+ //unsigned short pixel_shadow,pixel_highlight;
+
+ // Blue >> 9 << 2
+ pixel = (value & 0xe00) >> 7;
+ // Green >> 5 << 5 << 3
+ pixel |= (value & 0x0e0) << 3;
+ // Red >>1 << 11 << 2
+ pixel |= (value & 0x00e) << 12;
+
+ // Normal pixel values when SHI is not enabled
+ CRAM565[(address_reg & 0x7f) >> 1] = pixel;
+ CRAM565[0x40 + ((address_reg & 0x7f) >> 1)] = pixel;
+ CRAM565[0x80 + ((address_reg & 0x7f) >> 1)] = pixel;
+ CRAM565[0xC0 + ((address_reg & 0x7f) >> 1)] = pixel;
+
+ address_reg += REG15_DMA_INCREMENT;
+ address_reg &= 0xFFFF;
+
+ break;
+ case 0x5: /* VSRAM write */
+ //vdpm_log(__FUNCTION__,"VSRAM write : addr:%x increment:%d value:%04x",
+ // address_reg, REG15_DMA_INCREMENT, value);
+ // printf("write dataport 16: VSRAM@%04x:%04x\n",address_reg,value);
+ VSRAM[(address_reg & 0x7f) >> 1] = value & 0X03FF;
+ address_reg += REG15_DMA_INCREMENT;
+ address_reg &= 0xFFFF;
+ break;
+ case 0x0:
+ case 0x4:
+ case 0x8: // Write operation after setting up
+ // Makes Compatible with Alladin and Ecco 2
+ break;
+ case 0x9: // VDP FIFO TEST
+ break;
+ default:
+ printf("VDP Data Port invalid");
+ }
+
+ /* if a DMA is scheduled, do it */
+ if (dma_fill_pending)
+ {
+ dma_fill_pending = 0;
+ gwenesis_vdp_dma_fill(value);
+ return;
+ }
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 Get Status
+ * Return current VDP Status
+ *
+ ******************************************************************************/
+unsigned int gwenesis_vdp_get_status()
+{
+ return gwenesis_vdp_status;
+}
+
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 read from memory R8
+ * Read an value from mapped memory on specified address
+ * and return as byte
+ *
+ ******************************************************************************/
+ //static inline
+unsigned int gwenesis_vdp_read_memory_8(unsigned int address)
+{
+ unsigned int ret = gwenesis_vdp_read_memory_16(address & ~1);
+ if (address & 1)
+ return ret & 0xFF;
+
+ // vdpm_log(__FUNCTION__,"%04x : %04x",address,ret);
+
+ return ret >> 8;
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 read from memory R16
+ * Read an value from mapped memory on specified address
+ * and return as word
+ *
+ ******************************************************************************/
+ //static inline
+unsigned int gwenesis_vdp_read_memory_16(unsigned int address)
+{
+
+ address &= 0x1F;
+
+ if (address < 0X4)
+ return gwenesis_vdp_read_data_port_16();
+ else if (address < 0x8)
+ return status_register_r();
+ else if (address < 0xf)
+ return gwenesis_vdp_hvcounter();
+ else
+ return 0xff;
+
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 write to memory W8
+ * Write an byte value to mapped memory on specified address
+ *
+ ******************************************************************************/
+ //static inline
+void gwenesis_vdp_write_memory_8(unsigned int address, unsigned int value)
+{
+ gwenesis_vdp_write_memory_16(address & ~1, (value << 8) | value);
+
+}
+
+/******************************************************************************
+ *
+ * SEGA 315-5313 write to memory W16
+ * Write an word value to mapped memory on specified address
+ *
+ ******************************************************************************/
+ //static inline
+ extern int system_clock;
+void gwenesis_vdp_write_memory_16(unsigned int address, unsigned int value) {
+ address = address & 0x1F;
+
+ if (address < 0x4) {
+ gwenesis_vdp_write_data_port_16(value);
+ return;
+ }
+ if (address < 0x8) {
+ gwenesis_vdp_control_port_write(value);
+ return;
+ }
+ if (address < 0x18) { // PSG 8 bits write
+ vdpm_log(__FUNCTION__,"PSG sclk=%d,mclk=%d", system_clock, m68k_cycles_master());
+ gwenesis_SN76489_Write(value, m68k_cycles_master());
+
+ return;
+ }
+ // UNHANDLED
+ printf("unhandled gwenesis_vdp_write(%x, %x)\n", address, value);
+
+}
+
+void gwenesis_vdp_mem_save_state() {
+ SaveState* state;
+ state = saveGwenesisStateOpenForWrite("vdp_mem");
+
+ /* (VRAM: a part of the state of its own, md.c) */
+ saveGwenesisStateSetBuffer(state, "CRAM", CRAM, sizeof(CRAM));
+ saveGwenesisStateSetBuffer(state, "SAT_CACHE", SAT_CACHE, sizeof(SAT_CACHE));
+ saveGwenesisStateSetBuffer(state, "gwenesis_vdp_regs", gwenesis_vdp_regs, sizeof(gwenesis_vdp_regs));
+ saveGwenesisStateSetBuffer(state, "fifo", fifo, sizeof(fifo));
+ saveGwenesisStateSetBuffer(state, "CRAM565", CRAM565, sizeof(CRAM565));
+ saveGwenesisStateSetBuffer(state, "VSRAM", VSRAM, sizeof(VSRAM));
+ saveGwenesisStateSet(state, "code_reg", code_reg);
+ saveGwenesisStateSet(state, "address_reg", address_reg);
+ saveGwenesisStateSet(state, "command_word_pending", command_word_pending);
+ saveGwenesisStateSet(state, "gwenesis_vdp_status", gwenesis_vdp_status);
+ saveGwenesisStateSet(state, "dma_fill_pending", dma_fill_pending);
+ saveGwenesisStateSet(state, "hvcounter_latch", hvcounter_latch);
+ saveGwenesisStateSet(state, "hvcounter_latched", hvcounter_latched);
+ saveGwenesisStateSet(state, "hint_pending", hint_pending);
+}
+
+void gwenesis_vdp_mem_load_state() {
+ SaveState* state = saveGwenesisStateOpenForRead("vdp_mem");
+
+ saveGwenesisStateGetBuffer(state, "CRAM", CRAM, sizeof(CRAM));
+ saveGwenesisStateGetBuffer(state, "SAT_CACHE", SAT_CACHE, sizeof(SAT_CACHE));
+ saveGwenesisStateGetBuffer(state, "gwenesis_vdp_regs", gwenesis_vdp_regs, sizeof(gwenesis_vdp_regs));
+ saveGwenesisStateGetBuffer(state, "fifo", fifo, sizeof(fifo));
+ saveGwenesisStateGetBuffer(state, "CRAM565", CRAM565, sizeof(CRAM565));
+ saveGwenesisStateGetBuffer(state, "VSRAM", VSRAM, sizeof(VSRAM));
+ code_reg = saveGwenesisStateGet(state, "code_reg");
+ address_reg = saveGwenesisStateGet(state, "address_reg");
+ command_word_pending = saveGwenesisStateGet(state, "command_word_pending");
+ gwenesis_vdp_status = saveGwenesisStateGet(state, "gwenesis_vdp_status");
+ dma_fill_pending = saveGwenesisStateGet(state, "dma_fill_pending");
+ hvcounter_latch = saveGwenesisStateGet(state, "hvcounter_latch");
+ hvcounter_latched = saveGwenesisStateGet(state, "hvcounter_latched");
+ hint_pending = saveGwenesisStateGet(state, "hint_pending");
+}
\ No newline at end of file
diff --git a/games/retrogo/src/md/m68k.h b/games/retrogo/src/md/m68k.h
new file mode 100644
index 00000000..f400d3db
--- /dev/null
+++ b/games/retrogo/src/md/m68k.h
@@ -0,0 +1,482 @@
+#ifndef M68K__HEADER
+#define M68K__HEADER
+
+/* ======================================================================== */
+/* ========================= LICENSING & COPYRIGHT ======================== */
+/* ======================================================================== */
+/*
+ * MUSASHI
+ * Version 3.32
+ *
+ * A portable Motorola M680x0 processor emulation engine.
+ * Copyright Karl Stenerud. All rights reserved.
+ *
+ * This code may be freely used for non-commercial purposes as long as this
+ * copyright notice remains unaltered in the source code and any binary files
+ * containing this code in compiled form.
+ *
+ * All other licensing terms must be negotiated with the author
+ * (Karl Stenerud).
+ *
+ * The latest version of this code can be obtained at:
+ * http://kstenerud.cjb.net
+ */
+
+ /* Modified by Eke-Eke for Genesis Plus GX:
+
+ - removed unused stuff to reduce memory usage / optimize execution (multiple CPU types support, NMI support, ...)
+ - moved stuff to compile statically in a single object file
+ - implemented support for global cycle count (shared by 68k & Z80 CPU)
+ - added support for interrupt latency (Sesame's Street Counting Cafe, Fatal Rewind)
+ - added proper cycle use on reset
+ - added cycle accurate timings for MUL/DIV instructions (thanks to Jorge Cwik !)
+ - fixed undocumented flags for DIV instructions (Blood Shot)
+ - fixed undocumented behaviors for ABCD/SBCD/NBCD instructions (thanks to flamewing for his test ROM)
+ - improved auto-vectored interrupts acknowledge cycle timing accuracy
+ - added MAIN-CPU & SUB-CPU support for Mega CD emulation
+
+ */
+
+/* ======================================================================== */
+/* ================================ INCLUDES ============================== */
+/* ======================================================================== */
+
+#include <setjmp.h>
+#include "macros.h"
+#ifdef HOOK_CPU
+#include "cpuhook.h"
+#endif
+
+/* ======================================================================== */
+/* ==================== ARCHITECTURE-DEPENDANT DEFINES ==================== */
+/* ======================================================================== */
+
+/* Check for > 32bit sizes */
+#if UINT_MAX > 0xffffffff
+ #define M68K_INT_GT_32_BIT 1
+#else
+ #define M68K_INT_GT_32_BIT 0
+#endif
+
+/* Data types used in this emulation core */
+#undef sint8
+#undef sint16
+#undef sint32
+#undef sint64
+#undef uint8
+#undef uint16
+#undef uint32
+#undef uint64
+#undef sint
+#undef uint
+
+#define sint8 signed char /* ASG: changed from char to signed char */
+#define sint16 signed short
+#define sint32 signed int /* AWJ: changed from long to int */
+#define uint8 unsigned char
+#define uint16 unsigned short
+#define uint32 unsigned int /* AWJ: changed from long to int */
+
+/* signed and unsigned int must be at least 32 bits wide */
+#define sint signed int
+#define uint unsigned int
+
+
+#if M68K_USE_64_BIT
+#define sint64 signed long long
+#define uint64 unsigned long long
+#else
+#define sint64 sint32
+#define uint64 uint32
+#endif /* M68K_USE_64_BIT */
+
+
+
+/* Allow for architectures that don't have 8-bit sizes */
+/*#if UCHAR_MAX == 0xff*/
+ #define MAKE_INT_8(A) (sint8)(A)
+/*#else
+ #undef sint8
+ #define sint8 signed int
+ #undef uint8
+ #define uint8 unsigned int
+ INLINE sint MAKE_INT_8(uint value)
+ {
+ return (value & 0x80) ? value | ~0xff : value & 0xff;
+ }*/
+/*#endif *//* UCHAR_MAX == 0xff */
+
+
+/* Allow for architectures that don't have 16-bit sizes */
+/*#if USHRT_MAX == 0xffff*/
+ #define MAKE_INT_16(A) (sint16)(A)
+/*#else
+ #undef sint16
+ #define sint16 signed int
+ #undef uint16
+ #define uint16 unsigned int
+ INLINE sint MAKE_INT_16(uint value)
+ {
+ return (value & 0x8000) ? value | ~0xffff : value & 0xffff;
+ }*/
+/*#endif *//* USHRT_MAX == 0xffff */
+
+
+/* Allow for architectures that don't have 32-bit sizes */
+/*#if UINT_MAX == 0xffffffff*/
+ #define MAKE_INT_32(A) (sint32)(A)
+/*#else
+ #undef sint32
+ #define sint32 signed int
+ #undef uint32
+ #define uint32 unsigned int
+ INLINE sint MAKE_INT_32(uint value)
+ {
+ return (value & 0x80000000) ? value | ~0xffffffff : value & 0xffffffff;
+ }*/
+/*#endif *//* UINT_MAX == 0xffffffff */
+
+
+
+/* ======================================================================== */
+/* ============================ GENERAL DEFINES =========================== */
+/*** BZHXX ***/
+#ifndef FALSE
+#define FALSE 0
+#define TRUE 1
+#endif
+
+#define ROM_SWAP
+#define RAM_SWAP
+
+// 16/32 bits acces to RAM/ROM
+
+#if GNW_TARGET_MARIO != 0 | GNW_TARGET_ZELDA != 0
+
+ extern unsigned char *ROM_DATA;
+ extern unsigned char *M68K_RAM;
+#else
+
+ extern unsigned char *ROM_DATA;
+ /* (NumPlay: the 68000's 64 KB of RAM in 16 pages of 4 KB, wherever the calculator has room) */
+ extern unsigned char *md_ram[16];
+#endif
+
+/* (NumPlay: nothing read past the ROM's size rounded up to a power of two) */
+extern unsigned int md_rom_mask;
+#define FETCH8ROM(A) ((ROM_DATA[((A) ^ 1) & md_rom_mask]))
+#define FETCH16ROM(A) ((*(unsigned short *)&ROM_DATA[(A) & md_rom_mask]))
+#define FETCH32ROM(A) ( (*(unsigned int *)&ROM_DATA[(A) & md_rom_mask] << 16) | (*(unsigned int *)&ROM_DATA[(A) & md_rom_mask] >> 16) )
+
+#if GNW_TARGET_MARIO !=0 || GNW_TARGET_ZELDA!=0
+
+/* Direct access to ITCRAM as M68KRAM on STM32H7 mapped at 0x0 !! */
+#define FETCH8RAM(A) (*(unsigned char *)(((A)&0XFFFF) ^ 1))
+#define FETCH16RAM(A) (*(unsigned short *)((A)&0XFFFF))
+#define FETCH32RAM(A) (((*(unsigned int *)((A)&0XFFFF)) << 16) | ((*(unsigned int *)((A)&0XFFFF)) >> 16))
+
+#define WRITE8RAM(A, V) ((*(unsigned char *)(((A)&0XFFFF) ^ 1)) = (V))
+#define WRITE16RAM(A, V) ((*(unsigned short *)( (A)&0XFFFF)) = (V))
+#define WRITE32RAM(A, V) ((*(unsigned int *)( (A)&0XFFFF)) = (((V) << 16) | ((V) >> 16)))
+#else
+
+/* (the words swapped as gwenesis keeps them; a long word is two words, maybe in two pages) */
+#define MD_RAM16(A) (*(unsigned short *)&md_ram[((A) >> 12) & 15][(A) & 0xFFE])
+#define FETCH8RAM(A) (md_ram[((A) >> 12) & 15][((A) ^ 1) & 0xFFF])
+#define FETCH16RAM(A) (MD_RAM16(A))
+#define FETCH32RAM(A) (((unsigned int)MD_RAM16(A) << 16) | MD_RAM16((A) + 2))
+
+#define WRITE8RAM(A, V) (md_ram[((A) >> 12) & 15][((A) ^ 1) & 0xFFF] = (V))
+#define WRITE16RAM(A, V) (MD_RAM16(A) = (unsigned short)(V))
+#define WRITE32RAM(A, V) (MD_RAM16(A) = (unsigned short)((V) >> 16), MD_RAM16((A) + 2) = (unsigned short)(V))
+
+#endif
+
+#define m68k_read_immediate_16(A) ( ( (A) & 0x800000) ? FETCH16RAM((A)) : FETCH16ROM((A)) )
+#define m68k_read_immediate_32(A) ( ( (A) & 0x800000) ? FETCH32RAM((A)) : FETCH32ROM((A)) )
+
+#define m68k_read_pcrelative_8(A) ( FETCH8ROM((A)) )
+#define m68k_read_pcrelative_16(A) ( FETCH16ROM((A)) )
+#define m68k_read_pcrelative_32(A) ( FETCH32ROM((A)) )
+
+/* Read from anywhere */
+unsigned int m68k_read_memory_8(unsigned int address);
+unsigned int m68k_read_memory_16(unsigned int address);
+unsigned int m68k_read_memory_32(unsigned int address);
+
+/* Read data immediately following the PC */
+// unsigned int m68k_read_immediate_16(unsigned int address);
+// unsigned int m68k_read_immediate_32(unsigned int address);
+
+/* Read data relative to the PC */
+//unsigned int m68k_read_pcrelative_8(unsigned int address);
+//unsigned int m68k_read_pcrelative_16(unsigned int address);
+//unsigned int m68k_read_pcrelative_32(unsigned int address);
+
+/* Memory access for the disassembler */
+unsigned int m68k_read_disassembler_8 (unsigned int address);
+unsigned int m68k_read_disassembler_16 (unsigned int address);
+unsigned int m68k_read_disassembler_32 (unsigned int address);
+
+/* Write to anywhere */
+void m68k_write_memory_8(unsigned int address, unsigned int value);
+void m68k_write_memory_16(unsigned int address, unsigned int value);
+void m68k_write_memory_32(unsigned int address, unsigned int value);
+
+/*** BZHXX ***/
+/* ======================================================================== */
+
+/* There are 7 levels of interrupt to the 68K.
+ * A transition from < 7 to 7 will cause a non-maskable interrupt (NMI).
+ */
+#define M68K_IRQ_NONE 0
+#define M68K_IRQ_1 1
+#define M68K_IRQ_2 2
+#define M68K_IRQ_3 3
+#define M68K_IRQ_4 4
+#define M68K_IRQ_5 5
+#define M68K_IRQ_6 6
+#define M68K_IRQ_7 7
+
+
+/* Special interrupt acknowledge values.
+ * Use these as special returns from the interrupt acknowledge callback
+ * (specified later in this header).
+ */
+
+/* Causes an interrupt autovector (0x18 + interrupt level) to be taken.
+ * This happens in a real 68K if VPA or AVEC is asserted during an interrupt
+ * acknowledge cycle instead of DTACK.
+ */
+#define M68K_INT_ACK_AUTOVECTOR 0xffffffff
+
+/* Causes the spurious interrupt vector (0x18) to be taken
+ * This happens in a real 68K if BERR is asserted during the interrupt
+ * acknowledge cycle (i.e. no devices responded to the acknowledge).
+ */
+#define M68K_INT_ACK_SPURIOUS 0xfffffffe
+
+
+/* Registers used by m68k_get_reg() and m68k_set_reg() */
+typedef enum
+{
+ /* Real registers */
+ M68K_REG_D0, /* Data registers */
+ M68K_REG_D1,
+ M68K_REG_D2,
+ M68K_REG_D3,
+ M68K_REG_D4,
+ M68K_REG_D5,
+ M68K_REG_D6,
+ M68K_REG_D7,
+ M68K_REG_A0, /* Address registers */
+ M68K_REG_A1,
+ M68K_REG_A2,
+ M68K_REG_A3,
+ M68K_REG_A4,
+ M68K_REG_A5,
+ M68K_REG_A6,
+ M68K_REG_A7,
+ M68K_REG_PC, /* Program Counter */
+ M68K_REG_SR, /* Status Register */
+ M68K_REG_SP, /* The current Stack Pointer (located in A7) */
+ M68K_REG_USP, /* User Stack Pointer */
+ M68K_REG_ISP, /* Interrupt Stack Pointer */
+
+#if M68K_EMULATE_PREFETCH
+ /* Assumed registers */
+ /* These are cheat registers which emulate the 1-longword prefetch
+ * present in the 68000 and 68010.
+ */
+ M68K_REG_PREF_ADDR, /* Last prefetch address */
+ M68K_REG_PREF_DATA, /* Last prefetch data */
+#endif
+
+ /* Convenience registers */
+ M68K_REG_IR /* Instruction register */
+} m68k_register_t;
+
+
+/* 68k memory map structure */
+typedef struct
+{
+ unsigned char *base; /* memory-based access (ROM, RAM) */
+ unsigned int (*read8)(unsigned int address); /* I/O byte read access */
+ unsigned int (*read16)(unsigned int address); /* I/O word read access */
+ void (*write8)(unsigned int address, unsigned int data); /* I/O byte write access */
+ void (*write16)(unsigned int address, unsigned int data); /* I/O word write access */
+} cpu_memory_map;
+
+/* 68k idle loop detection */
+typedef struct
+{
+ uint pc;
+ uint cycle;
+ uint detected;
+} cpu_idle_t;
+
+typedef struct
+{
+ cpu_memory_map memory_map[256]; /* memory mapping */
+
+ cpu_idle_t poll; /* polling detection */
+
+ uint cycles; /* current master cycle count */
+ uint cycle_end; /* aimed master cycle count for current execution frame */
+
+ uint dar[16]; /* Data and Address Registers */
+ uint pc; /* Program Counter */
+ uint sp[5]; /* User and Interrupt Stack Pointers */
+ uint ir; /* Instruction Register */
+ uint t1_flag; /* Trace 1 */
+ uint s_flag; /* Supervisor */
+ uint x_flag; /* Extend */
+ uint n_flag; /* Negative */
+ uint not_z_flag; /* Zero, inverted for speedups */
+ uint v_flag; /* Overflow */
+ uint c_flag; /* Carry */
+ uint int_mask; /* I0-I2 */
+ uint int_level; /* State of interrupt pins IPL0-IPL2 -- ASG: changed from ints_pending */
+ uint stopped; /* Stopped state */
+
+ uint pref_addr; /* Last prefetch address */
+ uint pref_data; /* Data in the prefetch queue */
+
+ uint instr_mode; /* Stores whether we are in instruction mode or group 0/1 exception mode */
+ uint run_mode; /* Stores whether we are processing a reset, bus error, address error, or something else */
+ uint aerr_enabled; /* Enables/deisables address error checks at runtime */
+ jmp_buf aerr_trap; /* Address error jump */
+ uint aerr_address; /* Address error location */
+ uint aerr_write_mode; /* Address error write mode */
+ uint aerr_fc; /* Address error FC code */
+
+ uint tracing; /* Tracing enable flag */
+
+ uint address_space; /* Current FC code */
+
+#ifdef M68K_OVERCLOCK_SHIFT
+ int cycle_ratio;
+#endif
+
+ /* Callbacks to host */
+ int (*int_ack_callback)(int int_line); /* Interrupt Acknowledge */
+ void (*reset_instr_callback)(void); /* Called when a RESET instruction is encountered */
+ int (*tas_instr_callback)(void); /* Called when a TAS instruction is encountered, allows / disallows writeback */
+ void (*set_fc_callback)(unsigned int new_fc); /* Called when the CPU function code changes */
+} m68ki_cpu_core;
+
+/* CPU cores */
+extern m68ki_cpu_core m68k;
+
+/* ======================================================================== */
+/* ============================== CALLBACKS =============================== */
+/* ======================================================================== */
+
+/* These functions allow you to set callbacks to the host when specific events
+ * occur. Note that you must enable the corresponding value in m68kconf.h
+ * in order for these to do anything useful.
+ * Note: I have defined default callbacks which are used if you have enabled
+ * the corresponding #define in m68kconf.h but either haven't assigned a
+ * callback or have assigned a callback of NULL.
+ */
+
+#if M68K_EMULATE_INT_ACK == OPT_ON
+/* Set the callback for an interrupt acknowledge.
+ * You must enable M68K_EMULATE_INT_ACK in m68kconf.h.
+ * The CPU will call the callback with the interrupt level being acknowledged.
+ * The host program must return either a vector from 0x02-0xff, or one of the
+ * special interrupt acknowledge values specified earlier in this header.
+ * If this is not implemented, the CPU will always assume an autovectored
+ * interrupt, and will automatically clear the interrupt request when it
+ * services the interrupt.
+ * Default behavior: return M68K_INT_ACK_AUTOVECTOR.
+ */
+void m68k_set_int_ack_callback(int (*callback)(int int_level));
+#endif
+
+#if M68K_EMULATE_RESET == OPT_ON
+/* Set the callback for the RESET instruction.
+ * You must enable M68K_EMULATE_RESET in m68kconf.h.
+ * The CPU calls this callback every time it encounters a RESET instruction.
+ * Default behavior: do nothing.
+ */
+void m68k_set_reset_instr_callback(void (*callback)(void));
+#endif
+
+#if M68K_TAS_HAS_CALLBACK == OPT_ON
+/* Set the callback for the TAS instruction.
+ * You must enable M68K_TAS_HAS_CALLBACK in m68kconf.h.
+ * The CPU calls this callback every time it encounters a TAS instruction.
+ * Default behavior: return 1, allow writeback.
+ */
+void m68k_set_tas_instr_callback(int (*callback)(void));
+#endif
+
+#if M68K_EMULATE_FC == OPT_ON
+/* Set the callback for CPU function code changes.
+ * You must enable M68K_EMULATE_FC in m68kconf.h.
+ * The CPU calls this callback with the function code before every memory
+ * access to set the CPU's function code according to what kind of memory
+ * access it is (supervisor/user, program/data and such).
+ * Default behavior: do nothing.
+ */
+void m68k_set_fc_callback(void (*callback)(unsigned int new_fc));
+#endif
+
+
+/* ======================================================================== */
+/* ====================== FUNCTIONS TO ACCESS THE CPU ===================== */
+/* ======================================================================== */
+
+/* Do whatever initialisations the core requires. Should be called
+ * at least once at init time.
+ */
+extern void m68k_init(void);
+
+/* Pulse the RESET pin on the CPU.
+ * You *MUST* reset the CPU at least once to initialize the emulation
+ */
+extern void m68k_pulse_reset(void);
+
+/* Run until given cycle count is reached */
+extern void m68k_run(unsigned int cycles);
+
+/* Get current instruction execution time */
+extern int m68k_cycles(void);
+
+/* Number of cycles run so far from start of frame */
+extern int m68k_cycles_master(void);
+
+/* Number of cycles run so far from run call */
+extern int m68k_cycles_run(void);
+
+/* Set the IPL0-IPL2 pins on the CPU (IRQ).
+ * A transition from < 7 to 7 will cause a non-maskable interrupt (NMI).
+ * Setting IRQ to 0 will clear an interrupt request.
+ */
+extern void m68k_set_irq(unsigned int int_level);
+extern void m68k_set_irq_delay(unsigned int int_level);
+extern void m68k_update_irq(unsigned int mask);
+
+/* Halt the CPU as if you pulsed the HALT pin. */
+extern void m68k_pulse_halt(void);
+extern void m68k_clear_halt(void);
+
+/* Peek at the internals of a CPU context. This can either be a context
+ * retrieved using m68k_get_context() or the currently running context.
+ * If context is NULL, the currently running CPU context will be used.
+ */
+extern unsigned int m68k_get_reg(m68k_register_t reg);
+
+/* Poke values into the internals of the currently running CPU context */
+extern void m68k_set_reg(m68k_register_t reg, unsigned int value);
+
+/* Load/Save state of CPU */
+extern void gwenesis_m68k_save_state();
+extern void gwenesis_m68k_load_state();
+
+/* ======================================================================== */
+/* ============================== END OF FILE ============================= */
+/* ======================================================================== */
+
+#endif /* M68K__HEADER */
diff --git a/games/retrogo/src/md/m68kconf.h b/games/retrogo/src/md/m68kconf.h
new file mode 100644
index 00000000..bec6d017
--- /dev/null
+++ b/games/retrogo/src/md/m68kconf.h
@@ -0,0 +1,93 @@
+#ifndef M68KCONF__HEADER
+#define M68KCONF__HEADER
+
+/* ======================================================================== */
+/* ======================== MAIN 68K CONFIGURATION ======================== */
+/* ======================================================================== */
+
+/* Configuration switches.
+ * Use OPT_SPECIFY_HANDLER for configuration options that allow callbacks.
+ * OPT_SPECIFY_HANDLER causes the core to link directly to the function
+ * or macro you specify, rather than using callback functions whose pointer
+ * must be passed in using m68k_set_xxx_callback().
+ */
+#define OPT_OFF 0
+#define OPT_ON 1
+#define OPT_SPECIFY_HANDLER 2
+
+/* If ON, the CPU will call m68k_write_32_pd() when it executes move.l with a
+ * predecrement destination EA mode instead of m68k_write_32().
+ * To simulate real 68k behavior, m68k_write_32_pd() must first write the high
+ * word to [address+2], and then write the low word to [address].
+ */
+#define M68K_SIMULATE_PD_WRITES OPT_OFF
+
+/* If ON, CPU will call the interrupt acknowledge callback when it services an
+ * interrupt.
+ * If off, all interrupts will be autovectored and all interrupt requests will
+ * auto-clear when the interrupt is serviced.
+ */
+#define M68K_EMULATE_INT_ACK OPT_ON //OPT_SPECIFY_HANDLER
+#define M68K_INT_ACK_CALLBACK(A) your_int_ack_handler_function(A)
+
+/* If ON, CPU will call the output reset callback when it encounters a reset
+ * instruction.
+ */
+#define M68K_EMULATE_RESET OPT_OFF
+#define M68K_RESET_CALLBACK() your_reset_handler_function()
+
+/* If ON, CPU will call the callback when it encounters a tas
+ * instruction.
+ */
+#define M68K_TAS_HAS_CALLBACK OPT_OFF
+#define M68K_TAS_CALLBACK() your_tas_handler_function()
+
+/* If ON, CPU will call the set fc callback on every memory access to
+ * differentiate between user/supervisor, program/data access like a real
+ * 68000 would. This should be enabled and the callback should be set if you
+ * want to properly emulate the m68010 or higher. (moves uses function codes
+ * to read/write data from different address spaces)
+ */
+#define M68K_EMULATE_FC OPT_OFF
+#define M68K_SET_FC_CALLBACK(A) your_set_fc_handler_function(A)
+
+/* If ON, the CPU will monitor the trace flags and take trace exceptions
+ */
+#define M68K_EMULATE_TRACE OPT_OFF
+
+/* If ON, the CPU will emulate the 4-byte prefetch queue of a real 68000 */
+#define M68K_EMULATE_PREFETCH OPT_OFF
+
+/* If ON, the CPU will generate address error exceptions if it tries to
+ * access a word or longword at an odd address.
+ * NOTE: This is only emulated properly for 68000 mode.
+ */
+#define M68K_EMULATE_ADDRESS_ERROR OPT_ON
+
+/* If ON and previous option is also ON, address error exceptions will
+ also be checked when fetching instructions. Disabling this can help
+ speeding up emulation while still emulating address error exceptions
+ on other memory access if needed.
+ * NOTE: This is only emulated properly for 68000 mode.
+ */
+#define M68K_CHECK_PC_ADDRESS_ERROR OPT_OFF
+
+
+/* ----------------------------- COMPATIBILITY ---------------------------- */
+
+/* The following options set optimizations that violate the current ANSI
+ * standard, but will be compliant under the forthcoming C9X standard.
+ */
+
+
+/* If ON, the enulation core will use 64-bit integers to speed up some
+ * operations.
+*/
+#define M68K_USE_64_BIT OPT_OFF
+
+
+/* ======================================================================== */
+/* ============================== END OF FILE ============================= */
+/* ======================================================================== */
+
+#endif /* M68KCONF__HEADER */
diff --git a/games/retrogo/src/md/m68kcpu.c b/games/retrogo/src/md/m68kcpu.c
new file mode 100644
index 00000000..3079d321
--- /dev/null
+++ b/games/retrogo/src/md/m68kcpu.c
@@ -0,0 +1,462 @@
+/* ======================================================================== */
+/* MAIN 68K CORE */
+/* ======================================================================== */
+
+extern int vdp_68k_irq_ack(int int_level);
+
+#define m68ki_cpu m68k
+#define MUL (7)
+
+/* ======================================================================== */
+/* ================================ INCLUDES ============================== */
+/* ======================================================================== */
+
+/* (NumPlay: the opcode table made at build time by tools/m68ktab.py, a 16-bit number for each
+ opcode instead of a pointer, the same handlers and cycles as gwenesis' own table) */
+#include "m68k_tab.h"
+
+#include "m68kconf.h"
+#include "m68kcpu.h"
+#include "m68kops.h"
+#include "gwenesis_savestate.h"
+
+/* (NumPlay: no sound, the calculator has no speaker: the YM2612 reads as ready and the sound
+ chips' writes go nowhere; and nothing printed) */
+#define YM2612Read(clk) 0
+#define YM2612Write(a, v, clk) ((void)0)
+#define YM2612Init() ((void)0)
+#define YM2612Config(x) ((void)0)
+#define YM2612ResetChip() ((void)0)
+#define gwenesis_SN76489_Write(v, clk) ((void)0)
+#define gwenesis_SN76489_Init(a, b, c) ((void)0)
+#define gwenesis_SN76489_Reset() ((void)0)
+#define printf(...) ((void)0)
+#define vfprintf(...) ((void)0)
+
+/* ======================================================================== */
+/* ================================= DATA ================================= */
+/* ======================================================================== */
+
+
+static int irq_latency;
+
+m68ki_cpu_core m68k;
+
+
+/* ======================================================================== */
+/* =============================== CALLBACKS ============================== */
+/* ======================================================================== */
+
+/* Default callbacks used if the callback hasn't been set yet, or if the
+ * callback is set to NULL
+ */
+
+#if M68K_EMULATE_INT_ACK == OPT_ON
+/* Interrupt acknowledge */
+static int default_int_ack_callback(int int_level)
+{
+ CPU_INT_LEVEL = 0;
+ return M68K_INT_ACK_AUTOVECTOR;
+}
+#endif
+
+#if M68K_EMULATE_RESET == OPT_ON
+/* Called when a reset instruction is executed */
+static void default_reset_instr_callback(void)
+{
+}
+#endif
+
+#if M68K_TAS_HAS_CALLBACK == OPT_ON
+/* Called when a tas instruction is executed */
+static int default_tas_instr_callback(void)
+{
+ return 1; // allow writeback
+}
+#endif
+
+#if M68K_EMULATE_FC == OPT_ON
+/* Called every time there's bus activity (read/write to/from memory */
+static void default_set_fc_callback(unsigned int new_fc)
+{
+}
+#endif
+
+
+/* ======================================================================== */
+/* ================================= API ================================== */
+/* ======================================================================== */
+
+/* Access the internals of the CPU */
+unsigned int m68k_get_reg(m68k_register_t regnum)
+{
+ switch(regnum)
+ {
+ case M68K_REG_D0: return m68ki_cpu.dar[0];
+ case M68K_REG_D1: return m68ki_cpu.dar[1];
+ case M68K_REG_D2: return m68ki_cpu.dar[2];
+ case M68K_REG_D3: return m68ki_cpu.dar[3];
+ case M68K_REG_D4: return m68ki_cpu.dar[4];
+ case M68K_REG_D5: return m68ki_cpu.dar[5];
+ case M68K_REG_D6: return m68ki_cpu.dar[6];
+ case M68K_REG_D7: return m68ki_cpu.dar[7];
+ case M68K_REG_A0: return m68ki_cpu.dar[8];
+ case M68K_REG_A1: return m68ki_cpu.dar[9];
+ case M68K_REG_A2: return m68ki_cpu.dar[10];
+ case M68K_REG_A3: return m68ki_cpu.dar[11];
+ case M68K_REG_A4: return m68ki_cpu.dar[12];
+ case M68K_REG_A5: return m68ki_cpu.dar[13];
+ case M68K_REG_A6: return m68ki_cpu.dar[14];
+ case M68K_REG_A7: return m68ki_cpu.dar[15];
+ case M68K_REG_PC: return MASK_OUT_ABOVE_32(m68ki_cpu.pc);
+ case M68K_REG_SR: return m68ki_cpu.t1_flag |
+ (m68ki_cpu.s_flag << 11) |
+ m68ki_cpu.int_mask |
+ ((m68ki_cpu.x_flag & XFLAG_SET) >> 4) |
+ ((m68ki_cpu.n_flag & NFLAG_SET) >> 4) |
+ ((!m68ki_cpu.not_z_flag) << 2) |
+ ((m68ki_cpu.v_flag & VFLAG_SET) >> 6) |
+ ((m68ki_cpu.c_flag & CFLAG_SET) >> 8);
+ case M68K_REG_SP: return m68ki_cpu.dar[15];
+ case M68K_REG_USP: return m68ki_cpu.s_flag ? m68ki_cpu.sp[0] : m68ki_cpu.dar[15];
+ case M68K_REG_ISP: return m68ki_cpu.s_flag ? m68ki_cpu.dar[15] : m68ki_cpu.sp[4];
+#if M68K_EMULATE_PREFETCH
+ case M68K_REG_PREF_ADDR: return m68ki_cpu.pref_addr;
+ case M68K_REG_PREF_DATA: return m68ki_cpu.pref_data;
+#endif
+ case M68K_REG_IR: return m68ki_cpu.ir;
+ default: return 0;
+ }
+}
+
+void m68k_set_reg(m68k_register_t regnum, unsigned int value)
+{
+ switch(regnum)
+ {
+ case M68K_REG_D0: REG_D[0] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_D1: REG_D[1] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_D2: REG_D[2] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_D3: REG_D[3] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_D4: REG_D[4] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_D5: REG_D[5] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_D6: REG_D[6] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_D7: REG_D[7] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_A0: REG_A[0] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_A1: REG_A[1] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_A2: REG_A[2] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_A3: REG_A[3] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_A4: REG_A[4] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_A5: REG_A[5] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_A6: REG_A[6] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_A7: REG_A[7] = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_PC: m68ki_jump(MASK_OUT_ABOVE_32(value)); return;
+ case M68K_REG_SR: m68ki_set_sr(value); return;
+ case M68K_REG_SP: REG_SP = MASK_OUT_ABOVE_32(value); return;
+ case M68K_REG_USP: if(FLAG_S)
+ REG_USP = MASK_OUT_ABOVE_32(value);
+ else
+ REG_SP = MASK_OUT_ABOVE_32(value);
+ return;
+ case M68K_REG_ISP: if(FLAG_S)
+ REG_SP = MASK_OUT_ABOVE_32(value);
+ else
+ REG_ISP = MASK_OUT_ABOVE_32(value);
+ return;
+ case M68K_REG_IR: REG_IR = MASK_OUT_ABOVE_16(value); return;
+#if M68K_EMULATE_PREFETCH
+ case M68K_REG_PREF_ADDR: CPU_PREF_ADDR = MASK_OUT_ABOVE_32(value); return;
+#endif
+ default: return;
+ }
+}
+
+/* Set the callbacks */
+#if M68K_EMULATE_INT_ACK == OPT_ON
+void m68k_set_int_ack_callback(int (*callback)(int int_level))
+{
+ CALLBACK_INT_ACK = callback ? callback : default_int_ack_callback;
+}
+#endif
+
+#if M68K_EMULATE_RESET == OPT_ON
+void m68k_set_reset_instr_callback(void (*callback)(void))
+{
+ CALLBACK_RESET_INSTR = callback ? callback : default_reset_instr_callback;
+}
+#endif
+
+#if M68K_TAS_HAS_CALLBACK == OPT_ON
+void m68k_set_tas_instr_callback(int (*callback)(void))
+{
+ CALLBACK_TAS_INSTR = callback ? callback : default_tas_instr_callback;
+}
+#endif
+
+#if M68K_EMULATE_FC == OPT_ON
+void m68k_set_fc_callback(void (*callback)(unsigned int new_fc))
+{
+ CALLBACK_SET_FC = callback ? callback : default_set_fc_callback;
+}
+#endif
+
+#ifdef LOGERROR
+
+extern void error(char *format, ...);
+extern uint16 v_counter;
+#endif
+
+/* ASG: rewrote so that the int_level is a mask of the IPL0/IPL1/IPL2 bits */
+/* KS: Modified so that IPL* bits match with mask positions in the SR
+ * and cleaned out remenants of the interrupt controller.
+ */
+void m68k_update_irq(unsigned int mask)
+{
+ /* Update IRQ level */
+ CPU_INT_LEVEL |= (mask << 8);
+
+#ifdef LOGERROR
+ error("[%d(%d)][%d(%d)] m68k IRQ Level = %d(0x%02x) (%x)\n", v_counter, m68k.cycles/3420, m68k.cycles, m68k.cycles%3420,CPU_INT_LEVEL>>8,FLAG_INT_MASK,m68k_get_reg(M68K_REG_PC));
+#endif
+}
+
+void m68k_set_irq(unsigned int int_level)
+{
+ /* Set IRQ level */
+ CPU_INT_LEVEL = int_level << 8;
+
+#ifdef LOGERROR
+ error("[%d(%d)][%d(%d)] m68k IRQ Level = %d(0x%02x) (%x)\n", v_counter, m68k.cycles/3420, m68k.cycles, m68k.cycles%3420,CPU_INT_LEVEL>>8,FLAG_INT_MASK,m68k_get_reg(M68K_REG_PC));
+#endif
+}
+
+/* IRQ latency (Fatal Rewind, Sesame's Street Counting Cafe)*/
+void m68k_set_irq_delay(unsigned int int_level)
+{
+ /* Prevent reentrance */
+ if (!irq_latency)
+ {
+ /* This is always triggered from MOVE instructions (VDP CTRL port write) */
+ /* We just make sure this is not a MOVE.L instruction as we could be in */
+ /* the middle of its execution (first memory write). */
+ if ((REG_IR & 0xF000) != 0x2000)
+ {
+ /* Finish executing current instruction */
+ USE_CYCLES(CYC_INSTRUCTION(REG_IR));
+
+ /* One instruction delay before interrupt */
+ irq_latency = 1;
+ m68ki_trace_t1() /* auto-disable (see m68kcpu.h) */
+ m68ki_use_data_space() /* auto-disable (see m68kcpu.h) */
+ REG_IR = m68ki_read_imm_16();
+ m68ki_pair_handler[m68ki_opcode_pair[REG_IR]]();
+ m68ki_exception_if_trace() /* auto-disable (see m68kcpu.h) */
+ irq_latency = 0;
+ }
+
+ /* Set IRQ level */
+ CPU_INT_LEVEL = int_level << 8;
+ }
+
+#ifdef LOGERROR
+ error("[%d(%d)][%d(%d)] m68k IRQ Level = %d(0x%02x) (%x)\n", v_counter, m68k.cycles/3420, m68k.cycles, m68k.cycles%3420,CPU_INT_LEVEL>>8,FLAG_INT_MASK,m68k_get_reg(M68K_REG_PC));
+#endif
+
+ /* Check interrupt mask to process IRQ */
+ m68ki_check_interrupts(); /* Level triggered (IRQ) */
+}
+
+void m68k_run(unsigned int cycles)
+{
+ // printf("m68K_run current_cycles=%d add=%d STOP=%x\n",m68k.cycles,cycles,CPU_STOPPED);
+
+ /* Make sure CPU is not already ahead */
+ if (m68k.cycles >= cycles)
+ {
+ return;
+ }
+
+ /* Check interrupt mask to process IRQ if needed */
+ m68ki_check_interrupts();
+
+ /* Make sure we're not stopped */
+ if (CPU_STOPPED)
+ {
+ m68k.cycles = cycles;
+ return;
+ }
+
+ /* Save end cycles count for when CPU is stopped */
+ m68k.cycle_end = cycles;
+
+ /* Return point for when we have an address error (TODO: use goto) */
+ m68ki_set_address_error_trap() /* auto-disable (see m68kcpu.h) */
+
+#ifdef LOGERROR
+ error("[%d][%d] m68k run to %d cycles (%x), irq mask = %x (%x)\n", v_counter, m68k.cycles, cycles, m68k.pc,FLAG_INT_MASK, CPU_INT_LEVEL);
+#endif
+
+ while (m68k.cycles < cycles)
+ {
+ /* Set tracing accodring to T1. */
+ m68ki_trace_t1() /* auto-disable (see m68kcpu.h) */
+
+ /* Set the address space for reads */
+ m68ki_use_data_space() /* auto-disable (see m68kcpu.h) */
+
+#ifdef HOOK_CPU
+ /* Trigger execution hook */
+ if (cpu_hook)
+ cpu_hook(HOOK_M68K_E, 0, REG_PC, 0);
+#endif
+
+ /* Decode next instruction */
+ REG_IR = m68ki_read_imm_16();
+
+// printf("PC=%x IR=%x CYCLES=%d \n",m68k.pc,REG_IR,CYC_INSTRUCTION(REG_IR));
+
+ /* Execute instruction */
+ m68ki_pair_handler[m68ki_opcode_pair[REG_IR]]();
+ USE_CYCLES(CYC_INSTRUCTION(REG_IR));
+
+ /* Trace m68k_exception, if necessary */
+ m68ki_exception_if_trace(); /* auto-disable (see m68kcpu.h) */
+ }
+}
+
+int m68k_cycles(void)
+{
+ return CYC_INSTRUCTION(REG_IR);
+}
+
+int m68k_cycles_run(void)
+{
+ return m68k.cycle_end - m68k.cycles;
+}
+
+int m68k_cycles_master(void)
+{
+ return m68k.cycles;
+}
+
+void m68k_init(void)
+{
+#ifdef BUILD_TABLES
+ static uint emulation_initialized = 0;
+
+ /* The first call to this function initializes the opcode handler jump table */
+ if(!emulation_initialized)
+ {
+ m68ki_build_opcode_table();
+ emulation_initialized = 1;
+ }
+#endif
+
+#ifdef M68K_OVERCLOCK_SHIFT
+ m68k.cycle_ratio = 1 << M68K_OVERCLOCK_SHIFT;
+#endif
+
+#if M68K_EMULATE_INT_ACK == OPT_ON
+ m68k_set_int_ack_callback(NULL);
+#endif
+#if M68K_EMULATE_RESET == OPT_ON
+ m68k_set_reset_instr_callback(NULL);
+#endif
+#if M68K_TAS_HAS_CALLBACK == OPT_ON
+ m68k_set_tas_instr_callback(NULL);
+#endif
+#if M68K_EMULATE_FC == OPT_ON
+ m68k_set_fc_callback(NULL);
+#endif
+}
+
+/* Pulse the RESET line on the CPU */
+void m68k_pulse_reset(void)
+{
+ /* Clear all stop levels */
+ CPU_STOPPED = 0;
+#if M68K_EMULATE_ADDRESS_ERROR
+ CPU_RUN_MODE = RUN_MODE_BERR_AERR_RESET;
+#endif
+
+ /* Turn off tracing */
+ FLAG_T1 = 0;
+ m68ki_clear_trace()
+
+ /* Interrupt mask to level 7 */
+ FLAG_INT_MASK = 0x0700;
+ CPU_INT_LEVEL = 0;
+ irq_latency = 0;
+
+ /* Go to supervisor mode */
+ m68ki_set_s_flag(SFLAG_SET);
+
+ /* Invalidate the prefetch queue */
+#if M68K_EMULATE_PREFETCH
+ /* Set to arbitrary number since our first fetch is from 0 */
+ CPU_PREF_ADDR = 0x1000;
+#endif /* M68K_EMULATE_PREFETCH */
+
+ /* Read the initial stack pointer and program counter */
+ m68ki_jump(0);
+ REG_SP = m68ki_read_imm_32();
+ REG_PC = m68ki_read_imm_32();
+ m68ki_jump(REG_PC);
+
+#if M68K_EMULATE_ADDRESS_ERROR
+ CPU_RUN_MODE = RUN_MODE_NORMAL;
+#endif
+
+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_RESET]);
+}
+
+void m68k_pulse_halt(void)
+{
+ /* Pulse the HALT line on the CPU */
+ CPU_STOPPED |= STOP_LEVEL_HALT;
+}
+
+void m68k_clear_halt(void)
+{
+ /* Clear the HALT line on the CPU */
+ CPU_STOPPED &= ~STOP_LEVEL_HALT;
+}
+
+void gwenesis_m68k_save_state() {
+ SaveState *state;
+ state = saveGwenesisStateOpenForWrite("m68k");
+
+ saveGwenesisStateSetBuffer(state, "REG_D", REG_D, sizeof(REG_D));
+ saveGwenesisStateSet(state, "SR", m68ki_get_sr());
+ saveGwenesisStateSet(state, "REG_PC", REG_PC);
+ saveGwenesisStateSet(state, "REG_SP", REG_SP);
+ saveGwenesisStateSet(state, "REG_USP", REG_USP);
+ saveGwenesisStateSet(state, "REG_ISP", REG_ISP);
+ saveGwenesisStateSet(state, "REG_IR", REG_IR);
+
+ saveGwenesisStateSet(state, "m68k_cycle_end", m68k.cycle_end);
+ saveGwenesisStateSet(state, "m68k_cycles", m68k.cycles);
+ saveGwenesisStateSet(state, "m68k_int_level", m68k.int_level);
+ saveGwenesisStateSet(state, "m68k_stopped", m68k.stopped);
+}
+
+void gwenesis_m68k_load_state() {
+ SaveState *state = saveGwenesisStateOpenForRead("m68k");
+ saveGwenesisStateGetBuffer(state, "REG_D", REG_D, sizeof(REG_D));
+
+ m68ki_set_sr(saveGwenesisStateGet(state, "SR"));
+ REG_PC = saveGwenesisStateGet(state, "REG_PC");
+ REG_SP = saveGwenesisStateGet(state, "REG_SP");
+ REG_USP = saveGwenesisStateGet(state, "REG_USP");
+ REG_ISP = saveGwenesisStateGet(state, "REG_ISP");
+ REG_IR = saveGwenesisStateGet(state, "REG_IR");
+
+ m68k.cycle_end = saveGwenesisStateGet(state, "m68k_cycle_end");
+ m68k.cycles = saveGwenesisStateGet(state, "m68k_cycles");
+ m68k.int_level = saveGwenesisStateGet(state, "m68k_int_level");
+ m68k.stopped = saveGwenesisStateGet(state, "m68k_stopped");
+
+}
+
+/* ======================================================================== */
+/* ============================== END OF FILE ============================= */
+/* ======================================================================== */
diff --git a/games/retrogo/src/md/m68kcpu.h b/games/retrogo/src/md/m68kcpu.h
new file mode 100644
index 00000000..634e5004
--- /dev/null
+++ b/games/retrogo/src/md/m68kcpu.h
@@ -0,0 +1,1505 @@
+#ifndef M68KCPU__HEADER
+#define M68KCPU__HEADER
+
+/* ======================================================================== */
+/* GENERIC 68K CORE */
+/* ======================================================================== */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+
+#if M68K_EMULATE_ADDRESS_ERROR
+#include <setjmp.h>
+#endif /* M68K_EMULATE_ADDRESS_ERROR */
+
+#include "m68k.h"
+
+/* ======================================================================== */
+/* ============================ GENERAL DEFINES =========================== */
+/* ======================================================================== */
+
+/* Exception Vectors handled by emulation */
+#define EXCEPTION_RESET 0
+#define EXCEPTION_BUS_ERROR 2 /* This one is not emulated! */
+#define EXCEPTION_ADDRESS_ERROR 3 /* This one is partially emulated (doesn't stack a proper frame yet) */
+#define EXCEPTION_ILLEGAL_INSTRUCTION 4
+#define EXCEPTION_ZERO_DIVIDE 5
+#define EXCEPTION_CHK 6
+#define EXCEPTION_TRAPV 7
+#define EXCEPTION_PRIVILEGE_VIOLATION 8
+#define EXCEPTION_TRACE 9
+#define EXCEPTION_1010 10
+#define EXCEPTION_1111 11
+#define EXCEPTION_FORMAT_ERROR 14
+#define EXCEPTION_UNINITIALIZED_INTERRUPT 15
+#define EXCEPTION_SPURIOUS_INTERRUPT 24
+#define EXCEPTION_INTERRUPT_AUTOVECTOR 24
+#define EXCEPTION_TRAP_BASE 32
+
+/* Function codes set by CPU during data/address bus activity */
+#define FUNCTION_CODE_USER_DATA 1
+#define FUNCTION_CODE_USER_PROGRAM 2
+#define FUNCTION_CODE_SUPERVISOR_DATA 5
+#define FUNCTION_CODE_SUPERVISOR_PROGRAM 6
+#define FUNCTION_CODE_CPU_SPACE 7
+
+/* Different ways to stop the CPU */
+#define STOP_LEVEL_STOP 1
+#define STOP_LEVEL_HALT 2
+
+/* Used for 68000 address error processing */
+#if M68K_EMULATE_ADDRESS_ERROR
+#define INSTRUCTION_YES 0
+#define INSTRUCTION_NO 0x08
+#define MODE_READ 0x10
+#define MODE_WRITE 0
+
+#define RUN_MODE_NORMAL 0
+#define RUN_MODE_BERR_AERR_RESET 1
+#endif
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+/* ======================================================================== */
+/* ================================ MACROS ================================ */
+/* ======================================================================== */
+
+
+/* ---------------------------- General Macros ---------------------------- */
+
+/* Bit Isolation Macros */
+#define BIT_0(A) ((A) & 0x00000001)
+#define BIT_1(A) ((A) & 0x00000002)
+#define BIT_2(A) ((A) & 0x00000004)
+#define BIT_3(A) ((A) & 0x00000008)
+#define BIT_4(A) ((A) & 0x00000010)
+#define BIT_5(A) ((A) & 0x00000020)
+#define BIT_6(A) ((A) & 0x00000040)
+#define BIT_7(A) ((A) & 0x00000080)
+#define BIT_8(A) ((A) & 0x00000100)
+#define BIT_9(A) ((A) & 0x00000200)
+#define BIT_A(A) ((A) & 0x00000400)
+#define BIT_B(A) ((A) & 0x00000800)
+#define BIT_C(A) ((A) & 0x00001000)
+#define BIT_D(A) ((A) & 0x00002000)
+#define BIT_E(A) ((A) & 0x00004000)
+#define BIT_F(A) ((A) & 0x00008000)
+#define BIT_10(A) ((A) & 0x00010000)
+#define BIT_11(A) ((A) & 0x00020000)
+#define BIT_12(A) ((A) & 0x00040000)
+#define BIT_13(A) ((A) & 0x00080000)
+#define BIT_14(A) ((A) & 0x00100000)
+#define BIT_15(A) ((A) & 0x00200000)
+#define BIT_16(A) ((A) & 0x00400000)
+#define BIT_17(A) ((A) & 0x00800000)
+#define BIT_18(A) ((A) & 0x01000000)
+#define BIT_19(A) ((A) & 0x02000000)
+#define BIT_1A(A) ((A) & 0x04000000)
+#define BIT_1B(A) ((A) & 0x08000000)
+#define BIT_1C(A) ((A) & 0x10000000)
+#define BIT_1D(A) ((A) & 0x20000000)
+#define BIT_1E(A) ((A) & 0x40000000)
+#define BIT_1F(A) ((A) & 0x80000000)
+
+/* Get the most significant bit for specific sizes */
+#define GET_MSB_8(A) ((A) & 0x80)
+#define GET_MSB_9(A) ((A) & 0x100)
+#define GET_MSB_16(A) ((A) & 0x8000)
+#define GET_MSB_17(A) ((A) & 0x10000)
+#define GET_MSB_32(A) ((A) & 0x80000000)
+#if M68K_USE_64_BIT
+#define GET_MSB_33(A) ((A) & 0x100000000)
+#endif /* M68K_USE_64_BIT */
+
+/* Isolate nibbles */
+#define LOW_NIBBLE(A) ((A) & 0x0f)
+#define HIGH_NIBBLE(A) ((A) & 0xf0)
+
+/* These are used to isolate 8, 16, and 32 bit sizes */
+#define MASK_OUT_ABOVE_2(A) ((A) & 3)
+#define MASK_OUT_ABOVE_8(A) ((A) & 0xff)
+#define MASK_OUT_ABOVE_16(A) ((A) & 0xffff)
+#define MASK_OUT_BELOW_2(A) ((A) & ~3)
+#define MASK_OUT_BELOW_8(A) ((A) & ~0xff)
+#define MASK_OUT_BELOW_16(A) ((A) & ~0xffff)
+
+/* No need to mask if we are 32 bit */
+#if M68K_INT_GT_32_BIT || M68K_USE_64_BIT
+ #define MASK_OUT_ABOVE_32(A) ((A) & 0xffffffff)
+ #define MASK_OUT_BELOW_32(A) ((A) & ~0xffffffff)
+#else
+ #define MASK_OUT_ABOVE_32(A) (A)
+ #define MASK_OUT_BELOW_32(A) 0
+#endif /* M68K_INT_GT_32_BIT || M68K_USE_64_BIT */
+
+/* Simulate address lines of 68k family */
+#define ADDRESS_68K(A) ((A)&CPU_ADDRESS_MASK)
+
+
+/* Shift & Rotate Macros. */
+#define LSL(A, C) ((A) << (C))
+#define LSR(A, C) ((A) >> (C))
+
+/* Some > 32-bit optimizations */
+#if M68K_INT_GT_32_BIT
+ /* Shift left and right */
+ #define LSR_32(A, C) ((A) >> (C))
+ #define LSL_32(A, C) ((A) << (C))
+#else
+ /* We have to do this because the morons at ANSI decided that shifts
+ * by >= data size are undefined.
+ */
+ #define LSR_32(A, C) ((C) < 32 ? (A) >> (C) : 0)
+ #define LSL_32(A, C) ((C) < 32 ? (A) << (C) : 0)
+#endif /* M68K_INT_GT_32_BIT */
+
+#if M68K_USE_64_BIT
+ #define LSL_32_64(A, C) ((A) << (C))
+ #define LSR_32_64(A, C) ((A) >> (C))
+ #define ROL_33_64(A, C) (LSL_32_64(A, C) | LSR_32_64(A, 33-(C)))
+ #define ROR_33_64(A, C) (LSR_32_64(A, C) | LSL_32_64(A, 33-(C)))
+#endif /* M68K_USE_64_BIT */
+
+#define ROL_8(A, C) MASK_OUT_ABOVE_8(LSL(A, C) | LSR(A, 8-(C)))
+#define ROL_9(A, C) (LSL(A, C) | LSR(A, 9-(C)))
+#define ROL_16(A, C) MASK_OUT_ABOVE_16(LSL(A, C) | LSR(A, 16-(C)))
+#define ROL_17(A, C) (LSL(A, C) | LSR(A, 17-(C)))
+#define ROL_32(A, C) MASK_OUT_ABOVE_32(LSL_32(A, C) | LSR_32(A, 32-(C)))
+#define ROL_33(A, C) (LSL_32(A, C) | LSR_32(A, 33-(C)))
+
+#define ROR_8(A, C) MASK_OUT_ABOVE_8(LSR(A, C) | LSL(A, 8-(C)))
+#define ROR_9(A, C) (LSR(A, C) | LSL(A, 9-(C)))
+#define ROR_16(A, C) MASK_OUT_ABOVE_16(LSR(A, C) | LSL(A, 16-(C)))
+#define ROR_17(A, C) (LSR(A, C) | LSL(A, 17-(C)))
+#define ROR_32(A, C) MASK_OUT_ABOVE_32(LSR_32(A, C) | LSL_32(A, 32-(C)))
+#define ROR_33(A, C) (LSR_32(A, C) | LSL_32(A, 33-(C)))
+
+
+
+/* ------------------------------ CPU Access ------------------------------ */
+
+/* Access the CPU registers */
+#define REG_DA m68ki_cpu.dar /* easy access to data and address regs */
+#define REG_D m68ki_cpu.dar
+#define REG_A (m68ki_cpu.dar+8)
+#define REG_PC m68ki_cpu.pc
+#define REG_SP_BASE m68ki_cpu.sp
+#define REG_USP m68ki_cpu.sp[0]
+#define REG_ISP m68ki_cpu.sp[4]
+#define REG_SP m68ki_cpu.dar[15]
+#define REG_IR m68ki_cpu.ir
+
+#define FLAG_T1 m68ki_cpu.t1_flag
+#define FLAG_S m68ki_cpu.s_flag
+#define FLAG_X m68ki_cpu.x_flag
+#define FLAG_N m68ki_cpu.n_flag
+#define FLAG_Z m68ki_cpu.not_z_flag
+#define FLAG_V m68ki_cpu.v_flag
+#define FLAG_C m68ki_cpu.c_flag
+#define FLAG_INT_MASK m68ki_cpu.int_mask
+
+#define CPU_INT_LEVEL m68ki_cpu.int_level /* ASG: changed from CPU_INTS_PENDING */
+#define CPU_STOPPED m68ki_cpu.stopped
+#if M68K_EMULATE_PREFETCH
+#define CPU_PREF_ADDR m68ki_cpu.pref_addr
+#define CPU_PREF_DATA m68ki_cpu.pref_data
+#endif
+#define CPU_ADDRESS_MASK 0x00ffffff
+#if M68K_EMULATE_ADDRESS_ERROR
+#define CPU_INSTR_MODE m68ki_cpu.instr_mode
+#define CPU_RUN_MODE m68ki_cpu.run_mode
+#endif
+
+#define CYC_INSTRUCTION(ir) (m68ki_pair_cycles[m68ki_opcode_pair[ir]])
+#define CYC_EXCEPTION m68ki_exception_cycle_table
+#define CYC_BCC_NOTAKE_B ( -2 * MUL)
+#define CYC_BCC_NOTAKE_W ( 2 * MUL)
+#define CYC_DBCC_F_NOEXP ( -2 * MUL)
+#define CYC_DBCC_F_EXP ( 2 * MUL)
+#define CYC_SCC_R_TRUE ( 2 * MUL)
+#define CYC_MOVEM_W ( 4 * MUL)
+#define CYC_MOVEM_L ( 8 * MUL)
+#define CYC_SHIFT ( 2 * MUL)
+#define CYC_RESET (132 * MUL)
+
+#if M68K_EMULATE_INT_ACK == OPT_ON
+#define CALLBACK_INT_ACK m68ki_cpu.int_ack_callback
+#endif
+#if M68K_EMULATE_RESET == OPT_ON
+#define CALLBACK_RESET_INSTR m68ki_cpu.reset_instr_callback
+#endif
+#if M68K_TAS_HAS_CALLBACK == OPT_ON
+#define CALLBACK_TAS_INSTR m68ki_cpu.tas_instr_callback
+#endif
+#if M68K_EMULATE_FC == OPT_ON
+#define CALLBACK_SET_FC m68ki_cpu.set_fc_callback
+#endif
+
+
+/* ----------------------------- Configuration ---------------------------- */
+
+/* These defines are dependant on the configuration defines in m68kconf.h */
+
+/* Enable or disable callback functions */
+#if M68K_EMULATE_INT_ACK
+ #if M68K_EMULATE_INT_ACK == OPT_SPECIFY_HANDLER
+ #define m68ki_int_ack(A) M68K_INT_ACK_CALLBACK(A);
+ #else
+ #define m68ki_int_ack(A) CALLBACK_INT_ACK(A);
+ #endif
+#else
+ /* Default action is to used autovector mode, which is most common */
+ #define m68ki_int_ack(A) M68K_INT_ACK_AUTOVECTOR
+#endif /* M68K_EMULATE_INT_ACK */
+
+#if M68K_EMULATE_RESET
+ #if M68K_EMULATE_RESET == OPT_SPECIFY_HANDLER
+ #define m68ki_output_reset() M68K_RESET_CALLBACK();
+ #else
+ #define m68ki_output_reset() CALLBACK_RESET_INSTR();
+ #endif
+#else
+ #define m68ki_output_reset()
+#endif /* M68K_EMULATE_RESET */
+
+#if M68K_TAS_HAS_CALLBACK
+ #if M68K_TAS_HAS_CALLBACK == OPT_SPECIFY_HANDLER
+ #define m68ki_tas_callback() M68K_TAS_CALLBACK()
+ #else
+ #define m68ki_tas_callback() CALLBACK_TAS_INSTR()
+ #endif
+#else
+ #define m68ki_tas_callback() 0
+#endif /* M68K_TAS_HAS_CALLBACK */
+
+
+/* Enable or disable function code emulation */
+#if M68K_EMULATE_FC
+ #if M68K_EMULATE_FC == OPT_SPECIFY_HANDLER
+ #define m68ki_set_fc(A) M68K_SET_FC_CALLBACK(A);
+ #else
+ #define m68ki_set_fc(A) CALLBACK_SET_FC(A);
+ #endif
+ #define m68ki_use_data_space() m68ki_cpu.address_space = FUNCTION_CODE_USER_DATA;
+ #define m68ki_use_program_space() m68ki_cpu.address_space = FUNCTION_CODE_USER_PROGRAM;
+ #define m68ki_get_address_space() m68ki_cpu.address_space
+#else
+ #define m68ki_set_fc(A)
+ #define m68ki_use_data_space()
+ #define m68ki_use_program_space()
+ #define m68ki_get_address_space() FUNCTION_CODE_USER_DATA
+#endif /* M68K_EMULATE_FC */
+
+
+/* Enable or disable trace emulation */
+#if M68K_EMULATE_TRACE
+ /* Initiates trace checking before each instruction (t1) */
+ #define m68ki_trace_t1() m68ki_cpu.tracing = FLAG_T1;
+ /* Clear all tracing */
+ #define m68ki_clear_trace() m68ki_cpu.tracing = 0;
+ /* Cause a trace exception if we are tracing */
+ #define m68ki_exception_if_trace() if(m68ki_cpu.tracing) m68ki_exception_trace();
+#else
+ #define m68ki_trace_t1()
+ #define m68ki_clear_trace()
+ #define m68ki_exception_if_trace()
+#endif /* M68K_EMULATE_TRACE */
+
+
+/* Enable or disable Address error emulation */
+#if M68K_EMULATE_ADDRESS_ERROR
+ #define m68ki_set_address_error_trap() \
+ if(setjmp(m68ki_cpu.aerr_trap) != 0) \
+ { \
+ m68ki_exception_address_error(); \
+ }
+
+ #define m68ki_check_address_error(ADDR, WRITE_MODE, FC) \
+ if((ADDR)&1) \
+ { \
+ if (m68ki_cpu.aerr_enabled) \
+ { \
+ m68ki_cpu.aerr_address = ADDR; \
+ m68ki_cpu.aerr_write_mode = WRITE_MODE; \
+ m68ki_cpu.aerr_fc = FC; \
+ longjmp(m68ki_cpu.aerr_trap, 1); \
+ } \
+ }
+#else
+ #define m68ki_set_address_error_trap()
+ #define m68ki_check_address_error(ADDR, WRITE_MODE, FC)
+#endif /* M68K_ADDRESS_ERROR */
+
+
+/* -------------------------- EA / Operand Access ------------------------- */
+
+/*
+ * The general instruction format follows this pattern:
+ * .... XXX. .... .YYY
+ * where XXX is register X and YYY is register Y
+ */
+
+/* Data Register Isolation */
+#define DX (REG_D[(REG_IR >> 9) & 7])
+#define DY (REG_D[REG_IR & 7])
+
+/* Address Register Isolation */
+#define AX (REG_A[(REG_IR >> 9) & 7])
+#define AY (REG_A[REG_IR & 7])
+
+/* Effective Address Calculations */
+#define EA_AY_AI_8() AY /* address register indirect */
+#define EA_AY_AI_16() EA_AY_AI_8()
+#define EA_AY_AI_32() EA_AY_AI_8()
+#define EA_AY_PI_8() (AY++) /* postincrement (size = byte) */
+#define EA_AY_PI_16() ((AY+=2)-2) /* postincrement (size = word) */
+#define EA_AY_PI_32() ((AY+=4)-4) /* postincrement (size = long) */
+#define EA_AY_PD_8() (--AY) /* predecrement (size = byte) */
+#define EA_AY_PD_16() (AY-=2) /* predecrement (size = word) */
+#define EA_AY_PD_32() (AY-=4) /* predecrement (size = long) */
+#define EA_AY_DI_8() (AY+MAKE_INT_16(m68ki_read_imm_16())) /* displacement */
+#define EA_AY_DI_16() EA_AY_DI_8()
+#define EA_AY_DI_32() EA_AY_DI_8()
+#define EA_AY_IX_8() m68ki_get_ea_ix(AY) /* indirect + index */
+#define EA_AY_IX_16() EA_AY_IX_8()
+#define EA_AY_IX_32() EA_AY_IX_8()
+
+#define EA_AX_AI_8() AX
+#define EA_AX_AI_16() EA_AX_AI_8()
+#define EA_AX_AI_32() EA_AX_AI_8()
+#define EA_AX_PI_8() (AX++)
+#define EA_AX_PI_16() ((AX+=2)-2)
+#define EA_AX_PI_32() ((AX+=4)-4)
+#define EA_AX_PD_8() (--AX)
+#define EA_AX_PD_16() (AX-=2)
+#define EA_AX_PD_32() (AX-=4)
+#define EA_AX_DI_8() (AX+MAKE_INT_16(m68ki_read_imm_16()))
+#define EA_AX_DI_16() EA_AX_DI_8()
+#define EA_AX_DI_32() EA_AX_DI_8()
+#define EA_AX_IX_8() m68ki_get_ea_ix(AX)
+#define EA_AX_IX_16() EA_AX_IX_8()
+#define EA_AX_IX_32() EA_AX_IX_8()
+
+#define EA_A7_PI_8() ((REG_A[7]+=2)-2)
+#define EA_A7_PD_8() (REG_A[7]-=2)
+
+#define EA_AW_8() MAKE_INT_16(m68ki_read_imm_16()) /* absolute word */
+#define EA_AW_16() EA_AW_8()
+#define EA_AW_32() EA_AW_8()
+#define EA_AL_8() m68ki_read_imm_32() /* absolute long */
+#define EA_AL_16() EA_AL_8()
+#define EA_AL_32() EA_AL_8()
+#define EA_PCDI_8() m68ki_get_ea_pcdi() /* pc indirect + displacement */
+#define EA_PCDI_16() EA_PCDI_8()
+#define EA_PCDI_32() EA_PCDI_8()
+#define EA_PCIX_8() m68ki_get_ea_pcix() /* pc indirect + index */
+#define EA_PCIX_16() EA_PCIX_8()
+#define EA_PCIX_32() EA_PCIX_8()
+
+
+#define OPER_I_8() m68ki_read_imm_8()
+#define OPER_I_16() m68ki_read_imm_16()
+#define OPER_I_32() m68ki_read_imm_32()
+
+
+/* --------------------------- Status Register ---------------------------- */
+
+/* Flag Calculation Macros */
+#define CFLAG_8(A) (A)
+#define CFLAG_16(A) ((A)>>8)
+
+#if M68K_INT_GT_32_BIT
+ #define CFLAG_ADD_32(S, D, R) ((R)>>24)
+ #define CFLAG_SUB_32(S, D, R) ((R)>>24)
+#else
+ #define CFLAG_ADD_32(S, D, R) (((S & D) | (~R & (S | D)))>>23)
+ #define CFLAG_SUB_32(S, D, R) (((S & R) | (~D & (S | R)))>>23)
+#endif /* M68K_INT_GT_32_BIT */
+
+#define VFLAG_ADD_8(S, D, R) ((S^R) & (D^R))
+#define VFLAG_ADD_16(S, D, R) (((S^R) & (D^R))>>8)
+#define VFLAG_ADD_32(S, D, R) (((S^R) & (D^R))>>24)
+
+#define VFLAG_SUB_8(S, D, R) ((S^D) & (R^D))
+#define VFLAG_SUB_16(S, D, R) (((S^D) & (R^D))>>8)
+#define VFLAG_SUB_32(S, D, R) (((S^D) & (R^D))>>24)
+
+#define NFLAG_8(A) (A)
+#define NFLAG_16(A) ((A)>>8)
+#define NFLAG_32(A) ((A)>>24)
+#define NFLAG_64(A) ((A)>>56)
+
+#define ZFLAG_8(A) MASK_OUT_ABOVE_8(A)
+#define ZFLAG_16(A) MASK_OUT_ABOVE_16(A)
+#define ZFLAG_32(A) MASK_OUT_ABOVE_32(A)
+
+
+/* Flag values */
+#define NFLAG_SET 0x80
+#define NFLAG_CLEAR 0
+#define CFLAG_SET 0x100
+#define CFLAG_CLEAR 0
+#define XFLAG_SET 0x100
+#define XFLAG_CLEAR 0
+#define VFLAG_SET 0x80
+#define VFLAG_CLEAR 0
+#define ZFLAG_SET 0
+#define ZFLAG_CLEAR 0xffffffff
+#define SFLAG_SET 4
+#define SFLAG_CLEAR 0
+
+/* Turn flag values into 1 or 0 */
+#define XFLAG_AS_1() ((FLAG_X>>8)&1)
+#define NFLAG_AS_1() ((FLAG_N>>7)&1)
+#define VFLAG_AS_1() ((FLAG_V>>7)&1)
+#define ZFLAG_AS_1() (!FLAG_Z)
+#define CFLAG_AS_1() ((FLAG_C>>8)&1)
+
+
+/* Conditions */
+#define COND_CS() (FLAG_C&0x100)
+#define COND_CC() (!COND_CS())
+#define COND_VS() (FLAG_V&0x80)
+#define COND_VC() (!COND_VS())
+#define COND_NE() FLAG_Z
+#define COND_EQ() (!COND_NE())
+#define COND_MI() (FLAG_N&0x80)
+#define COND_PL() (!COND_MI())
+#define COND_LT() ((FLAG_N^FLAG_V)&0x80)
+#define COND_GE() (!COND_LT())
+#define COND_HI() (COND_CC() && COND_NE())
+#define COND_LS() (COND_CS() || COND_EQ())
+#define COND_GT() (COND_GE() && COND_NE())
+#define COND_LE() (COND_LT() || COND_EQ())
+
+/* Reversed conditions */
+#define COND_NOT_CS() COND_CC()
+#define COND_NOT_CC() COND_CS()
+#define COND_NOT_VS() COND_VC()
+#define COND_NOT_VC() COND_VS()
+#define COND_NOT_NE() COND_EQ()
+#define COND_NOT_EQ() COND_NE()
+#define COND_NOT_MI() COND_PL()
+#define COND_NOT_PL() COND_MI()
+#define COND_NOT_LT() COND_GE()
+#define COND_NOT_GE() COND_LT()
+#define COND_NOT_HI() COND_LS()
+#define COND_NOT_LS() COND_HI()
+#define COND_NOT_GT() COND_LE()
+#define COND_NOT_LE() COND_GT()
+
+/* Not real conditions, but here for convenience */
+#define COND_XS() (FLAG_X&0x100)
+#define COND_XC() (!COND_XS)
+
+
+/* Get the condition code register */
+#define m68ki_get_ccr() ((COND_XS() >> 4) | \
+ (COND_MI() >> 4) | \
+ (COND_EQ() << 2) | \
+ (COND_VS() >> 6) | \
+ (COND_CS() >> 8))
+
+/* Get the status register */
+#define m68ki_get_sr() ( FLAG_T1 | \
+ (FLAG_S << 11) | \
+ FLAG_INT_MASK | \
+ m68ki_get_ccr())
+
+
+
+/* ---------------------------- Cycle Counting ---------------------------- */
+
+#ifdef M68K_OVERCLOCK_SHIFT
+#define USE_CYCLES(A) m68ki_cpu.cycles += ((A) * m68ki_cpu.cycle_ratio) >> M68K_OVERCLOCK_SHIFT
+#else
+#define USE_CYCLES(A) m68ki_cpu.cycles += (A)
+#endif
+#define SET_CYCLES(A) m68ki_cpu.cycles = (A)
+
+
+/* ======================================================================== */
+/* =========================== UTILITY FUNCTIONS ========================== */
+/* ======================================================================== */
+
+void gwenesis_m68k_save_state();
+void gwenesis_m68k_load_state();
+
+/* ----------------------------- Read / Write ----------------------------- */
+
+/*** BZHXX ***/
+/* Read data immediately following the PC */
+//#define m68k_read_immediate_16(address) *(uint16 *)(m68ki_cpu.memory_map[((address)>>16)&0xff].base + ((address) & 0xffff))
+//#define m68k_read_immediate_32(address) (m68k_read_immediate_16(address) << 16) | (m68k_read_immediate_16(address+2))
+
+/* Read data relative to the PC */
+//#define m68k_read_pcrelative_8(address) READ_BYTE(m68ki_cpu.memory_map[((address)>>16)&0xff].base, (address) & 0xffff)
+//#define m68k_read_pcrelative_16(address) m68k_read_immediate_16(address)
+//#define m68k_read_pcrelative_32(address) m68k_read_immediate_32(address)
+
+/* map read immediate 8 to read immediate 16 */
+#define m68ki_read_imm_8() MASK_OUT_ABOVE_8(m68ki_read_imm_16())
+
+/* Map PC-relative reads */
+#define m68ki_read_pcrel_8(A) m68k_read_pcrelative_8(A)
+#define m68ki_read_pcrel_16(A) m68k_read_pcrelative_16(A)
+#define m68ki_read_pcrel_32(A) m68k_read_pcrelative_32(A)
+
+
+/* ======================================================================== */
+/* =============================== PROTOTYPES ============================= */
+/* ======================================================================== */
+
+/* Used by shift & rotate instructions */
+static const uint8 m68ki_shift_8_table[65] =
+{
+ 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+ 0xff, 0xff, 0xff, 0xff, 0xff
+};
+
+static const uint16 m68ki_shift_16_table[65] =
+{
+ 0x0000, 0x8000, 0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00,
+ 0xff80, 0xffc0, 0xffe0, 0xfff0, 0xfff8, 0xfffc, 0xfffe, 0xffff, 0xffff,
+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+ 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff, 0xffff,
+ 0xffff, 0xffff
+};
+
+static const uint m68ki_shift_32_table[65] =
+{
+ 0x00000000, 0x80000000, 0xc0000000, 0xe0000000, 0xf0000000, 0xf8000000,
+ 0xfc000000, 0xfe000000, 0xff000000, 0xff800000, 0xffc00000, 0xffe00000,
+ 0xfff00000, 0xfff80000, 0xfffc0000, 0xfffe0000, 0xffff0000, 0xffff8000,
+ 0xffffc000, 0xffffe000, 0xfffff000, 0xfffff800, 0xfffffc00, 0xfffffe00,
+ 0xffffff00, 0xffffff80, 0xffffffc0, 0xffffffe0, 0xfffffff0, 0xfffffff8,
+ 0xfffffffc, 0xfffffffe, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
+ 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff
+};
+
+
+/* Number of clock cycles to use for exception processing.
+ * I used 4 for any vectors that are undocumented for processing times.
+ */
+static const uint16 m68ki_exception_cycle_table[256] =
+{
+ 40*MUL, /* 0: Reset - Initial Stack Pointer */
+ 4*MUL, /* 1: Reset - Initial Program Counter */
+ 50*MUL, /* 2: Bus Error (unemulated) */
+ 50*MUL, /* 3: Address Error (unemulated) */
+ 34*MUL, /* 4: Illegal Instruction */
+ 38*MUL, /* 5: Divide by Zero -- ASG: changed from 42 */
+ 40*MUL, /* 6: CHK -- ASG: chanaged from 44 */
+ 34*MUL, /* 7: TRAPV */
+ 34*MUL, /* 8: Privilege Violation */
+ 34*MUL, /* 9: Trace */
+ 4*MUL, /* 10: 1010 */
+ 4*MUL, /* 11: 1111 */
+ 4*MUL, /* 12: RESERVED */
+ 4*MUL, /* 13: Coprocessor Protocol Violation (unemulated) */
+ 4*MUL, /* 14: Format Error */
+ 44*MUL, /* 15: Uninitialized Interrupt */
+ 4*MUL, /* 16: RESERVED */
+ 4*MUL, /* 17: RESERVED */
+ 4*MUL, /* 18: RESERVED */
+ 4*MUL, /* 19: RESERVED */
+ 4*MUL, /* 20: RESERVED */
+ 4*MUL, /* 21: RESERVED */
+ 4*MUL, /* 22: RESERVED */
+ 4*MUL, /* 23: RESERVED */
+ 44*MUL, /* 24: Spurious Interrupt */
+ 54*MUL, /* 25: Level 1 Interrupt Autovector */
+ 54*MUL, /* 26: Level 2 Interrupt Autovector */
+ 54*MUL, /* 27: Level 3 Interrupt Autovector */
+ 54*MUL, /* 28: Level 4 Interrupt Autovector */
+ 54*MUL, /* 29: Level 5 Interrupt Autovector */
+ 54*MUL, /* 30: Level 6 Interrupt Autovector */
+ 54*MUL, /* 31: Level 7 Interrupt Autovector */
+ 34*MUL, /* 32: TRAP #0 -- ASG: chanaged from 38 */
+ 34*MUL, /* 33: TRAP #1 */
+ 34*MUL, /* 34: TRAP #2 */
+ 34*MUL, /* 35: TRAP #3 */
+ 34*MUL, /* 36: TRAP #4 */
+ 34*MUL, /* 37: TRAP #5 */
+ 34*MUL, /* 38: TRAP #6 */
+ 34*MUL, /* 39: TRAP #7 */
+ 34*MUL, /* 40: TRAP #8 */
+ 34*MUL, /* 41: TRAP #9 */
+ 34*MUL, /* 42: TRAP #10 */
+ 34*MUL, /* 43: TRAP #11 */
+ 34*MUL, /* 44: TRAP #12 */
+ 34*MUL, /* 45: TRAP #13 */
+ 34*MUL, /* 46: TRAP #14 */
+ 34*MUL, /* 47: TRAP #15 */
+ 4*MUL, /* 48: FP Branch or Set on Unknown Condition (unemulated) */
+ 4*MUL, /* 49: FP Inexact Result (unemulated) */
+ 4*MUL, /* 50: FP Divide by Zero (unemulated) */
+ 4*MUL, /* 51: FP Underflow (unemulated) */
+ 4*MUL, /* 52: FP Operand Error (unemulated) */
+ 4*MUL, /* 53: FP Overflow (unemulated) */
+ 4*MUL, /* 54: FP Signaling NAN (unemulated) */
+ 4*MUL, /* 55: FP Unimplemented Data Type (unemulated) */
+ 4*MUL, /* 56: MMU Configuration Error (unemulated) */
+ 4*MUL, /* 57: MMU Illegal Operation Error (unemulated) */
+ 4*MUL, /* 58: MMU Access Level Violation Error (unemulated) */
+ 4*MUL, /* 59: RESERVED */
+ 4*MUL, /* 60: RESERVED */
+ 4*MUL, /* 61: RESERVED */
+ 4*MUL, /* 62: RESERVED */
+ 4*MUL, /* 63: RESERVED */
+ /* 64-255: User Defined */
+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,
+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,
+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,
+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,
+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,
+ 4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL,4*MUL
+};
+
+/* Read data immediately after the program counter */
+INLINE uint m68ki_read_imm_16(void);
+INLINE uint m68ki_read_imm_32(void);
+
+/* Read from the current address space */
+INLINE uint m68ki_read_8(uint address);
+INLINE uint m68ki_read_16(uint address);
+INLINE uint m68ki_read_32(uint address);
+
+/* Write to the current data space */
+INLINE void m68ki_write_8(uint address, uint value);
+INLINE void m68ki_write_16(uint address, uint value);
+INLINE void m68ki_write_32(uint address, uint value);
+
+/* Indexed and PC-relative ea fetching */
+INLINE uint m68ki_get_ea_pcdi(void);
+INLINE uint m68ki_get_ea_pcix(void);
+INLINE uint m68ki_get_ea_ix(uint An);
+
+/* Operand fetching */
+INLINE uint OPER_AY_AI_8(void);
+INLINE uint OPER_AY_AI_16(void);
+INLINE uint OPER_AY_AI_32(void);
+INLINE uint OPER_AY_PI_8(void);
+INLINE uint OPER_AY_PI_16(void);
+INLINE uint OPER_AY_PI_32(void);
+INLINE uint OPER_AY_PD_8(void);
+INLINE uint OPER_AY_PD_16(void);
+INLINE uint OPER_AY_PD_32(void);
+INLINE uint OPER_AY_DI_8(void);
+INLINE uint OPER_AY_DI_16(void);
+INLINE uint OPER_AY_DI_32(void);
+INLINE uint OPER_AY_IX_8(void);
+INLINE uint OPER_AY_IX_16(void);
+INLINE uint OPER_AY_IX_32(void);
+
+INLINE uint OPER_AX_AI_8(void);
+INLINE uint OPER_AX_AI_16(void);
+INLINE uint OPER_AX_AI_32(void);
+INLINE uint OPER_AX_PI_8(void);
+INLINE uint OPER_AX_PI_16(void);
+INLINE uint OPER_AX_PI_32(void);
+INLINE uint OPER_AX_PD_8(void);
+INLINE uint OPER_AX_PD_16(void);
+INLINE uint OPER_AX_PD_32(void);
+INLINE uint OPER_AX_DI_8(void);
+INLINE uint OPER_AX_DI_16(void);
+INLINE uint OPER_AX_DI_32(void);
+INLINE uint OPER_AX_IX_8(void);
+INLINE uint OPER_AX_IX_16(void);
+INLINE uint OPER_AX_IX_32(void);
+
+INLINE uint OPER_A7_PI_8(void);
+INLINE uint OPER_A7_PD_8(void);
+
+INLINE uint OPER_AW_8(void);
+INLINE uint OPER_AW_16(void);
+INLINE uint OPER_AW_32(void);
+INLINE uint OPER_AL_8(void);
+INLINE uint OPER_AL_16(void);
+INLINE uint OPER_AL_32(void);
+INLINE uint OPER_PCDI_8(void);
+INLINE uint OPER_PCDI_16(void);
+INLINE uint OPER_PCDI_32(void);
+INLINE uint OPER_PCIX_8(void);
+INLINE uint OPER_PCIX_16(void);
+INLINE uint OPER_PCIX_32(void);
+
+/* Stack operations */
+INLINE void m68ki_push_16(uint value);
+INLINE void m68ki_push_32(uint value);
+INLINE uint m68ki_pull_16(void);
+INLINE uint m68ki_pull_32(void);
+
+/* Program flow operations */
+INLINE void m68ki_jump(uint new_pc);
+INLINE void m68ki_jump_vector(uint vector);
+INLINE void m68ki_branch_8(uint offset);
+INLINE void m68ki_branch_16(uint offset);
+INLINE void m68ki_branch_32(uint offset);
+
+/* Status register operations. */
+INLINE void m68ki_set_s_flag(uint value); /* Only bit 2 of value should be set (i.e. 4 or 0) */
+INLINE void m68ki_set_ccr(uint value); /* set the condition code register */
+INLINE void m68ki_set_sr(uint value); /* set the status register */
+
+/* Exception processing */
+INLINE uint m68ki_init_exception(void); /* Initial exception processing */
+INLINE void m68ki_stack_frame_3word(uint pc, uint sr); /* Stack various frame types */
+#if M68K_EMULATE_ADDRESS_ERROR
+INLINE void m68ki_stack_frame_buserr(uint sr);
+#endif
+INLINE void m68ki_exception_trap(uint vector);
+INLINE void m68ki_exception_trapN(uint vector);
+#if M68K_EMULATE_TRACE
+INLINE void m68ki_exception_trace(void);
+#endif
+static void m68ki_exception_privilege_violation(void); /* do not inline in order to reduce function size and allow inlining of read/write functions by the compile */
+INLINE void m68ki_exception_1010(void);
+INLINE void m68ki_exception_1111(void);
+INLINE void m68ki_exception_illegal(void);
+#if M68K_EMULATE_ADDRESS_ERROR
+INLINE void m68ki_exception_address_error(void);
+#endif
+INLINE void m68ki_exception_interrupt(uint int_level);
+INLINE void m68ki_check_interrupts(void); /* ASG: check for interrupts */
+
+/* ======================================================================== */
+/* =========================== UTILITY FUNCTIONS ========================== */
+/* ======================================================================== */
+
+
+/* ---------------------------- Read Immediate ---------------------------- */
+
+/* Handles all immediate reads, does address error check, function code setting,
+ * and prefetching if they are enabled in m68kconf.h
+ */
+INLINE uint m68ki_read_imm_16(void)
+{
+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */
+#if M68K_CHECK_PC_ADDRESS_ERROR
+ m68ki_check_address_error(REG_PC, MODE_READ, FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */
+#endif
+#if M68K_EMULATE_PREFETCH
+ if(MASK_OUT_BELOW_2(REG_PC) != CPU_PREF_ADDR)
+ {
+ CPU_PREF_ADDR = MASK_OUT_BELOW_2(REG_PC);
+ CPU_PREF_DATA = m68k_read_immediate_32(CPU_PREF_ADDR);
+ }
+ REG_PC += 2;
+ return MASK_OUT_ABOVE_16(CPU_PREF_DATA >> ((2-((REG_PC-2)&2))<<3));
+#else
+ uint pc = REG_PC;
+ REG_PC += 2;
+ return m68k_read_immediate_16(pc);
+#endif /* M68K_EMULATE_PREFETCH */
+}
+
+INLINE uint m68ki_read_imm_32(void)
+{
+#if M68K_EMULATE_PREFETCH
+ uint temp_val;
+
+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */
+#if M68K_CHECK_PC_ADDRESS_ERROR
+ m68ki_check_address_error(REG_PC, MODE_READ, FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */
+#endif
+ if(MASK_OUT_BELOW_2(REG_PC) != CPU_PREF_ADDR)
+ {
+ CPU_PREF_ADDR = MASK_OUT_BELOW_2(REG_PC);
+ CPU_PREF_DATA = m68k_read_immediate_32(CPU_PREF_ADDR);
+ }
+ temp_val = CPU_PREF_DATA;
+ REG_PC += 2;
+ if(MASK_OUT_BELOW_2(REG_PC) != CPU_PREF_ADDR)
+ {
+ CPU_PREF_ADDR = MASK_OUT_BELOW_2(REG_PC);
+ CPU_PREF_DATA = m68k_read_immediate_32(CPU_PREF_ADDR);
+ temp_val = MASK_OUT_ABOVE_32((temp_val << 16) | (CPU_PREF_DATA >> 16));
+ }
+ REG_PC += 2;
+
+ return temp_val;
+#else
+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */
+#if M68K_CHECK_PC_ADDRESS_ERROR
+ m68ki_check_address_error(REG_PC, MODE_READ, FLAG_S | FUNCTION_CODE_USER_PROGRAM) /* auto-disable (see m68kcpu.h) */
+#endif
+ uint pc = REG_PC;
+ REG_PC += 4;
+ return m68k_read_immediate_32(pc);
+#endif /* M68K_EMULATE_PREFETCH */
+}
+
+
+
+/* ------------------------- Top level read/write ------------------------- */
+
+/* Handles all memory accesses (except for immediate reads if they are
+ * configured to use separate functions in m68kconf.h).
+ * All memory accesses must go through these top level functions.
+ * These functions will also check for address error and set the function
+ * code if they are enabled in m68kconf.h.
+ */
+ /*** BZHXX ***/
+
+INLINE uint m68ki_read_8(uint address)
+{
+
+ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */
+
+ if (ADDRESS_68K(address) < 0x800000) return FETCH8ROM(ADDRESS_68K(address));
+ if (ADDRESS_68K(address) >= 0xFF0000) return FETCH8RAM(ADDRESS_68K(address));
+ return m68k_read_memory_8(ADDRESS_68K(address));
+
+}
+
+INLINE uint m68ki_read_16(uint address)
+{
+
+ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */
+
+ if (ADDRESS_68K(address) < 0x800000) return FETCH16ROM(ADDRESS_68K(address));
+ if (ADDRESS_68K(address) >= 0xFF0000) return FETCH16RAM(ADDRESS_68K(address));
+ return m68k_read_memory_16(ADDRESS_68K(address));
+
+}
+
+INLINE uint m68ki_read_32(uint address)
+{
+
+ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */
+ if (ADDRESS_68K(address) < 0x800000) return FETCH32ROM(ADDRESS_68K(address));
+ if (ADDRESS_68K(address) >= 0xFF0000) return FETCH32RAM(ADDRESS_68K(address));
+ return m68k_read_memory_32(ADDRESS_68K(address));
+}
+
+INLINE void m68ki_write_8(uint address, uint value)
+{
+
+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */
+ if (ADDRESS_68K(address) >= 0xFF0000) {
+ WRITE8RAM(ADDRESS_68K(address), value);
+ } else
+ m68k_write_memory_8(ADDRESS_68K(address), value);
+}
+
+INLINE void m68ki_write_16(uint address, uint value)
+{
+
+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */
+ if (ADDRESS_68K(address) >= 0xFF0000) {
+ WRITE16RAM(ADDRESS_68K(address), value);
+ } else
+ m68k_write_memory_16(ADDRESS_68K(address), value);
+}
+
+INLINE void m68ki_write_32(uint address, uint value)
+{
+
+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */
+ if (ADDRESS_68K(address) >= 0xFF0000) {
+ WRITE32RAM(ADDRESS_68K(address), value);
+ } else
+ m68k_write_memory_32(ADDRESS_68K(address), value);
+}
+
+
+#if 0
+INLINE uint m68ki_read_8(uint address)
+{
+ cpu_memory_map *temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];
+ uint val;
+
+ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */
+
+ if (temp->read8) val = (*temp->read8)(ADDRESS_68K(address));
+ else val = READ_BYTE(temp->base, (address) & 0xffff);
+
+#ifdef HOOK_CPU
+ if (cpu_hook)
+ cpu_hook(HOOK_M68K_R, 1, address, val);
+#endif
+
+ return val;
+}
+
+INLINE uint m68ki_read_16(uint address)
+{
+ cpu_memory_map *temp;
+ uint val;
+
+ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */
+ m68ki_check_address_error(address, MODE_READ, FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */
+
+ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];
+ if (temp->read16) val = (*temp->read16)(ADDRESS_68K(address));
+ else val = *(uint16 *)(temp->base + ((address) & 0xffff));
+
+#ifdef HOOK_CPU
+ if (cpu_hook)
+ cpu_hook(HOOK_M68K_R, 2, address, val);
+#endif
+
+ return val;
+}
+
+INLINE uint m68ki_read_32(uint address)
+{
+ cpu_memory_map *temp;
+ uint val;
+
+ m68ki_set_fc(FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */
+ m68ki_check_address_error(address, MODE_READ, FLAG_S | m68ki_get_address_space()) /* auto-disable (see m68kcpu.h) */
+
+ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];
+ if (temp->read16) val = ((*temp->read16)(ADDRESS_68K(address)) << 16) | ((*temp->read16)(ADDRESS_68K(address + 2)));
+ else val = m68k_read_immediate_32(address);
+
+#ifdef HOOK_CPU
+ if (cpu_hook)
+ cpu_hook(HOOK_M68K_R, 4, address, val);
+#endif
+
+ return val;
+}
+
+INLINE void m68ki_write_8(uint address, uint value)
+{
+ cpu_memory_map *temp;
+
+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */
+
+#ifdef HOOK_CPU
+ if (cpu_hook)
+ cpu_hook(HOOK_M68K_W, 1, address, value);
+#endif
+
+ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];
+ if (temp->write8) (*temp->write8)(ADDRESS_68K(address),value);
+ else WRITE_BYTE(temp->base, (address) & 0xffff, value);
+}
+
+INLINE void m68ki_write_16(uint address, uint value)
+{
+ cpu_memory_map *temp;
+
+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */
+ m68ki_check_address_error(address, MODE_WRITE, FLAG_S | FUNCTION_CODE_USER_DATA); /* auto-disable (see m68kcpu.h) */
+
+#ifdef HOOK_CPU
+ if (cpu_hook)
+ cpu_hook(HOOK_M68K_W, 2, address, value);
+#endif
+
+ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];
+ if (temp->write16) (*temp->write16)(ADDRESS_68K(address),value);
+ else *(uint16 *)(temp->base + ((address) & 0xffff)) = value;
+}
+
+INLINE void m68ki_write_32(uint address, uint value)
+{
+ cpu_memory_map *temp;
+
+ m68ki_set_fc(FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */
+ m68ki_check_address_error(address, MODE_WRITE, FLAG_S | FUNCTION_CODE_USER_DATA) /* auto-disable (see m68kcpu.h) */
+
+#ifdef HOOK_CPU
+ if (cpu_hook)
+ cpu_hook(HOOK_M68K_W, 4, address, value);
+#endif
+
+ temp = &m68ki_cpu.memory_map[((address)>>16)&0xff];
+ if (temp->write16) (*temp->write16)(ADDRESS_68K(address),value>>16);
+ else *(uint16 *)(temp->base + ((address) & 0xffff)) = value >> 16;
+
+ temp = &m68ki_cpu.memory_map[((address + 2)>>16)&0xff];
+ if (temp->write16) (*temp->write16)(ADDRESS_68K(address+2),value&0xffff);
+ else *(uint16 *)(temp->base + ((address + 2) & 0xffff)) = value;
+}
+#endif
+
+/* --------------------- Effective Address Calculation -------------------- */
+
+/* The program counter relative addressing modes cause operands to be
+ * retrieved from program space, not data space.
+ */
+INLINE uint m68ki_get_ea_pcdi(void)
+{
+ uint old_pc = REG_PC;
+ m68ki_use_program_space() /* auto-disable */
+ return old_pc + MAKE_INT_16(m68ki_read_imm_16());
+}
+
+
+INLINE uint m68ki_get_ea_pcix(void)
+{
+ m68ki_use_program_space() /* auto-disable */
+ return m68ki_get_ea_ix(REG_PC);
+}
+
+/* Indexed addressing modes are encoded as follows:
+ *
+ * Base instruction format:
+ * F E D C B A 9 8 7 6 | 5 4 3 | 2 1 0
+ * x x x x x x x x x x | 1 1 0 | BASE REGISTER (An)
+ *
+ * Base instruction format for destination EA in move instructions:
+ * F E D C | B A 9 | 8 7 6 | 5 4 3 2 1 0
+ * x x x x | BASE REG | 1 1 0 | X X X X X X (An)
+ *
+ * Brief extension format:
+ * F | E D C | B | A 9 | 8 | 7 6 5 4 3 2 1 0
+ * D/A | REGISTER | W/L | SCALE | 0 | DISPLACEMENT
+ *
+ * Full extension format:
+ * F E D C B A 9 8 7 6 5 4 3 2 1 0
+ * D/A | REGISTER | W/L | SCALE | 1 | BS | IS | BD SIZE | 0 | I/IS
+ * BASE DISPLACEMENT (0, 16, 32 bit) (bd)
+ * OUTER DISPLACEMENT (0, 16, 32 bit) (od)
+ *
+ * D/A: 0 = Dn, 1 = An (Xn)
+ * W/L: 0 = W (sign extend), 1 = L (.SIZE)
+ * SCALE: 00=1, 01=2, 10=4, 11=8 (*SCALE)
+ * BS: 0=add base reg, 1=suppress base reg (An suppressed)
+ * IS: 0=add index, 1=suppress index (Xn suppressed)
+ * BD SIZE: 00=reserved, 01=NULL, 10=Word, 11=Long (size of bd)
+ *
+ * IS I/IS Operation
+ * 0 000 No Memory Indirect
+ * 0 001 indir prex with null outer
+ * 0 010 indir prex with word outer
+ * 0 011 indir prex with long outer
+ * 0 100 reserved
+ * 0 101 indir postx with null outer
+ * 0 110 indir postx with word outer
+ * 0 111 indir postx with long outer
+ * 1 000 no memory indirect
+ * 1 001 mem indir with null outer
+ * 1 010 mem indir with word outer
+ * 1 011 mem indir with long outer
+ * 1 100-111 reserved
+ */
+INLINE uint m68ki_get_ea_ix(uint An)
+{
+ /* An = base register */
+ uint extension = m68ki_read_imm_16();
+
+ uint Xn = 0; /* Index register */
+
+ /* Calculate index */
+ Xn = REG_DA[extension>>12]; /* Xn */
+ if(!BIT_B(extension)) /* W/L */
+ Xn = MAKE_INT_16(Xn);
+
+ /* Add base register and displacement and return */
+ return An + Xn + MAKE_INT_8(extension);
+}
+
+
+/* Fetch operands */
+INLINE uint OPER_AY_AI_8(void) {uint ea = EA_AY_AI_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AY_AI_16(void) {uint ea = EA_AY_AI_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AY_AI_32(void) {uint ea = EA_AY_AI_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_AY_PI_8(void) {uint ea = EA_AY_PI_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AY_PI_16(void) {uint ea = EA_AY_PI_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AY_PI_32(void) {uint ea = EA_AY_PI_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_AY_PD_8(void) {uint ea = EA_AY_PD_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AY_PD_16(void) {uint ea = EA_AY_PD_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AY_PD_32(void) {uint ea = EA_AY_PD_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_AY_DI_8(void) {uint ea = EA_AY_DI_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AY_DI_16(void) {uint ea = EA_AY_DI_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AY_DI_32(void) {uint ea = EA_AY_DI_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_AY_IX_8(void) {uint ea = EA_AY_IX_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AY_IX_16(void) {uint ea = EA_AY_IX_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AY_IX_32(void) {uint ea = EA_AY_IX_32(); return m68ki_read_32(ea);}
+
+INLINE uint OPER_AX_AI_8(void) {uint ea = EA_AX_AI_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AX_AI_16(void) {uint ea = EA_AX_AI_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AX_AI_32(void) {uint ea = EA_AX_AI_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_AX_PI_8(void) {uint ea = EA_AX_PI_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AX_PI_16(void) {uint ea = EA_AX_PI_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AX_PI_32(void) {uint ea = EA_AX_PI_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_AX_PD_8(void) {uint ea = EA_AX_PD_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AX_PD_16(void) {uint ea = EA_AX_PD_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AX_PD_32(void) {uint ea = EA_AX_PD_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_AX_DI_8(void) {uint ea = EA_AX_DI_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AX_DI_16(void) {uint ea = EA_AX_DI_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AX_DI_32(void) {uint ea = EA_AX_DI_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_AX_IX_8(void) {uint ea = EA_AX_IX_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AX_IX_16(void) {uint ea = EA_AX_IX_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AX_IX_32(void) {uint ea = EA_AX_IX_32(); return m68ki_read_32(ea);}
+
+INLINE uint OPER_A7_PI_8(void) {uint ea = EA_A7_PI_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_A7_PD_8(void) {uint ea = EA_A7_PD_8(); return m68ki_read_8(ea); }
+
+INLINE uint OPER_AW_8(void) {uint ea = EA_AW_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AW_16(void) {uint ea = EA_AW_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AW_32(void) {uint ea = EA_AW_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_AL_8(void) {uint ea = EA_AL_8(); return m68ki_read_8(ea); }
+INLINE uint OPER_AL_16(void) {uint ea = EA_AL_16(); return m68ki_read_16(ea);}
+INLINE uint OPER_AL_32(void) {uint ea = EA_AL_32(); return m68ki_read_32(ea);}
+INLINE uint OPER_PCDI_8(void) {uint ea = EA_PCDI_8(); return m68ki_read_pcrel_8(ea); }
+INLINE uint OPER_PCDI_16(void) {uint ea = EA_PCDI_16(); return m68ki_read_pcrel_16(ea);}
+INLINE uint OPER_PCDI_32(void) {uint ea = EA_PCDI_32(); return m68ki_read_pcrel_32(ea);}
+INLINE uint OPER_PCIX_8(void) {uint ea = EA_PCIX_8(); return m68ki_read_pcrel_8(ea); }
+INLINE uint OPER_PCIX_16(void) {uint ea = EA_PCIX_16(); return m68ki_read_pcrel_16(ea);}
+INLINE uint OPER_PCIX_32(void) {uint ea = EA_PCIX_32(); return m68ki_read_pcrel_32(ea);}
+
+
+
+/* ---------------------------- Stack Functions --------------------------- */
+
+/* Push/pull data from the stack */
+INLINE void m68ki_push_16(uint value)
+{
+ REG_SP = MASK_OUT_ABOVE_32(REG_SP - 2);
+ m68ki_write_16(REG_SP, value);
+}
+
+INLINE void m68ki_push_32(uint value)
+{
+ REG_SP = MASK_OUT_ABOVE_32(REG_SP - 4);
+ m68ki_write_32(REG_SP, value);
+}
+
+INLINE uint m68ki_pull_16(void)
+{
+ uint sp = REG_SP;
+ REG_SP = MASK_OUT_ABOVE_32(REG_SP + 2);
+ return m68ki_read_16(sp);
+}
+
+INLINE uint m68ki_pull_32(void)
+{
+ uint sp = REG_SP;
+ REG_SP = MASK_OUT_ABOVE_32(REG_SP + 4);
+ return m68ki_read_32(sp);
+}
+
+
+
+/* ----------------------------- Program Flow ----------------------------- */
+
+/* Jump to a new program location or vector.
+ * These functions will also call the pc_changed callback if it was enabled
+ * in m68kconf.h.
+ */
+INLINE void m68ki_jump(uint new_pc)
+{
+ REG_PC = new_pc;
+}
+
+INLINE void m68ki_jump_vector(uint vector)
+{
+ m68ki_use_data_space() /* auto-disable (see m68kcpu.h) */
+ REG_PC = m68ki_read_32(vector<<2);
+}
+
+
+/* Branch to a new memory location.
+ * The 32-bit branch will call pc_changed if it was enabled in m68kconf.h.
+ * So far I've found no problems with not calling pc_changed for 8 or 16
+ * bit branches.
+ */
+INLINE void m68ki_branch_8(uint offset)
+{
+ REG_PC += MAKE_INT_8(offset);
+}
+
+INLINE void m68ki_branch_16(uint offset)
+{
+ REG_PC += MAKE_INT_16(offset);
+}
+
+INLINE void m68ki_branch_32(uint offset)
+{
+ REG_PC += offset;
+}
+
+
+
+/* ---------------------------- Status Register --------------------------- */
+
+/* Set the S flag and change the active stack pointer.
+ * Note that value MUST be 4 or 0.
+ */
+INLINE void m68ki_set_s_flag(uint value)
+{
+ /* Backup the old stack pointer */
+ REG_SP_BASE[FLAG_S] = REG_SP;
+ /* Set the S flag */
+ FLAG_S = value;
+ /* Set the new stack pointer */
+ REG_SP = REG_SP_BASE[FLAG_S];
+}
+
+
+/* Set the condition code register */
+INLINE void m68ki_set_ccr(uint value)
+{
+ FLAG_X = BIT_4(value) << 4;
+ FLAG_N = BIT_3(value) << 4;
+ FLAG_Z = !BIT_2(value);
+ FLAG_V = BIT_1(value) << 6;
+ FLAG_C = BIT_0(value) << 8;
+}
+
+
+/* Set the status register and check for interrupts */
+INLINE void m68ki_set_sr(uint value)
+{
+ /* Set the status register */
+ FLAG_T1 = BIT_F(value);
+ FLAG_INT_MASK = value & 0x0700;
+ m68ki_set_ccr(value);
+ m68ki_set_s_flag((value >> 11) & 4);
+
+ /* Check current IRQ status */
+ m68ki_check_interrupts();
+}
+
+
+/* ------------------------- Exception Processing ------------------------- */
+
+/* Initiate exception processing */
+INLINE uint m68ki_init_exception(void)
+{
+ /* Save the old status register */
+ uint sr = m68ki_get_sr();
+
+ /* Turn off trace flag, clear pending traces */
+ FLAG_T1 = 0;
+ m68ki_clear_trace()
+
+ /* Enter supervisor mode */
+ m68ki_set_s_flag(SFLAG_SET);
+
+ return sr;
+}
+
+/* 3 word stack frame (68000 only) */
+INLINE void m68ki_stack_frame_3word(uint pc, uint sr)
+{
+ m68ki_push_32(pc);
+ m68ki_push_16(sr);
+}
+
+#if M68K_EMULATE_ADDRESS_ERROR
+/* Bus error stack frame (68000 only).
+ */
+INLINE void m68ki_stack_frame_buserr(uint sr)
+{
+ m68ki_push_32(REG_PC);
+ m68ki_push_16(sr);
+ m68ki_push_16(REG_IR);
+ m68ki_push_32(m68ki_cpu.aerr_address); /* access address */
+ /* 0 0 0 0 0 0 0 0 0 0 0 R/W I/N FC
+ * R/W 0 = write, 1 = read
+ * I/N 0 = instruction, 1 = not
+ * FC 3-bit function code
+ */
+ m68ki_push_16(m68ki_cpu.aerr_write_mode | CPU_INSTR_MODE | m68ki_cpu.aerr_fc);
+}
+#endif
+
+/* Used for Group 2 exceptions.
+ */
+INLINE void m68ki_exception_trap(uint vector)
+{
+ uint sr = m68ki_init_exception();
+
+ m68ki_stack_frame_3word(REG_PC, sr);
+
+ m68ki_jump_vector(vector);
+
+ /* Use up some clock cycles */
+ USE_CYCLES(CYC_EXCEPTION[vector]);
+}
+
+/* Trap#n stacks a 0 frame but behaves like group2 otherwise */
+INLINE void m68ki_exception_trapN(uint vector)
+{
+ uint sr = m68ki_init_exception();
+ m68ki_stack_frame_3word(REG_PC, sr);
+ m68ki_jump_vector(vector);
+
+ /* Use up some clock cycles */
+ USE_CYCLES(CYC_EXCEPTION[vector]);
+}
+
+#if M68K_EMULATE_TRACE
+/* Exception for trace mode */
+INLINE void m68ki_exception_trace(void)
+{
+ uint sr = m68ki_init_exception();
+
+ #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON
+ CPU_INSTR_MODE = INSTRUCTION_NO;
+ #endif /* M68K_EMULATE_ADDRESS_ERROR */
+
+ m68ki_stack_frame_3word(REG_PC, sr);
+ m68ki_jump_vector(EXCEPTION_TRACE);
+
+ /* Trace nullifies a STOP instruction */
+ CPU_STOPPED &= ~STOP_LEVEL_STOP;
+
+ /* Use up some clock cycles */
+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_TRACE]);
+}
+#endif
+
+/* Exception for privilege violation */
+static void m68ki_exception_privilege_violation(void)
+{
+ uint sr = m68ki_init_exception();
+
+ #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON
+ CPU_INSTR_MODE = INSTRUCTION_NO;
+ #endif /* M68K_EMULATE_ADDRESS_ERROR */
+
+ m68ki_stack_frame_3word(REG_PC-2, sr);
+ m68ki_jump_vector(EXCEPTION_PRIVILEGE_VIOLATION);
+
+ /* Use up some clock cycles and undo the instruction's cycles */
+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_PRIVILEGE_VIOLATION] - CYC_INSTRUCTION(REG_IR));
+}
+
+/* Exception for A-Line instructions */
+INLINE void m68ki_exception_1010(void)
+{
+ uint sr = m68ki_init_exception();
+ m68ki_stack_frame_3word(REG_PC-2, sr);
+ m68ki_jump_vector(EXCEPTION_1010);
+
+ /* Use up some clock cycles and undo the instruction's cycles */
+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_1010] - CYC_INSTRUCTION(REG_IR));
+}
+
+/* Exception for F-Line instructions */
+INLINE void m68ki_exception_1111(void)
+{
+ uint sr = m68ki_init_exception();
+ m68ki_stack_frame_3word(REG_PC-2, sr);
+ m68ki_jump_vector(EXCEPTION_1111);
+
+ /* Use up some clock cycles and undo the instruction's cycles */
+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_1111] - CYC_INSTRUCTION(REG_IR));
+}
+
+/* Exception for illegal instructions */
+INLINE void m68ki_exception_illegal(void)
+{
+ uint sr = m68ki_init_exception();
+
+ #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON
+ CPU_INSTR_MODE = INSTRUCTION_NO;
+ #endif /* M68K_EMULATE_ADDRESS_ERROR */
+
+ m68ki_stack_frame_3word(REG_PC-2, sr);
+ m68ki_jump_vector(EXCEPTION_ILLEGAL_INSTRUCTION);
+
+ /* Use up some clock cycles and undo the instruction's cycles */
+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_ILLEGAL_INSTRUCTION] - CYC_INSTRUCTION(REG_IR));
+}
+
+
+#if M68K_EMULATE_ADDRESS_ERROR
+/* Exception for address error */
+INLINE void m68ki_exception_address_error(void)
+{
+ uint sr = m68ki_init_exception();
+
+ /* If we were processing a bus error, address error, or reset,
+ * this is a catastrophic failure.
+ * Halt the CPU
+ */
+ if(CPU_RUN_MODE == RUN_MODE_BERR_AERR_RESET)
+ {
+ CPU_STOPPED = STOP_LEVEL_HALT;
+ SET_CYCLES(m68ki_cpu.cycle_end - CYC_INSTRUCTION(REG_IR));
+ return;
+ }
+ CPU_RUN_MODE = RUN_MODE_BERR_AERR_RESET;
+
+ /* Note: This is implemented for 68000 only! */
+ m68ki_stack_frame_buserr(sr);
+
+ m68ki_jump_vector(EXCEPTION_ADDRESS_ERROR);
+
+ /* Use up some clock cycles and undo the instruction's cycles */
+ USE_CYCLES(CYC_EXCEPTION[EXCEPTION_ADDRESS_ERROR] - CYC_INSTRUCTION(REG_IR));
+}
+#endif
+
+/* Service an interrupt request and start exception processing */
+INLINE void m68ki_exception_interrupt(uint int_level)
+{
+ uint vector, sr, new_pc;
+
+ #if M68K_EMULATE_ADDRESS_ERROR == OPT_ON
+ CPU_INSTR_MODE = INSTRUCTION_NO;
+ #endif /* M68K_EMULATE_ADDRESS_ERROR */
+
+ /* Turn off the stopped state */
+ CPU_STOPPED &= STOP_LEVEL_HALT;
+
+ /* If we are halted, don't do anything */
+ if(CPU_STOPPED)
+ return;
+
+ /* Always use the autovectors. */
+ vector = EXCEPTION_INTERRUPT_AUTOVECTOR+int_level;
+
+ /* Start exception processing */
+ sr = m68ki_init_exception();
+
+ /* Set the interrupt mask to the level of the one being serviced */
+ FLAG_INT_MASK = int_level<<8;
+
+ /* Acknowledge the interrupt */
+ m68ki_int_ack(int_level);
+
+ /* Get the new PC */
+ m68ki_use_data_space() /* auto-disable (see m68kcpu.h) */
+ new_pc = m68ki_read_32(vector<<2);
+
+ /* If vector is uninitialized, call the uninitialized interrupt vector */
+ if(new_pc == 0)
+ new_pc = m68ki_read_32((EXCEPTION_UNINITIALIZED_INTERRUPT<<2));
+
+ /* Generate a stack frame */
+ m68ki_stack_frame_3word(REG_PC, sr);
+
+ m68ki_jump(new_pc);
+
+ /* Update cycle count now */
+ USE_CYCLES(CYC_EXCEPTION[vector]);
+}
+
+/* ASG: Check for interrupts */
+INLINE void m68ki_check_interrupts(void)
+{
+ if(CPU_INT_LEVEL > FLAG_INT_MASK)
+ m68ki_exception_interrupt(CPU_INT_LEVEL>>8);
+}
+
+
+/* ======================================================================== */
+/* ============================== END OF FILE ============================= */
+/* ======================================================================== */
+
+#endif /* M68KCPU__HEADER */
diff --git a/games/retrogo/src/md/m68kops.h b/games/retrogo/src/md/m68kops.h
new file mode 100644
index 00000000..6847b3fb
--- /dev/null
+++ b/games/retrogo/src/md/m68kops.h
@@ -0,0 +1,25487 @@
+
+/* ======================================================================== */
+/* ============== CYCLE-ACCURATE DIV/MUL EXECUTION ======================== */
+/* ======================================================================== */
+
+INLINE void UseDivuCycles(uint32 dst, uint32 src)
+{
+ int i;
+
+ /* minimum cycle time */
+ uint mcycles = 38 * MUL;
+
+ /* 16-bit divisor */
+ src <<= 16;
+
+ /* 16-bit dividend */
+ for (i=0; i<15; i++)
+ {
+ /* check if carry bit set */
+ if ((sint32) dst < 0)
+ {
+ /* shift dividend and apply divisor */
+ dst <<= 1;
+ dst -= src;
+ }
+ else
+ {
+ /* shift dividend and add two cycles */
+ dst <<= 1;
+ mcycles += (2 * MUL);
+
+ if (dst >= src)
+ {
+ /* apply divisor and remove one cycle */
+ dst -= src;
+ mcycles -= 1 * MUL;
+ }
+ }
+ }
+
+ USE_CYCLES(mcycles << 1);
+}
+
+INLINE void UseDivsCycles(sint32 dst, sint16 src)
+{
+ /* minimum cycle time */
+ uint mcycles = 6 * MUL;
+
+ /* negative dividend */
+ if (dst < 0) mcycles += 1 * MUL;
+
+ if ((abs(dst) >> 16) < abs(src))
+ {
+ int i;
+
+ /* absolute quotient */
+ uint32 quotient = abs(dst) / abs(src);
+
+ /* add default cycle time */
+ mcycles += (55 * MUL);
+
+ /* positive divisor */
+ if (src >= 0)
+ {
+ /* check dividend sign */
+ if (dst >= 0) mcycles -= 1 * MUL;
+ else mcycles += 1 * MUL;
+ }
+
+ /* check higher 15-bits of quotient */
+ for (i=0; i<15; i++)
+ {
+ quotient >>= 1;
+ if (!(quotient & 1)) mcycles += 1 * MUL;
+ }
+ }
+ else
+ {
+ /* absolute overflow */
+ mcycles += (2 * MUL);
+ }
+
+ USE_CYCLES(mcycles << 1);
+}
+
+INLINE void UseMuluCycles(uint16 src)
+{
+ /* minimum cycle time */
+ uint mcycles = 38 * MUL;
+
+ /* count number of bits set to 1 */
+ while (src)
+ {
+ if (src & 1) mcycles += (2 * MUL);
+ src >>= 1;
+ }
+
+ /* 38 + 2*N */
+ USE_CYCLES(mcycles);
+}
+
+INLINE void UseMulsCycles(sint16 src)
+{
+ /* minimum cycle time */
+ uint mcycles = 38 * MUL;
+
+ /* detect 01 or 10 patterns */
+ sint32 tmp = src << 1;
+ tmp = (tmp ^ src) & 0xFFFF;
+
+ /* count number of bits set to 1 */
+ while (tmp)
+ {
+ if (tmp & 1) mcycles += (2 * MUL);
+ tmp >>= 1;
+ }
+
+ /* 38 + 2*N */
+ USE_CYCLES(mcycles);
+}
+
+
+/* ======================================================================== */
+/* ========================= INSTRUCTION HANDLERS ========================= */
+/* ======================================================================== */
+
+
+static void m68k_op_1010(void)
+{
+ m68ki_exception_1010();
+}
+
+/* (NumPlay: line F too, as the table has every opcode) */
+static void m68k_op_1111(void)
+{
+ m68ki_exception_1111();
+}
+
+static void m68k_op_abcd_8_rr(void)
+{
+ uint* r_dst = &DX;
+ uint src = DY;
+ uint dst = *r_dst;
+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 9)
+ corf = 6;
+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
+ FLAG_V = ~res; /* Undefined V behavior */
+
+ res += corf;
+ FLAG_X = FLAG_C = (res > 0x9f) << 8;
+ if(FLAG_C)
+ res -= 0xa0;
+
+ FLAG_V &= res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+}
+
+
+static void m68k_op_abcd_8_mm_ax7(void)
+{
+ uint src = OPER_AY_PD_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 9)
+ corf = 6;
+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
+ FLAG_V = ~res; /* Undefined V behavior */
+
+ res += corf;
+ FLAG_X = FLAG_C = (res > 0x9f) << 8;
+ if(FLAG_C)
+ res -= 0xa0;
+
+ FLAG_V &= res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_abcd_8_mm_ay7(void)
+{
+ uint src = OPER_A7_PD_8();
+ uint ea = EA_AX_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 9)
+ corf = 6;
+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
+ FLAG_V = ~res; /* Undefined V behavior */
+
+ res += corf;
+ FLAG_X = FLAG_C = (res > 0x9f) << 8;
+ if(FLAG_C)
+ res -= 0xa0;
+
+ FLAG_V &= res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_abcd_8_mm_axy7(void)
+{
+ uint src = OPER_A7_PD_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 9)
+ corf = 6;
+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
+ FLAG_V = ~res; /* Undefined V behavior */
+
+ res += corf;
+ FLAG_X = FLAG_C = (res > 0x9f) << 8;
+ if(FLAG_C)
+ res -= 0xa0;
+
+ FLAG_V &= res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_abcd_8_mm(void)
+{
+ uint src = OPER_AY_PD_8();
+ uint ea = EA_AX_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = LOW_NIBBLE(src) + LOW_NIBBLE(dst) + XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 9)
+ corf = 6;
+ res += HIGH_NIBBLE(src) + HIGH_NIBBLE(dst);
+ FLAG_V = ~res; /* Undefined V behavior */
+
+ res += corf;
+ FLAG_X = FLAG_C = (res > 0x9f) << 8;
+ if(FLAG_C)
+ res -= 0xa0;
+
+ FLAG_V &= res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_add_8_er_d(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_8(DY);
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_ai(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_AI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_pi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_pi7(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_A7_PI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_pd(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PD_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_pd7(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_A7_PD_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_di(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_DI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_ix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_IX_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_aw(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AW_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_al(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AL_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_pcdi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCDI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_pcix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCIX_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_8_er_i(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_I_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_d(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_16(DY);
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_a(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_16(AY);
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_ai(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_AI_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_pi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PI_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_pd(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PD_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_di(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_DI_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_ix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_IX_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_aw(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AW_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_al(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AL_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_pcdi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCDI_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_pcix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCIX_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_16_er_i(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_I_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_d(void)
+{
+ uint* r_dst = &DX;
+ uint src = DY;
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_a(void)
+{
+ uint* r_dst = &DX;
+ uint src = AY;
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_ai(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_AI_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_pi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PI_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_pd(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PD_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_di(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_DI_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_ix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_IX_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_aw(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AW_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_al(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AL_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_pcdi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCDI_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_pcix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCIX_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_32_er_i(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_I_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_add_8_re_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_8_re_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_8_re_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_8_re_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_8_re_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_8_re_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_8_re_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_8_re_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_8_re_al(void)
+{
+ uint ea = EA_AL_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_16_re_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_16_re_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_16_re_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_16_re_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_16_re_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_16_re_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_16_re_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_32_re_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_32_re_pi(void)
+{
+ uint ea = EA_AY_PI_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_32_re_pd(void)
+{
+ uint ea = EA_AY_PD_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_32_re_di(void)
+{
+ uint ea = EA_AY_DI_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_32_re_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_32_re_aw(void)
+{
+ uint ea = EA_AW_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_add_32_re_al(void)
+{
+ uint ea = EA_AL_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_adda_16_d(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + MAKE_INT_16(DY));
+}
+
+
+static void m68k_op_adda_16_a(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + MAKE_INT_16(AY));
+}
+
+
+static void m68k_op_adda_16_ai(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_AI_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_16_pi(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_PI_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_16_pd(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_PD_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_16_di(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_DI_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_16_ix(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_IX_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_16_aw(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AW_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_16_al(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AL_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_16_pcdi(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_PCDI_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_16_pcix(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_PCIX_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_16_i(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_I_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + src);
+}
+
+
+static void m68k_op_adda_32_d(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + DY);
+}
+
+
+static void m68k_op_adda_32_a(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + AY);
+}
+
+
+static void m68k_op_adda_32_ai(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_AI_32() + *r_dst);
+}
+
+
+static void m68k_op_adda_32_pi(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_PI_32() + *r_dst);
+}
+
+
+static void m68k_op_adda_32_pd(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_PD_32() + *r_dst);
+}
+
+
+static void m68k_op_adda_32_di(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_DI_32() + *r_dst);
+}
+
+
+static void m68k_op_adda_32_ix(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_AY_IX_32() + *r_dst);
+}
+
+
+static void m68k_op_adda_32_aw(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_AW_32() + *r_dst);
+}
+
+
+static void m68k_op_adda_32_al(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_AL_32() + *r_dst);
+}
+
+
+static void m68k_op_adda_32_pcdi(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_PCDI_32() + *r_dst);
+}
+
+
+static void m68k_op_adda_32_pcix(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_PCIX_32() + *r_dst);
+}
+
+
+static void m68k_op_adda_32_i(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(OPER_I_32() + *r_dst);
+}
+
+
+static void m68k_op_addi_8_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = OPER_I_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_addi_8_ai(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_AI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_8_pi(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_8_pi7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_8_pd(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_8_pd7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_8_di(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_DI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_8_ix(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_IX_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_8_aw(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AW_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_8_al(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AL_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_16_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = OPER_I_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_addi_16_ai(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_AI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_16_pi(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_16_pd(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PD_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_16_di(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_DI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_16_ix(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_IX_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_16_aw(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AW_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_16_al(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AL_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_32_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = OPER_I_32();
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_addi_32_ai(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_AI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_32_pi(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_32_pd(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PD_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_32_di(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_DI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_32_ix(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_IX_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_32_aw(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AW_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addi_32_al(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AL_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_8_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_addq_8_ai(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_AI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_8_pi(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_8_pi7(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_A7_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_8_pd(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_8_pd7(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_8_di(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_DI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_8_ix(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_IX_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_8_aw(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AW_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_8_al(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AL_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_16_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_addq_16_a(void)
+{
+ uint* r_dst = &AY;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + (((REG_IR >> 9) - 1) & 7) + 1);
+}
+
+
+static void m68k_op_addq_16_ai(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_AI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_16_pi(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_16_pd(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PD_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_16_di(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_DI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_16_ix(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_IX_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_16_aw(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AW_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_16_al(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AL_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_32_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint dst = *r_dst;
+ uint res = src + dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_addq_32_a(void)
+{
+ uint* r_dst = &AY;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst + (((REG_IR >> 9) - 1) & 7) + 1);
+}
+
+
+static void m68k_op_addq_32_ai(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_AI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_32_pi(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_32_pd(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PD_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_32_di(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_DI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_32_ix(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_IX_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_32_aw(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AW_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addq_32_al(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AL_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst;
+
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_addx_8_rr(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_8(DY);
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src + dst + XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+}
+
+
+static void m68k_op_addx_16_rr(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_16(DY);
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src + dst + XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+}
+
+
+static void m68k_op_addx_32_rr(void)
+{
+ uint* r_dst = &DX;
+ uint src = DY;
+ uint dst = *r_dst;
+ uint res = src + dst + XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ *r_dst = res;
+}
+
+
+static void m68k_op_addx_8_mm_ax7(void)
+{
+ uint src = OPER_AY_PD_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst + XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_addx_8_mm_ay7(void)
+{
+ uint src = OPER_A7_PD_8();
+ uint ea = EA_AX_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst + XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_addx_8_mm_axy7(void)
+{
+ uint src = OPER_A7_PD_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst + XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_addx_8_mm(void)
+{
+ uint src = OPER_AY_PD_8();
+ uint ea = EA_AX_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = src + dst + XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_V = VFLAG_ADD_8(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_addx_16_mm(void)
+{
+ uint src = OPER_AY_PD_16();
+ uint ea = EA_AX_PD_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = src + dst + XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_V = VFLAG_ADD_16(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_addx_32_mm(void)
+{
+ uint src = OPER_AY_PD_32();
+ uint ea = EA_AX_PD_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = src + dst + XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_ADD_32(src, dst, res);
+ FLAG_X = FLAG_C = CFLAG_ADD_32(src, dst, res);
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_and_8_er_d(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (DY | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_ai(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_AI_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_pi(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_PI_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_pi7(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_A7_PI_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_pd(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_PD_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_pd7(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_A7_PD_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_di(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_DI_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_ix(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AY_IX_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_aw(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AW_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_al(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_AL_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_pcdi(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_PCDI_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_pcix(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_PCIX_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_er_i(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DX &= (OPER_I_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_d(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (DY | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_ai(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_AI_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_pi(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_PI_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_pd(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_PD_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_di(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_DI_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_ix(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AY_IX_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_aw(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AW_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_al(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_AL_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_pcdi(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_PCDI_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_pcix(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_PCIX_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_16_er_i(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DX &= (OPER_I_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_d(void)
+{
+ FLAG_Z = DX &= DY;
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_ai(void)
+{
+ FLAG_Z = DX &= OPER_AY_AI_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_pi(void)
+{
+ FLAG_Z = DX &= OPER_AY_PI_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_pd(void)
+{
+ FLAG_Z = DX &= OPER_AY_PD_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_di(void)
+{
+ FLAG_Z = DX &= OPER_AY_DI_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_ix(void)
+{
+ FLAG_Z = DX &= OPER_AY_IX_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_aw(void)
+{
+ FLAG_Z = DX &= OPER_AW_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_al(void)
+{
+ FLAG_Z = DX &= OPER_AL_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_pcdi(void)
+{
+ FLAG_Z = DX &= OPER_PCDI_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_pcix(void)
+{
+ FLAG_Z = DX &= OPER_PCIX_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_32_er_i(void)
+{
+ FLAG_Z = DX &= OPER_I_32();
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_and_8_re_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint res = DX & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_8_re_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint res = DX & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_8_re_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint res = DX & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_8_re_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint res = DX & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_8_re_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint res = DX & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_8_re_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint res = DX & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_8_re_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint res = DX & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_8_re_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint res = DX & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_8_re_al(void)
+{
+ uint ea = EA_AL_8();
+ uint res = DX & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_16_re_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint res = DX & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_16_re_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint res = DX & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_16_re_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint res = DX & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_16_re_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint res = DX & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_16_re_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint res = DX & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_16_re_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint res = DX & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_16_re_al(void)
+{
+ uint ea = EA_AL_16();
+ uint res = DX & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_and_32_re_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+ uint res = DX & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_and_32_re_pi(void)
+{
+ uint ea = EA_AY_PI_32();
+ uint res = DX & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_and_32_re_pd(void)
+{
+ uint ea = EA_AY_PD_32();
+ uint res = DX & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_and_32_re_di(void)
+{
+ uint ea = EA_AY_DI_32();
+ uint res = DX & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_and_32_re_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+ uint res = DX & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_and_32_re_aw(void)
+{
+ uint ea = EA_AW_32();
+ uint res = DX & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_and_32_re_al(void)
+{
+ uint ea = EA_AL_32();
+ uint res = DX & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_andi_8_d(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_8(DY &= (OPER_I_8() | 0xffffff00));
+
+ FLAG_N = NFLAG_8(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_andi_8_ai(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_AI_8();
+ uint res = src & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_andi_8_pi(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PI_8();
+ uint res = src & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_andi_8_pi7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PI_8();
+ uint res = src & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_andi_8_pd(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PD_8();
+ uint res = src & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_andi_8_pd7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PD_8();
+ uint res = src & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_andi_8_di(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_DI_8();
+ uint res = src & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_andi_8_ix(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_IX_8();
+ uint res = src & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_andi_8_aw(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AW_8();
+ uint res = src & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_andi_8_al(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AL_8();
+ uint res = src & m68ki_read_8(ea);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_andi_16_d(void)
+{
+ FLAG_Z = MASK_OUT_ABOVE_16(DY &= (OPER_I_16() | 0xffff0000));
+
+ FLAG_N = NFLAG_16(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_andi_16_ai(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_AI_16();
+ uint res = src & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_andi_16_pi(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PI_16();
+ uint res = src & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_andi_16_pd(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PD_16();
+ uint res = src & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_andi_16_di(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_DI_16();
+ uint res = src & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_andi_16_ix(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_IX_16();
+ uint res = src & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_andi_16_aw(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AW_16();
+ uint res = src & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_andi_16_al(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AL_16();
+ uint res = src & m68ki_read_16(ea);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_andi_32_d(void)
+{
+ FLAG_Z = DY &= (OPER_I_32());
+
+ FLAG_N = NFLAG_32(FLAG_Z);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_andi_32_ai(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_AI_32();
+ uint res = src & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_andi_32_pi(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PI_32();
+ uint res = src & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_andi_32_pd(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PD_32();
+ uint res = src & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_andi_32_di(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_DI_32();
+ uint res = src & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_andi_32_ix(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_IX_32();
+ uint res = src & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_andi_32_aw(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AW_32();
+ uint res = src & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_andi_32_al(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AL_32();
+ uint res = src & m68ki_read_32(ea);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_andi_16_toc(void)
+{
+ m68ki_set_ccr(m68ki_get_ccr() & OPER_I_16());
+}
+
+
+static void m68k_op_andi_16_tos(void)
+{
+ if(FLAG_S)
+ {
+ uint src = OPER_I_16();
+ m68ki_set_sr(m68ki_get_sr() & src);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_asr_8_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src >> shift;
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(GET_MSB_8(src))
+ res |= m68ki_shift_8_table[shift];
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_X = FLAG_C = src << (9-shift);
+}
+
+
+static void m68k_op_asr_16_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src >> shift;
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(GET_MSB_16(src))
+ res |= m68ki_shift_16_table[shift];
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_X = FLAG_C = src << (9-shift);
+}
+
+
+static void m68k_op_asr_32_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = *r_dst;
+ uint res = src >> shift;
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(GET_MSB_32(src))
+ res |= m68ki_shift_32_table[shift];
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_X = FLAG_C = src << (9-shift);
+}
+
+
+static void m68k_op_asr_8_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src >> shift;
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift < 8)
+ {
+ if(GET_MSB_8(src))
+ res |= m68ki_shift_8_table[shift];
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_X = FLAG_C = src << (9-shift);
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ if(GET_MSB_8(src))
+ {
+ *r_dst |= 0xff;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_SET;
+ FLAG_Z = ZFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ *r_dst &= 0xffffff00;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_8(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_asr_16_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src >> shift;
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift < 16)
+ {
+ if(GET_MSB_16(src))
+ res |= m68ki_shift_16_table[shift];
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_C = FLAG_X = (src >> (shift - 1))<<8;
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ if(GET_MSB_16(src))
+ {
+ *r_dst |= 0xffff;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_SET;
+ FLAG_Z = ZFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ *r_dst &= 0xffff0000;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_16(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_asr_32_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = *r_dst;
+ uint res = src >> shift;
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift < 32)
+ {
+ if(GET_MSB_32(src))
+ res |= m68ki_shift_32_table[shift];
+
+ *r_dst = res;
+
+ FLAG_C = FLAG_X = (src >> (shift - 1))<<8;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ if(GET_MSB_32(src))
+ {
+ *r_dst = 0xffffffff;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_SET;
+ FLAG_Z = ZFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ *r_dst = 0;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_32(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_asr_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ if(GET_MSB_16(src))
+ res |= 0x8000;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = FLAG_X = src << 8;
+}
+
+
+static void m68k_op_asr_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ if(GET_MSB_16(src))
+ res |= 0x8000;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = FLAG_X = src << 8;
+}
+
+
+static void m68k_op_asr_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ if(GET_MSB_16(src))
+ res |= 0x8000;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = FLAG_X = src << 8;
+}
+
+
+static void m68k_op_asr_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ if(GET_MSB_16(src))
+ res |= 0x8000;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = FLAG_X = src << 8;
+}
+
+
+static void m68k_op_asr_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ if(GET_MSB_16(src))
+ res |= 0x8000;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = FLAG_X = src << 8;
+}
+
+
+static void m68k_op_asr_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ if(GET_MSB_16(src))
+ res |= 0x8000;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = FLAG_X = src << 8;
+}
+
+
+static void m68k_op_asr_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ if(GET_MSB_16(src))
+ res |= 0x8000;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = FLAG_X = src << 8;
+}
+
+
+static void m68k_op_asl_8_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = MASK_OUT_ABOVE_8(src << shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_X = FLAG_C = src << shift;
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ src &= m68ki_shift_8_table[shift + 1];
+ FLAG_V = (!(src == 0 || (src == m68ki_shift_8_table[shift + 1] && shift < 8)))<<7;
+}
+
+
+static void m68k_op_asl_16_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = MASK_OUT_ABOVE_16(src << shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> (8-shift);
+ src &= m68ki_shift_16_table[shift + 1];
+ FLAG_V = (!(src == 0 || src == m68ki_shift_16_table[shift + 1]))<<7;
+}
+
+
+static void m68k_op_asl_32_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = *r_dst;
+ uint res = MASK_OUT_ABOVE_32(src << shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> (24-shift);
+ src &= m68ki_shift_32_table[shift + 1];
+ FLAG_V = (!(src == 0 || src == m68ki_shift_32_table[shift + 1]))<<7;
+}
+
+
+static void m68k_op_asl_8_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = MASK_OUT_ABOVE_8(src << shift);
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift < 8)
+ {
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+ FLAG_X = FLAG_C = src << shift;
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ src &= m68ki_shift_8_table[shift + 1];
+ FLAG_V = (!(src == 0 || src == m68ki_shift_8_table[shift + 1]))<<7;
+ return;
+ }
+
+ *r_dst &= 0xffffff00;
+ FLAG_X = FLAG_C = ((shift == 8 ? src & 1 : 0))<<8;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = (!(src == 0))<<7;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_8(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_asl_16_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = MASK_OUT_ABOVE_16(src << shift);
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift < 16)
+ {
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ FLAG_X = FLAG_C = (src << shift) >> 8;
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ src &= m68ki_shift_16_table[shift + 1];
+ FLAG_V = (!(src == 0 || src == m68ki_shift_16_table[shift + 1]))<<7;
+ return;
+ }
+
+ *r_dst &= 0xffff0000;
+ FLAG_X = FLAG_C = ((shift == 16 ? src & 1 : 0))<<8;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = (!(src == 0))<<7;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_16(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_asl_32_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = *r_dst;
+ uint res = MASK_OUT_ABOVE_32(src << shift);
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift < 32)
+ {
+ *r_dst = res;
+ FLAG_X = FLAG_C = (src >> (32 - shift)) << 8;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ src &= m68ki_shift_32_table[shift + 1];
+ FLAG_V = (!(src == 0 || src == m68ki_shift_32_table[shift + 1]))<<7;
+ return;
+ }
+
+ *r_dst = 0;
+ FLAG_X = FLAG_C = ((shift == 32 ? src & 1 : 0))<<8;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = (!(src == 0))<<7;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_32(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_asl_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ src &= 0xc000;
+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;
+}
+
+
+static void m68k_op_asl_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ src &= 0xc000;
+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;
+}
+
+
+static void m68k_op_asl_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ src &= 0xc000;
+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;
+}
+
+
+static void m68k_op_asl_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ src &= 0xc000;
+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;
+}
+
+
+static void m68k_op_asl_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ src &= 0xc000;
+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;
+}
+
+
+static void m68k_op_asl_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ src &= 0xc000;
+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;
+}
+
+
+static void m68k_op_asl_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ src &= 0xc000;
+ FLAG_V = (!(src == 0 || src == 0xc000))<<7;
+}
+
+
+static void m68k_op_bhi_8(void)
+{
+ if(COND_HI())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bls_8(void)
+{
+ if(COND_LS())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bcc_8(void)
+{
+ if(COND_CC())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bcs_8(void)
+{
+ if(COND_CS())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bne_8(void)
+{
+ if(COND_NE())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_beq_8(void)
+{
+ if(COND_EQ())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bvc_8(void)
+{
+ if(COND_VC())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bvs_8(void)
+{
+ if(COND_VS())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bpl_8(void)
+{
+ if(COND_PL())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bmi_8(void)
+{
+ if(COND_MI())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bge_8(void)
+{
+ if(COND_GE())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_blt_8(void)
+{
+ if(COND_LT())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bgt_8(void)
+{
+ if(COND_GT())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_ble_8(void)
+{
+ if(COND_LE())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bhi_16(void)
+{
+ if(COND_HI())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bls_16(void)
+{
+ if(COND_LS())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bcc_16(void)
+{
+ if(COND_CC())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bcs_16(void)
+{
+ if(COND_CS())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bne_16(void)
+{
+ if(COND_NE())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_beq_16(void)
+{
+ if(COND_EQ())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bvc_16(void)
+{
+ if(COND_VC())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bvs_16(void)
+{
+ if(COND_VS())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bpl_16(void)
+{
+ if(COND_PL())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bmi_16(void)
+{
+ if(COND_MI())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bge_16(void)
+{
+ if(COND_GE())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_blt_16(void)
+{
+ if(COND_LT())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bgt_16(void)
+{
+ if(COND_GT())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_ble_16(void)
+{
+ if(COND_LE())
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_BCC_NOTAKE_W);
+}
+
+
+static void m68k_op_bhi_32(void)
+{
+ if(COND_HI())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bls_32(void)
+{
+ if(COND_LS())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bcc_32(void)
+{
+ if(COND_CC())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bcs_32(void)
+{
+ if(COND_CS())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bne_32(void)
+{
+ if(COND_NE())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_beq_32(void)
+{
+ if(COND_EQ())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bvc_32(void)
+{
+ if(COND_VC())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bvs_32(void)
+{
+ if(COND_VS())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bpl_32(void)
+{
+ if(COND_PL())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bmi_32(void)
+{
+ if(COND_MI())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bge_32(void)
+{
+ if(COND_GE())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_blt_32(void)
+{
+ if(COND_LT())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bgt_32(void)
+{
+ if(COND_GT())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_ble_32(void)
+{
+ if(COND_LE())
+ {
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+ return;
+ }
+ USE_CYCLES(CYC_BCC_NOTAKE_B);
+}
+
+
+static void m68k_op_bchg_32_r_d(void)
+{
+ uint* r_dst = &DY;
+ uint mask = 1 << (DX & 0x1f);
+
+ FLAG_Z = *r_dst & mask;
+ *r_dst ^= mask;
+}
+
+
+static void m68k_op_bchg_8_r_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_r_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_r_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_r_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_r_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_r_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_r_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_r_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_r_al(void)
+{
+ uint ea = EA_AL_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_32_s_d(void)
+{
+ uint* r_dst = &DY;
+ uint mask = 1 << (OPER_I_8() & 0x1f);
+
+ FLAG_Z = *r_dst & mask;
+ *r_dst ^= mask;
+}
+
+
+static void m68k_op_bchg_8_s_ai(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_AI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_s_pi(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_PI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_s_pi7(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_A7_PI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_s_pd(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_PD_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_s_pd7(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_A7_PD_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_s_di(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_DI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_s_ix(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_IX_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_s_aw(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AW_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bchg_8_s_al(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AL_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src ^ mask);
+}
+
+
+static void m68k_op_bclr_32_r_d(void)
+{
+ uint* r_dst = &DY;
+ uint mask = 1 << (DX & 0x1f);
+
+ FLAG_Z = *r_dst & mask;
+ *r_dst &= ~mask;
+}
+
+
+static void m68k_op_bclr_8_r_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_r_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_r_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_r_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_r_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_r_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_r_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_r_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_r_al(void)
+{
+ uint ea = EA_AL_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_32_s_d(void)
+{
+ uint* r_dst = &DY;
+ uint mask = 1 << (OPER_I_8() & 0x1f);
+
+ FLAG_Z = *r_dst & mask;
+ *r_dst &= ~mask;
+}
+
+
+static void m68k_op_bclr_8_s_ai(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_AI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_s_pi(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_PI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_s_pi7(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_A7_PI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_s_pd(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_PD_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_s_pd7(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_A7_PD_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_s_di(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_DI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_s_ix(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_IX_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_s_aw(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AW_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bclr_8_s_al(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AL_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src & ~mask);
+}
+
+
+static void m68k_op_bra_8(void)
+{
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+}
+
+
+static void m68k_op_bra_16(void)
+{
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+}
+
+
+static void m68k_op_bra_32(void)
+{
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+}
+
+
+static void m68k_op_bset_32_r_d(void)
+{
+ uint* r_dst = &DY;
+ uint mask = 1 << (DX & 0x1f);
+
+ FLAG_Z = *r_dst & mask;
+ *r_dst |= mask;
+}
+
+
+static void m68k_op_bset_8_r_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_r_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_r_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_r_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_r_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_r_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_r_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_r_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_r_al(void)
+{
+ uint ea = EA_AL_8();
+ uint src = m68ki_read_8(ea);
+ uint mask = 1 << (DX & 7);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_32_s_d(void)
+{
+ uint* r_dst = &DY;
+ uint mask = 1 << (OPER_I_8() & 0x1f);
+
+ FLAG_Z = *r_dst & mask;
+ *r_dst |= mask;
+}
+
+
+static void m68k_op_bset_8_s_ai(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_AI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_s_pi(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_PI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_s_pi7(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_A7_PI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_s_pd(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_PD_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_s_pd7(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_A7_PD_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_s_di(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_DI_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_s_ix(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AY_IX_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_s_aw(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AW_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bset_8_s_al(void)
+{
+ uint mask = 1 << (OPER_I_8() & 7);
+ uint ea = EA_AL_8();
+ uint src = m68ki_read_8(ea);
+
+ FLAG_Z = src & mask;
+ m68ki_write_8(ea, src | mask);
+}
+
+
+static void m68k_op_bsr_8(void)
+{
+ m68ki_push_32(REG_PC);
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+}
+
+
+static void m68k_op_bsr_16(void)
+{
+ uint offset = OPER_I_16();
+ m68ki_push_32(REG_PC);
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+}
+
+
+static void m68k_op_bsr_32(void)
+{
+ m68ki_push_32(REG_PC);
+ m68ki_branch_8(MASK_OUT_ABOVE_8(REG_IR));
+}
+
+
+static void m68k_op_btst_32_r_d(void)
+{
+ FLAG_Z = DY & (1 << (DX & 0x1f));
+}
+
+
+static void m68k_op_btst_8_r_ai(void)
+{
+ FLAG_Z = OPER_AY_AI_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_pi(void)
+{
+ FLAG_Z = OPER_AY_PI_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_pi7(void)
+{
+ FLAG_Z = OPER_A7_PI_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_pd(void)
+{
+ FLAG_Z = OPER_AY_PD_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_pd7(void)
+{
+ FLAG_Z = OPER_A7_PD_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_di(void)
+{
+ FLAG_Z = OPER_AY_DI_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_ix(void)
+{
+ FLAG_Z = OPER_AY_IX_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_aw(void)
+{
+ FLAG_Z = OPER_AW_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_al(void)
+{
+ FLAG_Z = OPER_AL_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_pcdi(void)
+{
+ FLAG_Z = OPER_PCDI_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_pcix(void)
+{
+ FLAG_Z = OPER_PCIX_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_8_r_i(void)
+{
+ FLAG_Z = OPER_I_8() & (1 << (DX & 7));
+}
+
+
+static void m68k_op_btst_32_s_d(void)
+{
+ FLAG_Z = DY & (1 << (OPER_I_8() & 0x1f));
+}
+
+
+static void m68k_op_btst_8_s_ai(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_AY_AI_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_pi(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_AY_PI_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_pi7(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_A7_PI_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_pd(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_AY_PD_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_pd7(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_A7_PD_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_di(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_AY_DI_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_ix(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_AY_IX_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_aw(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_AW_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_al(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_AL_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_pcdi(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_PCDI_8() & (1 << bit);
+}
+
+
+static void m68k_op_btst_8_s_pcix(void)
+{
+ uint bit = OPER_I_8() & 7;
+
+ FLAG_Z = OPER_PCIX_8() & (1 << bit);
+}
+
+
+static void m68k_op_chk_16_d(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(DY);
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_ai(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_AY_AI_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_pi(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_AY_PI_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_pd(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_AY_PD_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_di(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_AY_DI_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_ix(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_AY_IX_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_aw(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_AW_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_al(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_AL_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_pcdi(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_PCDI_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_pcix(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_PCIX_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_chk_16_i(void)
+{
+ sint src = MAKE_INT_16(DX);
+ sint bound = MAKE_INT_16(OPER_I_16());
+
+ FLAG_Z = ZFLAG_16(src); /* Undocumented */
+ FLAG_V = VFLAG_CLEAR; /* Undocumented */
+ FLAG_C = CFLAG_CLEAR; /* Undocumented */
+
+ if(src >= 0 && src <= bound)
+ {
+ return;
+ }
+ FLAG_N = (src < 0)<<7;
+ m68ki_exception_trap(EXCEPTION_CHK);
+}
+
+
+static void m68k_op_clr_8_d(void)
+{
+ DY &= 0xffffff00;
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_16_d(void)
+{
+ DY &= 0xffff0000;
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_16_ai(void)
+{
+ m68ki_write_16(EA_AY_AI_16(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_16_pi(void)
+{
+ m68ki_write_16(EA_AY_PI_16(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_16_pd(void)
+{
+ m68ki_write_16(EA_AY_PD_16(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_16_di(void)
+{
+ m68ki_write_16(EA_AY_DI_16(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_16_ix(void)
+{
+ m68ki_write_16(EA_AY_IX_16(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_16_aw(void)
+{
+ m68ki_write_16(EA_AW_16(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_16_al(void)
+{
+ m68ki_write_16(EA_AL_16(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_32_d(void)
+{
+ DY = 0;
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_32_ai(void)
+{
+ m68ki_write_32(EA_AY_AI_32(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_32_pi(void)
+{
+ m68ki_write_32(EA_AY_PI_32(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_32_pd(void)
+{
+ m68ki_write_32(EA_AY_PD_32(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_32_di(void)
+{
+ m68ki_write_32(EA_AY_DI_32(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_32_ix(void)
+{
+ m68ki_write_32(EA_AY_IX_32(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_32_aw(void)
+{
+ m68ki_write_32(EA_AW_32(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_clr_32_al(void)
+{
+ m68ki_write_32(EA_AL_32(), 0);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+}
+
+
+static void m68k_op_cmp_8_d(void)
+{
+ uint src = MASK_OUT_ABOVE_8(DY);
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_ai(void)
+{
+ uint src = OPER_AY_AI_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_pi(void)
+{
+ uint src = OPER_AY_PI_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_pi7(void)
+{
+ uint src = OPER_A7_PI_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_pd(void)
+{
+ uint src = OPER_AY_PD_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_pd7(void)
+{
+ uint src = OPER_A7_PD_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_di(void)
+{
+ uint src = OPER_AY_DI_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_ix(void)
+{
+ uint src = OPER_AY_IX_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_aw(void)
+{
+ uint src = OPER_AW_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_al(void)
+{
+ uint src = OPER_AL_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_pcdi(void)
+{
+ uint src = OPER_PCDI_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_pcix(void)
+{
+ uint src = OPER_PCIX_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_8_i(void)
+{
+ uint src = OPER_I_8();
+ uint dst = MASK_OUT_ABOVE_8(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmp_16_d(void)
+{
+ uint src = MASK_OUT_ABOVE_16(DY);
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_a(void)
+{
+ uint src = MASK_OUT_ABOVE_16(AY);
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_ai(void)
+{
+ uint src = OPER_AY_AI_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_pi(void)
+{
+ uint src = OPER_AY_PI_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_pd(void)
+{
+ uint src = OPER_AY_PD_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_di(void)
+{
+ uint src = OPER_AY_DI_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_ix(void)
+{
+ uint src = OPER_AY_IX_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_aw(void)
+{
+ uint src = OPER_AW_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_al(void)
+{
+ uint src = OPER_AL_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_pcdi(void)
+{
+ uint src = OPER_PCDI_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_pcix(void)
+{
+ uint src = OPER_PCIX_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_16_i(void)
+{
+ uint src = OPER_I_16();
+ uint dst = MASK_OUT_ABOVE_16(DX);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmp_32_d(void)
+{
+ uint src = DY;
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_a(void)
+{
+ uint src = AY;
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_ai(void)
+{
+ uint src = OPER_AY_AI_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_pi(void)
+{
+ uint src = OPER_AY_PI_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_pd(void)
+{
+ uint src = OPER_AY_PD_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_di(void)
+{
+ uint src = OPER_AY_DI_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_ix(void)
+{
+ uint src = OPER_AY_IX_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_aw(void)
+{
+ uint src = OPER_AW_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_al(void)
+{
+ uint src = OPER_AL_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_pcdi(void)
+{
+ uint src = OPER_PCDI_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_pcix(void)
+{
+ uint src = OPER_PCIX_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmp_32_i(void)
+{
+ uint src = OPER_I_32();
+ uint dst = DX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_d(void)
+{
+ uint src = MAKE_INT_16(DY);
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_a(void)
+{
+ uint src = MAKE_INT_16(AY);
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_ai(void)
+{
+ uint src = MAKE_INT_16(OPER_AY_AI_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_pi(void)
+{
+ uint src = MAKE_INT_16(OPER_AY_PI_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_pd(void)
+{
+ uint src = MAKE_INT_16(OPER_AY_PD_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_di(void)
+{
+ uint src = MAKE_INT_16(OPER_AY_DI_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_ix(void)
+{
+ uint src = MAKE_INT_16(OPER_AY_IX_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_aw(void)
+{
+ uint src = MAKE_INT_16(OPER_AW_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_al(void)
+{
+ uint src = MAKE_INT_16(OPER_AL_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_pcdi(void)
+{
+ uint src = MAKE_INT_16(OPER_PCDI_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_pcix(void)
+{
+ uint src = MAKE_INT_16(OPER_PCIX_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_16_i(void)
+{
+ uint src = MAKE_INT_16(OPER_I_16());
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_d(void)
+{
+ uint src = DY;
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_a(void)
+{
+ uint src = AY;
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_ai(void)
+{
+ uint src = OPER_AY_AI_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_pi(void)
+{
+ uint src = OPER_AY_PI_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_pd(void)
+{
+ uint src = OPER_AY_PD_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_di(void)
+{
+ uint src = OPER_AY_DI_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_ix(void)
+{
+ uint src = OPER_AY_IX_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_aw(void)
+{
+ uint src = OPER_AW_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_al(void)
+{
+ uint src = OPER_AL_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_pcdi(void)
+{
+ uint src = OPER_PCDI_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_pcix(void)
+{
+ uint src = OPER_PCIX_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpa_32_i(void)
+{
+ uint src = OPER_I_32();
+ uint dst = AX;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpi_8_d(void)
+{
+ uint src = OPER_I_8();
+ uint dst = MASK_OUT_ABOVE_8(DY);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_8_ai(void)
+{
+ uint src = OPER_I_8();
+ uint dst = OPER_AY_AI_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_8_pi(void)
+{
+ uint src = OPER_I_8();
+ uint dst = OPER_AY_PI_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_8_pi7(void)
+{
+ uint src = OPER_I_8();
+ uint dst = OPER_A7_PI_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_8_pd(void)
+{
+ uint src = OPER_I_8();
+ uint dst = OPER_AY_PD_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_8_pd7(void)
+{
+ uint src = OPER_I_8();
+ uint dst = OPER_A7_PD_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_8_di(void)
+{
+ uint src = OPER_I_8();
+ uint dst = OPER_AY_DI_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_8_ix(void)
+{
+ uint src = OPER_I_8();
+ uint dst = OPER_AY_IX_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_8_aw(void)
+{
+ uint src = OPER_I_8();
+ uint dst = OPER_AW_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_8_al(void)
+{
+ uint src = OPER_I_8();
+ uint dst = OPER_AL_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpi_16_d(void)
+{
+ uint src = OPER_I_16();
+ uint dst = MASK_OUT_ABOVE_16(DY);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmpi_16_ai(void)
+{
+ uint src = OPER_I_16();
+ uint dst = OPER_AY_AI_16();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmpi_16_pi(void)
+{
+ uint src = OPER_I_16();
+ uint dst = OPER_AY_PI_16();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmpi_16_pd(void)
+{
+ uint src = OPER_I_16();
+ uint dst = OPER_AY_PD_16();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmpi_16_di(void)
+{
+ uint src = OPER_I_16();
+ uint dst = OPER_AY_DI_16();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmpi_16_ix(void)
+{
+ uint src = OPER_I_16();
+ uint dst = OPER_AY_IX_16();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmpi_16_aw(void)
+{
+ uint src = OPER_I_16();
+ uint dst = OPER_AW_16();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmpi_16_al(void)
+{
+ uint src = OPER_I_16();
+ uint dst = OPER_AL_16();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmpi_32_d(void)
+{
+ uint src = OPER_I_32();
+ uint dst = DY;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpi_32_ai(void)
+{
+ uint src = OPER_I_32();
+ uint dst = OPER_AY_AI_32();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpi_32_pi(void)
+{
+ uint src = OPER_I_32();
+ uint dst = OPER_AY_PI_32();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpi_32_pd(void)
+{
+ uint src = OPER_I_32();
+ uint dst = OPER_AY_PD_32();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpi_32_di(void)
+{
+ uint src = OPER_I_32();
+ uint dst = OPER_AY_DI_32();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpi_32_ix(void)
+{
+ uint src = OPER_I_32();
+ uint dst = OPER_AY_IX_32();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpi_32_aw(void)
+{
+ uint src = OPER_I_32();
+ uint dst = OPER_AW_32();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpi_32_al(void)
+{
+ uint src = OPER_I_32();
+ uint dst = OPER_AL_32();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_cmpm_8_ax7(void)
+{
+ uint src = OPER_AY_PI_8();
+ uint dst = OPER_A7_PI_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpm_8_ay7(void)
+{
+ uint src = OPER_A7_PI_8();
+ uint dst = OPER_AX_PI_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpm_8_axy7(void)
+{
+ uint src = OPER_A7_PI_8();
+ uint dst = OPER_A7_PI_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpm_8(void)
+{
+ uint src = OPER_AY_PI_8();
+ uint dst = OPER_AX_PI_8();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_C = CFLAG_8(res);
+}
+
+
+static void m68k_op_cmpm_16(void)
+{
+ uint src = OPER_AY_PI_16();
+ uint dst = OPER_AX_PI_16();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_C = CFLAG_16(res);
+}
+
+
+static void m68k_op_cmpm_32(void)
+{
+ uint src = OPER_AY_PI_32();
+ uint dst = OPER_AX_PI_32();
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_C = CFLAG_SUB_32(src, dst, res);
+}
+
+
+static void m68k_op_dbt_16(void)
+{
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbf_16(void)
+{
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+}
+
+
+static void m68k_op_dbhi_16(void)
+{
+ if(COND_NOT_HI())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbls_16(void)
+{
+ if(COND_NOT_LS())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbcc_16(void)
+{
+ if(COND_NOT_CC())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbcs_16(void)
+{
+ if(COND_NOT_CS())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbne_16(void)
+{
+ if(COND_NOT_NE())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbeq_16(void)
+{
+ if(COND_NOT_EQ())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbvc_16(void)
+{
+ if(COND_NOT_VC())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbvs_16(void)
+{
+ if(COND_NOT_VS())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbpl_16(void)
+{
+ if(COND_NOT_PL())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbmi_16(void)
+{
+ if(COND_NOT_MI())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbge_16(void)
+{
+ if(COND_NOT_GE())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dblt_16(void)
+{
+ if(COND_NOT_LT())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dbgt_16(void)
+{
+ if(COND_NOT_GT())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_dble_16(void)
+{
+ if(COND_NOT_LE())
+ {
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(*r_dst - 1);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ if(res != 0xffff)
+ {
+ uint offset = OPER_I_16();
+ REG_PC -= 2;
+ m68ki_branch_16(offset);
+ USE_CYCLES(CYC_DBCC_F_NOEXP);
+
+ /* reset idle loop detection */
+ m68ki_cpu.poll.detected = 0;
+ return;
+ }
+ REG_PC += 2;
+ USE_CYCLES(CYC_DBCC_F_EXP);
+ return;
+ }
+ REG_PC += 2;
+}
+
+
+static void m68k_op_divs_16_d(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(DY);
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_ai(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_AI_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_pi(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_PI_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_pd(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_PD_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_di(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_DI_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_ix(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_IX_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_aw(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AW_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_al(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AL_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_pcdi(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_PCDI_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_pcix(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_PCIX_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divs_16_i(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_I_16());
+ sint quotient;
+ sint remainder;
+
+ if(src != 0)
+ {
+ UseDivsCycles(*r_dst,src);
+
+ if((uint32)*r_dst == 0x80000000 && src == -1)
+ {
+ FLAG_Z = 0;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = 0;
+ return;
+ }
+
+ quotient = MAKE_INT_32(*r_dst) / src;
+ remainder = MAKE_INT_32(*r_dst) % src;
+
+ if(quotient == MAKE_INT_16(quotient))
+ {
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_d(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_16(DY);
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_ai(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_AI_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_pi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PI_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_pd(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PD_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_di(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_DI_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_ix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_IX_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_aw(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AW_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_al(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AL_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_pcdi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCDI_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_pcix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCIX_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_divu_16_i(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_I_16();
+
+ if(src != 0)
+ {
+ uint quotient = *r_dst / src;
+ uint remainder = *r_dst % src;
+
+ if(quotient < 0x10000)
+ {
+ UseDivuCycles(*r_dst,src);
+ FLAG_Z = quotient;
+ FLAG_N = NFLAG_16(quotient);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst = MASK_OUT_ABOVE_32(MASK_OUT_ABOVE_16(quotient) | (remainder << 16));
+ return;
+ }
+ USE_CYCLES(MUL * 10);
+ FLAG_V = VFLAG_SET;
+ FLAG_N = NFLAG_SET; /* undocumented behavior (fixes Blood Shot on Genesis) */
+ FLAG_C = CFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = CFLAG_CLEAR;
+ m68ki_exception_trap(EXCEPTION_ZERO_DIVIDE);
+}
+
+
+static void m68k_op_eor_8_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY ^= MASK_OUT_ABOVE_8(DX));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_8_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_8_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_8_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_8_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_8_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_8_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_8_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_8_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_8_al(void)
+{
+ uint ea = EA_AL_8();
+ uint res = MASK_OUT_ABOVE_8(DX ^ m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_16_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY ^= MASK_OUT_ABOVE_16(DX));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint res = MASK_OUT_ABOVE_16(DX ^ m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_32_d(void)
+{
+ uint res = DY ^= DX;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_32_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+ uint res = DX ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_32_pi(void)
+{
+ uint ea = EA_AY_PI_32();
+ uint res = DX ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_32_pd(void)
+{
+ uint ea = EA_AY_PD_32();
+ uint res = DX ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_32_di(void)
+{
+ uint ea = EA_AY_DI_32();
+ uint res = DX ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_32_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+ uint res = DX ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_32_aw(void)
+{
+ uint ea = EA_AW_32();
+ uint res = DX ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eor_32_al(void)
+{
+ uint ea = EA_AL_32();
+ uint res = DX ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY ^= OPER_I_8());
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_ai(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_AI_8();
+ uint res = src ^ m68ki_read_8(ea);
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_pi(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PI_8();
+ uint res = src ^ m68ki_read_8(ea);
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_pi7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PI_8();
+ uint res = src ^ m68ki_read_8(ea);
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_pd(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PD_8();
+ uint res = src ^ m68ki_read_8(ea);
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_pd7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PD_8();
+ uint res = src ^ m68ki_read_8(ea);
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_di(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_DI_8();
+ uint res = src ^ m68ki_read_8(ea);
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_ix(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_IX_8();
+ uint res = src ^ m68ki_read_8(ea);
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_aw(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AW_8();
+ uint res = src ^ m68ki_read_8(ea);
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_8_al(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AL_8();
+ uint res = src ^ m68ki_read_8(ea);
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_16_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY ^= OPER_I_16());
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_16_ai(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_AI_16();
+ uint res = src ^ m68ki_read_16(ea);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_16_pi(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PI_16();
+ uint res = src ^ m68ki_read_16(ea);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_16_pd(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PD_16();
+ uint res = src ^ m68ki_read_16(ea);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_16_di(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_DI_16();
+ uint res = src ^ m68ki_read_16(ea);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_16_ix(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_IX_16();
+ uint res = src ^ m68ki_read_16(ea);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_16_aw(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AW_16();
+ uint res = src ^ m68ki_read_16(ea);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_16_al(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AL_16();
+ uint res = src ^ m68ki_read_16(ea);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_32_d(void)
+{
+ uint res = DY ^= OPER_I_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_32_ai(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_AI_32();
+ uint res = src ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_32_pi(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PI_32();
+ uint res = src ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_32_pd(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PD_32();
+ uint res = src ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_32_di(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_DI_32();
+ uint res = src ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_32_ix(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_IX_32();
+ uint res = src ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_32_aw(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AW_32();
+ uint res = src ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_32_al(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AL_32();
+ uint res = src ^ m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_eori_16_toc(void)
+{
+ m68ki_set_ccr(m68ki_get_ccr() ^ OPER_I_16());
+}
+
+
+static void m68k_op_eori_16_tos(void)
+{
+ if(FLAG_S)
+ {
+ uint src = OPER_I_16();
+ m68ki_set_sr(m68ki_get_sr() ^ src);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_exg_32_dd(void)
+{
+ uint* reg_a = &DX;
+ uint* reg_b = &DY;
+ uint tmp = *reg_a;
+ *reg_a = *reg_b;
+ *reg_b = tmp;
+}
+
+
+static void m68k_op_exg_32_aa(void)
+{
+ uint* reg_a = &AX;
+ uint* reg_b = &AY;
+ uint tmp = *reg_a;
+ *reg_a = *reg_b;
+ *reg_b = tmp;
+}
+
+
+static void m68k_op_exg_32_da(void)
+{
+ uint* reg_a = &DX;
+ uint* reg_b = &AY;
+ uint tmp = *reg_a;
+ *reg_a = *reg_b;
+ *reg_b = tmp;
+}
+
+
+static void m68k_op_ext_16(void)
+{
+ uint* r_dst = &DY;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | MASK_OUT_ABOVE_8(*r_dst) | (GET_MSB_8(*r_dst) ? 0xff00 : 0);
+
+ FLAG_N = NFLAG_16(*r_dst);
+ FLAG_Z = MASK_OUT_ABOVE_16(*r_dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_ext_32(void)
+{
+ uint* r_dst = &DY;
+
+ *r_dst = MASK_OUT_ABOVE_16(*r_dst) | (GET_MSB_16(*r_dst) ? 0xffff0000 : 0);
+
+ FLAG_N = NFLAG_32(*r_dst);
+ FLAG_Z = *r_dst;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_illegal(void)
+{
+ m68ki_exception_illegal();
+}
+
+
+static void m68k_op_jmp_32_ai(void)
+{
+ m68ki_jump(EA_AY_AI_32());
+}
+
+
+static void m68k_op_jmp_32_di(void)
+{
+ m68ki_jump(EA_AY_DI_32());
+}
+
+
+static void m68k_op_jmp_32_ix(void)
+{
+ m68ki_jump(EA_AY_IX_32());
+}
+
+
+static void m68k_op_jmp_32_aw(void)
+{
+ m68ki_jump(EA_AW_32());
+}
+
+
+static void m68k_op_jmp_32_al(void)
+{
+ m68ki_jump(EA_AL_32());
+}
+
+
+static void m68k_op_jmp_32_pcdi(void)
+{
+ m68ki_jump(EA_PCDI_32());
+}
+
+
+static void m68k_op_jmp_32_pcix(void)
+{
+ m68ki_jump(EA_PCIX_32());
+}
+
+
+static void m68k_op_jsr_32_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+ m68ki_push_32(REG_PC);
+ m68ki_jump(ea);
+}
+
+
+static void m68k_op_jsr_32_di(void)
+{
+ uint ea = EA_AY_DI_32();
+ m68ki_push_32(REG_PC);
+ m68ki_jump(ea);
+}
+
+
+static void m68k_op_jsr_32_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+ m68ki_push_32(REG_PC);
+ m68ki_jump(ea);
+}
+
+
+static void m68k_op_jsr_32_aw(void)
+{
+ uint ea = EA_AW_32();
+ m68ki_push_32(REG_PC);
+ m68ki_jump(ea);
+}
+
+
+static void m68k_op_jsr_32_al(void)
+{
+ uint ea = EA_AL_32();
+ m68ki_push_32(REG_PC);
+ m68ki_jump(ea);
+}
+
+
+static void m68k_op_jsr_32_pcdi(void)
+{
+ uint ea = EA_PCDI_32();
+ m68ki_push_32(REG_PC);
+ m68ki_jump(ea);
+}
+
+
+static void m68k_op_jsr_32_pcix(void)
+{
+ uint ea = EA_PCIX_32();
+ m68ki_push_32(REG_PC);
+ m68ki_jump(ea);
+}
+
+
+static void m68k_op_lea_32_ai(void)
+{
+ AX = EA_AY_AI_32();
+}
+
+
+static void m68k_op_lea_32_di(void)
+{
+ AX = EA_AY_DI_32();
+}
+
+
+static void m68k_op_lea_32_ix(void)
+{
+ AX = EA_AY_IX_32();
+}
+
+
+static void m68k_op_lea_32_aw(void)
+{
+ AX = EA_AW_32();
+}
+
+
+static void m68k_op_lea_32_al(void)
+{
+ AX = EA_AL_32();
+}
+
+
+static void m68k_op_lea_32_pcdi(void)
+{
+ AX = EA_PCDI_32();
+}
+
+
+static void m68k_op_lea_32_pcix(void)
+{
+ AX = EA_PCIX_32();
+}
+
+
+static void m68k_op_link_16_a7(void)
+{
+ REG_A[7] -= 4;
+ m68ki_write_32(REG_A[7], REG_A[7]);
+ REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16()));
+}
+
+
+static void m68k_op_link_16(void)
+{
+ uint* r_dst = &AY;
+
+ m68ki_push_32(*r_dst);
+ *r_dst = REG_A[7];
+ REG_A[7] = MASK_OUT_ABOVE_32(REG_A[7] + MAKE_INT_16(OPER_I_16()));
+}
+
+
+static void m68k_op_lsr_8_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src >> shift;
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src << (9-shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_16_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src >> shift;
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src << (9-shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_32_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = *r_dst;
+ uint res = src >> shift;
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src << (9-shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_8_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = src >> shift;
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift <= 8)
+ {
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+ FLAG_X = FLAG_C = src << (9-shift);
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ *r_dst &= 0xffffff00;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_8(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_16_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = src >> shift;
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift <= 16)
+ {
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ FLAG_C = FLAG_X = (src >> (shift - 1))<<8;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ *r_dst &= 0xffff0000;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_16(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_32_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = *r_dst;
+ uint res = src >> shift;
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift < 32)
+ {
+ *r_dst = res;
+ FLAG_C = FLAG_X = (src >> (shift - 1))<<8;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ *r_dst = 0;
+ FLAG_X = FLAG_C = (shift == 32 ? GET_MSB_32(src)>>23 : 0);
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_32(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_C = FLAG_X = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_C = FLAG_X = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_C = FLAG_X = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_C = FLAG_X = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_C = FLAG_X = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_C = FLAG_X = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsr_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = src >> 1;
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = res;
+ FLAG_C = FLAG_X = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_8_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = MASK_OUT_ABOVE_8(src << shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src << shift;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_16_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = MASK_OUT_ABOVE_16(src << shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> (8-shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_32_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = *r_dst;
+ uint res = MASK_OUT_ABOVE_32(src << shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> (24-shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_8_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = MASK_OUT_ABOVE_8(src << shift);
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift <= 8)
+ {
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+ FLAG_X = FLAG_C = src << shift;
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ *r_dst &= 0xffffff00;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_8(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_16_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = MASK_OUT_ABOVE_16(src << shift);
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift <= 16)
+ {
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ FLAG_X = FLAG_C = (src << shift) >> 8;
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ *r_dst &= 0xffff0000;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_16(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_32_r(void)
+{
+ uint* r_dst = &DY;
+ uint shift = DX & 0x3f;
+ uint src = *r_dst;
+ uint res = MASK_OUT_ABOVE_32(src << shift);
+
+ if(shift != 0)
+ {
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ if(shift < 32)
+ {
+ *r_dst = res;
+ FLAG_X = FLAG_C = (src >> (32 - shift)) << 8;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ *r_dst = 0;
+ FLAG_X = FLAG_C = ((shift == 32 ? src & 1 : 0))<<8;
+ FLAG_N = NFLAG_CLEAR;
+ FLAG_Z = ZFLAG_SET;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_32(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_lsl_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(src << 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_X = FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_al(void)
+{
+ uint res = OPER_AL_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_d_i(void)
+{
+ uint res = OPER_I_8();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_8_ai_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_al(void)
+{
+ uint res = OPER_AL_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ai_i(void)
+{
+ uint res = OPER_I_8();
+ uint ea = EA_AX_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_al(void)
+{
+ uint res = OPER_AL_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi7_i(void)
+{
+ uint res = OPER_I_8();
+ uint ea = EA_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_al(void)
+{
+ uint res = OPER_AL_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pi_i(void)
+{
+ uint res = OPER_I_8();
+ uint ea = EA_AX_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_al(void)
+{
+ uint res = OPER_AL_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd7_i(void)
+{
+ uint res = OPER_I_8();
+ uint ea = EA_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_al(void)
+{
+ uint res = OPER_AL_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_pd_i(void)
+{
+ uint res = OPER_I_8();
+ uint ea = EA_AX_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_al(void)
+{
+ uint res = OPER_AL_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_di_i(void)
+{
+ uint res = OPER_I_8();
+ uint ea = EA_AX_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_al(void)
+{
+ uint res = OPER_AL_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_ix_i(void)
+{
+ uint res = OPER_I_8();
+ uint ea = EA_AX_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_al(void)
+{
+ uint res = OPER_AL_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_aw_i(void)
+{
+ uint res = OPER_I_8();
+ uint ea = EA_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_di(void)
+{
+ uint res = OPER_AY_DI_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_aw(void)
+{
+ uint res = OPER_AW_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_al(void)
+{
+ uint res = OPER_AL_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_pcdi(void)
+{
+ uint res = OPER_PCDI_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_pcix(void)
+{
+ uint res = OPER_PCIX_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_8_al_i(void)
+{
+ uint res = OPER_I_8();
+ uint ea = EA_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_move_16_d_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY);
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_a(void)
+{
+ uint res = MASK_OUT_ABOVE_16(AY);
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_ai(void)
+{
+ uint res = OPER_AY_AI_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_pi(void)
+{
+ uint res = OPER_AY_PI_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_pd(void)
+{
+ uint res = OPER_AY_PD_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_di(void)
+{
+ uint res = OPER_AY_DI_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_ix(void)
+{
+ uint res = OPER_AY_IX_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_aw(void)
+{
+ uint res = OPER_AW_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_al(void)
+{
+ uint res = OPER_AL_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_pcdi(void)
+{
+ uint res = OPER_PCDI_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_pcix(void)
+{
+ uint res = OPER_PCIX_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_d_i(void)
+{
+ uint res = OPER_I_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_16_ai_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY);
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_a(void)
+{
+ uint res = MASK_OUT_ABOVE_16(AY);
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_ai(void)
+{
+ uint res = OPER_AY_AI_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_pi(void)
+{
+ uint res = OPER_AY_PI_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_pd(void)
+{
+ uint res = OPER_AY_PD_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_di(void)
+{
+ uint res = OPER_AY_DI_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_ix(void)
+{
+ uint res = OPER_AY_IX_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_aw(void)
+{
+ uint res = OPER_AW_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_al(void)
+{
+ uint res = OPER_AL_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_pcdi(void)
+{
+ uint res = OPER_PCDI_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_pcix(void)
+{
+ uint res = OPER_PCIX_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ai_i(void)
+{
+ uint res = OPER_I_16();
+ uint ea = EA_AX_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY);
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_a(void)
+{
+ uint res = MASK_OUT_ABOVE_16(AY);
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_ai(void)
+{
+ uint res = OPER_AY_AI_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_pi(void)
+{
+ uint res = OPER_AY_PI_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_pd(void)
+{
+ uint res = OPER_AY_PD_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_di(void)
+{
+ uint res = OPER_AY_DI_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_ix(void)
+{
+ uint res = OPER_AY_IX_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_aw(void)
+{
+ uint res = OPER_AW_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_al(void)
+{
+ uint res = OPER_AL_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_pcdi(void)
+{
+ uint res = OPER_PCDI_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_pcix(void)
+{
+ uint res = OPER_PCIX_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pi_i(void)
+{
+ uint res = OPER_I_16();
+ uint ea = EA_AX_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY);
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_a(void)
+{
+ uint res = MASK_OUT_ABOVE_16(AY);
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_ai(void)
+{
+ uint res = OPER_AY_AI_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_pi(void)
+{
+ uint res = OPER_AY_PI_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_pd(void)
+{
+ uint res = OPER_AY_PD_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_di(void)
+{
+ uint res = OPER_AY_DI_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_ix(void)
+{
+ uint res = OPER_AY_IX_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_aw(void)
+{
+ uint res = OPER_AW_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_al(void)
+{
+ uint res = OPER_AL_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_pcdi(void)
+{
+ uint res = OPER_PCDI_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_pcix(void)
+{
+ uint res = OPER_PCIX_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_pd_i(void)
+{
+ uint res = OPER_I_16();
+ uint ea = EA_AX_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY);
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_a(void)
+{
+ uint res = MASK_OUT_ABOVE_16(AY);
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_ai(void)
+{
+ uint res = OPER_AY_AI_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_pi(void)
+{
+ uint res = OPER_AY_PI_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_pd(void)
+{
+ uint res = OPER_AY_PD_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_di(void)
+{
+ uint res = OPER_AY_DI_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_ix(void)
+{
+ uint res = OPER_AY_IX_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_aw(void)
+{
+ uint res = OPER_AW_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_al(void)
+{
+ uint res = OPER_AL_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_pcdi(void)
+{
+ uint res = OPER_PCDI_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_pcix(void)
+{
+ uint res = OPER_PCIX_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_di_i(void)
+{
+ uint res = OPER_I_16();
+ uint ea = EA_AX_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY);
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_a(void)
+{
+ uint res = MASK_OUT_ABOVE_16(AY);
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_ai(void)
+{
+ uint res = OPER_AY_AI_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_pi(void)
+{
+ uint res = OPER_AY_PI_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_pd(void)
+{
+ uint res = OPER_AY_PD_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_di(void)
+{
+ uint res = OPER_AY_DI_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_ix(void)
+{
+ uint res = OPER_AY_IX_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_aw(void)
+{
+ uint res = OPER_AW_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_al(void)
+{
+ uint res = OPER_AL_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_pcdi(void)
+{
+ uint res = OPER_PCDI_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_pcix(void)
+{
+ uint res = OPER_PCIX_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_ix_i(void)
+{
+ uint res = OPER_I_16();
+ uint ea = EA_AX_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY);
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_a(void)
+{
+ uint res = MASK_OUT_ABOVE_16(AY);
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_ai(void)
+{
+ uint res = OPER_AY_AI_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_pi(void)
+{
+ uint res = OPER_AY_PI_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_pd(void)
+{
+ uint res = OPER_AY_PD_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_di(void)
+{
+ uint res = OPER_AY_DI_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_ix(void)
+{
+ uint res = OPER_AY_IX_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_aw(void)
+{
+ uint res = OPER_AW_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_al(void)
+{
+ uint res = OPER_AL_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_pcdi(void)
+{
+ uint res = OPER_PCDI_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_pcix(void)
+{
+ uint res = OPER_PCIX_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_aw_i(void)
+{
+ uint res = OPER_I_16();
+ uint ea = EA_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY);
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_a(void)
+{
+ uint res = MASK_OUT_ABOVE_16(AY);
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_ai(void)
+{
+ uint res = OPER_AY_AI_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_pi(void)
+{
+ uint res = OPER_AY_PI_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_pd(void)
+{
+ uint res = OPER_AY_PD_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_di(void)
+{
+ uint res = OPER_AY_DI_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_ix(void)
+{
+ uint res = OPER_AY_IX_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_aw(void)
+{
+ uint res = OPER_AW_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_al(void)
+{
+ uint res = OPER_AL_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_pcdi(void)
+{
+ uint res = OPER_PCDI_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_pcix(void)
+{
+ uint res = OPER_PCIX_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_16_al_i(void)
+{
+ uint res = OPER_I_16();
+ uint ea = EA_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_move_32_d_d(void)
+{
+ uint res = DY;
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_a(void)
+{
+ uint res = AY;
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_ai(void)
+{
+ uint res = OPER_AY_AI_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_pi(void)
+{
+ uint res = OPER_AY_PI_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_pd(void)
+{
+ uint res = OPER_AY_PD_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_di(void)
+{
+ uint res = OPER_AY_DI_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_ix(void)
+{
+ uint res = OPER_AY_IX_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_aw(void)
+{
+ uint res = OPER_AW_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_al(void)
+{
+ uint res = OPER_AL_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_pcdi(void)
+{
+ uint res = OPER_PCDI_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_pcix(void)
+{
+ uint res = OPER_PCIX_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_d_i(void)
+{
+ uint res = OPER_I_32();
+ uint* r_dst = &DX;
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_move_32_ai_d(void)
+{
+ uint res = DY;
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_a(void)
+{
+ uint res = AY;
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_ai(void)
+{
+ uint res = OPER_AY_AI_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_pi(void)
+{
+ uint res = OPER_AY_PI_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_pd(void)
+{
+ uint res = OPER_AY_PD_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_di(void)
+{
+ uint res = OPER_AY_DI_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_ix(void)
+{
+ uint res = OPER_AY_IX_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_aw(void)
+{
+ uint res = OPER_AW_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_al(void)
+{
+ uint res = OPER_AL_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_pcdi(void)
+{
+ uint res = OPER_PCDI_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_pcix(void)
+{
+ uint res = OPER_PCIX_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ai_i(void)
+{
+ uint res = OPER_I_32();
+ uint ea = EA_AX_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_d(void)
+{
+ uint res = DY;
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_a(void)
+{
+ uint res = AY;
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_ai(void)
+{
+ uint res = OPER_AY_AI_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_pi(void)
+{
+ uint res = OPER_AY_PI_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_pd(void)
+{
+ uint res = OPER_AY_PD_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_di(void)
+{
+ uint res = OPER_AY_DI_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_ix(void)
+{
+ uint res = OPER_AY_IX_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_aw(void)
+{
+ uint res = OPER_AW_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_al(void)
+{
+ uint res = OPER_AL_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_pcdi(void)
+{
+ uint res = OPER_PCDI_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_pcix(void)
+{
+ uint res = OPER_PCIX_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pi_i(void)
+{
+ uint res = OPER_I_32();
+ uint ea = EA_AX_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_pd_d(void)
+{
+ uint res = DY;
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_a(void)
+{
+ uint res = AY;
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_ai(void)
+{
+ uint res = OPER_AY_AI_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_pi(void)
+{
+ uint res = OPER_AY_PI_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_pd(void)
+{
+ uint res = OPER_AY_PD_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_di(void)
+{
+ uint res = OPER_AY_DI_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_ix(void)
+{
+ uint res = OPER_AY_IX_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_aw(void)
+{
+ uint res = OPER_AW_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_al(void)
+{
+ uint res = OPER_AL_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_pcdi(void)
+{
+ uint res = OPER_PCDI_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_pcix(void)
+{
+ uint res = OPER_PCIX_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_pd_i(void)
+{
+ uint res = OPER_I_32();
+ uint ea = EA_AX_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_16(ea+2, res & 0xFFFF );
+ m68ki_write_16(ea, (res >> 16) & 0xFFFF );
+}
+
+
+static void m68k_op_move_32_di_d(void)
+{
+ uint res = DY;
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_a(void)
+{
+ uint res = AY;
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_ai(void)
+{
+ uint res = OPER_AY_AI_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_pi(void)
+{
+ uint res = OPER_AY_PI_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_pd(void)
+{
+ uint res = OPER_AY_PD_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_di(void)
+{
+ uint res = OPER_AY_DI_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_ix(void)
+{
+ uint res = OPER_AY_IX_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_aw(void)
+{
+ uint res = OPER_AW_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_al(void)
+{
+ uint res = OPER_AL_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_pcdi(void)
+{
+ uint res = OPER_PCDI_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_pcix(void)
+{
+ uint res = OPER_PCIX_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_di_i(void)
+{
+ uint res = OPER_I_32();
+ uint ea = EA_AX_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_d(void)
+{
+ uint res = DY;
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_a(void)
+{
+ uint res = AY;
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_ai(void)
+{
+ uint res = OPER_AY_AI_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_pi(void)
+{
+ uint res = OPER_AY_PI_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_pd(void)
+{
+ uint res = OPER_AY_PD_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_di(void)
+{
+ uint res = OPER_AY_DI_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_ix(void)
+{
+ uint res = OPER_AY_IX_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_aw(void)
+{
+ uint res = OPER_AW_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_al(void)
+{
+ uint res = OPER_AL_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_pcdi(void)
+{
+ uint res = OPER_PCDI_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_pcix(void)
+{
+ uint res = OPER_PCIX_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_ix_i(void)
+{
+ uint res = OPER_I_32();
+ uint ea = EA_AX_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_d(void)
+{
+ uint res = DY;
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_a(void)
+{
+ uint res = AY;
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_ai(void)
+{
+ uint res = OPER_AY_AI_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_pi(void)
+{
+ uint res = OPER_AY_PI_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_pd(void)
+{
+ uint res = OPER_AY_PD_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_di(void)
+{
+ uint res = OPER_AY_DI_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_ix(void)
+{
+ uint res = OPER_AY_IX_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_aw(void)
+{
+ uint res = OPER_AW_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_al(void)
+{
+ uint res = OPER_AL_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_pcdi(void)
+{
+ uint res = OPER_PCDI_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_pcix(void)
+{
+ uint res = OPER_PCIX_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_aw_i(void)
+{
+ uint res = OPER_I_32();
+ uint ea = EA_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_d(void)
+{
+ uint res = DY;
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_a(void)
+{
+ uint res = AY;
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_ai(void)
+{
+ uint res = OPER_AY_AI_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_pi(void)
+{
+ uint res = OPER_AY_PI_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_pd(void)
+{
+ uint res = OPER_AY_PD_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_di(void)
+{
+ uint res = OPER_AY_DI_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_ix(void)
+{
+ uint res = OPER_AY_IX_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_aw(void)
+{
+ uint res = OPER_AW_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_al(void)
+{
+ uint res = OPER_AL_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_pcdi(void)
+{
+ uint res = OPER_PCDI_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_pcix(void)
+{
+ uint res = OPER_PCIX_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_move_32_al_i(void)
+{
+ uint res = OPER_I_32();
+ uint ea = EA_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_movea_16_d(void)
+{
+ AX = MAKE_INT_16(DY);
+}
+
+
+static void m68k_op_movea_16_a(void)
+{
+ AX = MAKE_INT_16(AY);
+}
+
+
+static void m68k_op_movea_16_ai(void)
+{
+ AX = MAKE_INT_16(OPER_AY_AI_16());
+}
+
+
+static void m68k_op_movea_16_pi(void)
+{
+ AX = MAKE_INT_16(OPER_AY_PI_16());
+}
+
+
+static void m68k_op_movea_16_pd(void)
+{
+ AX = MAKE_INT_16(OPER_AY_PD_16());
+}
+
+
+static void m68k_op_movea_16_di(void)
+{
+ AX = MAKE_INT_16(OPER_AY_DI_16());
+}
+
+
+static void m68k_op_movea_16_ix(void)
+{
+ AX = MAKE_INT_16(OPER_AY_IX_16());
+}
+
+
+static void m68k_op_movea_16_aw(void)
+{
+ AX = MAKE_INT_16(OPER_AW_16());
+}
+
+
+static void m68k_op_movea_16_al(void)
+{
+ AX = MAKE_INT_16(OPER_AL_16());
+}
+
+
+static void m68k_op_movea_16_pcdi(void)
+{
+ AX = MAKE_INT_16(OPER_PCDI_16());
+}
+
+
+static void m68k_op_movea_16_pcix(void)
+{
+ AX = MAKE_INT_16(OPER_PCIX_16());
+}
+
+
+static void m68k_op_movea_16_i(void)
+{
+ AX = MAKE_INT_16(OPER_I_16());
+}
+
+
+static void m68k_op_movea_32_d(void)
+{
+ AX = DY;
+}
+
+
+static void m68k_op_movea_32_a(void)
+{
+ AX = AY;
+}
+
+
+static void m68k_op_movea_32_ai(void)
+{
+ AX = OPER_AY_AI_32();
+}
+
+
+static void m68k_op_movea_32_pi(void)
+{
+ AX = OPER_AY_PI_32();
+}
+
+
+static void m68k_op_movea_32_pd(void)
+{
+ AX = OPER_AY_PD_32();
+}
+
+
+static void m68k_op_movea_32_di(void)
+{
+ AX = OPER_AY_DI_32();
+}
+
+
+static void m68k_op_movea_32_ix(void)
+{
+ AX = OPER_AY_IX_32();
+}
+
+
+static void m68k_op_movea_32_aw(void)
+{
+ AX = OPER_AW_32();
+}
+
+
+static void m68k_op_movea_32_al(void)
+{
+ AX = OPER_AL_32();
+}
+
+
+static void m68k_op_movea_32_pcdi(void)
+{
+ AX = OPER_PCDI_32();
+}
+
+
+static void m68k_op_movea_32_pcix(void)
+{
+ AX = OPER_PCIX_32();
+}
+
+
+static void m68k_op_movea_32_i(void)
+{
+ AX = OPER_I_32();
+}
+
+static void m68k_op_move_16_toc_d(void)
+{
+ m68ki_set_ccr(DY);
+}
+
+
+static void m68k_op_move_16_toc_ai(void)
+{
+ m68ki_set_ccr(OPER_AY_AI_16());
+}
+
+
+static void m68k_op_move_16_toc_pi(void)
+{
+ m68ki_set_ccr(OPER_AY_PI_16());
+}
+
+
+static void m68k_op_move_16_toc_pd(void)
+{
+ m68ki_set_ccr(OPER_AY_PD_16());
+}
+
+
+static void m68k_op_move_16_toc_di(void)
+{
+ m68ki_set_ccr(OPER_AY_DI_16());
+}
+
+
+static void m68k_op_move_16_toc_ix(void)
+{
+ m68ki_set_ccr(OPER_AY_IX_16());
+}
+
+
+static void m68k_op_move_16_toc_aw(void)
+{
+ m68ki_set_ccr(OPER_AW_16());
+}
+
+
+static void m68k_op_move_16_toc_al(void)
+{
+ m68ki_set_ccr(OPER_AL_16());
+}
+
+
+static void m68k_op_move_16_toc_pcdi(void)
+{
+ m68ki_set_ccr(OPER_PCDI_16());
+}
+
+
+static void m68k_op_move_16_toc_pcix(void)
+{
+ m68ki_set_ccr(OPER_PCIX_16());
+}
+
+
+static void m68k_op_move_16_toc_i(void)
+{
+ m68ki_set_ccr(OPER_I_16());
+}
+
+
+static void m68k_op_move_16_frs_d(void)
+{
+ DY = MASK_OUT_BELOW_16(DY) | m68ki_get_sr();
+}
+
+
+static void m68k_op_move_16_frs_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ m68ki_write_16(ea, m68ki_get_sr());
+}
+
+
+static void m68k_op_move_16_frs_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ m68ki_write_16(ea, m68ki_get_sr());
+}
+
+
+static void m68k_op_move_16_frs_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ m68ki_write_16(ea, m68ki_get_sr());
+}
+
+
+static void m68k_op_move_16_frs_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ m68ki_write_16(ea, m68ki_get_sr());
+}
+
+
+static void m68k_op_move_16_frs_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ m68ki_write_16(ea, m68ki_get_sr());
+}
+
+
+static void m68k_op_move_16_frs_aw(void)
+{
+ uint ea = EA_AW_16();
+ m68ki_write_16(ea, m68ki_get_sr());
+}
+
+
+static void m68k_op_move_16_frs_al(void)
+{
+ uint ea = EA_AL_16();
+ m68ki_write_16(ea, m68ki_get_sr());
+}
+
+
+static void m68k_op_move_16_tos_d(void)
+{
+ if(FLAG_S)
+ {
+ m68ki_set_sr(DY);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_ai(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_AY_AI_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_pi(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_AY_PI_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_pd(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_AY_PD_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_di(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_AY_DI_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_ix(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_AY_IX_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_aw(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_AW_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_al(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_AL_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_pcdi(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_PCDI_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_pcix(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_PCIX_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_16_tos_i(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_I_16();
+ m68ki_set_sr(new_sr);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_32_fru(void)
+{
+ if(FLAG_S)
+ {
+ AY = REG_USP;
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_move_32_tou(void)
+{
+ if(FLAG_S)
+ {
+ REG_USP = AY;
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_movem_16_re_pd(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = AY;
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ ea -= 2;
+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[15-i]));
+ count++;
+ }
+ AY = ea;
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_re_ai(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_AI_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_re_di(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_DI_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_re_ix(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_IX_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_re_aw(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AW_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_re_al(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AL_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_16(ea, MASK_OUT_ABOVE_16(REG_DA[i]));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_32_re_pd(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = AY;
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ ea -= 4;
+ m68ki_write_16(ea+2, REG_DA[15-i] & 0xFFFF );
+ m68ki_write_16(ea, (REG_DA[15-i] >> 16) & 0xFFFF );
+ count++;
+ }
+ AY = ea;
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_re_ai(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_AI_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_32(ea, REG_DA[i]);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_re_di(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_DI_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_32(ea, REG_DA[i]);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_re_ix(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_IX_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_32(ea, REG_DA[i]);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_re_aw(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AW_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_32(ea, REG_DA[i]);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_re_al(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AL_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ m68ki_write_32(ea, REG_DA[i]);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_16_er_pi(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = AY;
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));
+ ea += 2;
+ count++;
+ }
+ AY = ea;
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_er_pcdi(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_PCDI_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_pcrel_16(ea)));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_er_pcix(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_PCIX_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_pcrel_16(ea)));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_er_ai(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_AI_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_er_di(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_DI_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_er_ix(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_IX_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_er_aw(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AW_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_16_er_al(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AL_16();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = MAKE_INT_16(MASK_OUT_ABOVE_16(m68ki_read_16(ea)));
+ ea += 2;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_W);
+}
+
+
+static void m68k_op_movem_32_er_pi(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = AY;
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = m68ki_read_32(ea);
+ ea += 4;
+ count++;
+ }
+ AY = ea;
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_er_pcdi(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_PCDI_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = m68ki_read_pcrel_32(ea);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_er_pcix(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_PCIX_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = m68ki_read_pcrel_32(ea);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_er_ai(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_AI_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = m68ki_read_32(ea);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_er_di(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_DI_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = m68ki_read_32(ea);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_er_ix(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AY_IX_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = m68ki_read_32(ea);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_er_aw(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AW_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = m68ki_read_32(ea);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movem_32_er_al(void)
+{
+ uint i = 0;
+ uint register_list = OPER_I_16();
+ uint ea = EA_AL_32();
+ uint count = 0;
+
+ for(; i < 16; i++)
+ if(register_list & (1 << i))
+ {
+ REG_DA[i] = m68ki_read_32(ea);
+ ea += 4;
+ count++;
+ }
+
+ USE_CYCLES(count * CYC_MOVEM_L);
+}
+
+
+static void m68k_op_movep_16_re(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = DX;
+
+ m68ki_write_8(ea, MASK_OUT_ABOVE_8(src >> 8));
+ m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src));
+}
+
+
+static void m68k_op_movep_32_re(void)
+{
+ uint ea = EA_AY_DI_32();
+ uint src = DX;
+
+ m68ki_write_8(ea, MASK_OUT_ABOVE_8(src >> 24));
+ m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src >> 16));
+ m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src >> 8));
+ m68ki_write_8(ea += 2, MASK_OUT_ABOVE_8(src));
+}
+
+
+static void m68k_op_movep_16_er(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint* r_dst = &DX;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | ((m68ki_read_8(ea) << 8) + m68ki_read_8(ea + 2));
+}
+
+
+static void m68k_op_movep_32_er(void)
+{
+ uint ea = EA_AY_DI_32();
+
+ DX = (m68ki_read_8(ea) << 24) + (m68ki_read_8(ea + 2) << 16)
+ + (m68ki_read_8(ea + 4) << 8) + m68ki_read_8(ea + 6);
+}
+
+
+static void m68k_op_moveq_32(void)
+{
+ uint res = DX = MAKE_INT_8(MASK_OUT_ABOVE_8(REG_IR));
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_d(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(DY);
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_ai(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_AI_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_pi(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_PI_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_pd(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_PD_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_di(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_DI_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_ix(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AY_IX_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_aw(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AW_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_al(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_AL_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_pcdi(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_PCDI_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_pcix(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_PCIX_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_muls_16_i(void)
+{
+ uint* r_dst = &DX;
+ sint src = MAKE_INT_16(OPER_I_16());
+ uint res = MASK_OUT_ABOVE_32( src * MAKE_INT_16(MASK_OUT_ABOVE_16(*r_dst)));
+
+ UseMulsCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_d(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_16(DY);
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_ai(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_AI_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_pi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PI_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_pd(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PD_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_di(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_DI_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_ix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_IX_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_aw(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AW_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_al(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AL_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_pcdi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCDI_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_pcix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCIX_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_mulu_16_i(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_I_16();
+ uint res = src * MASK_OUT_ABOVE_16(*r_dst);
+
+ UseMuluCycles(src);
+
+ *r_dst = res;
+
+ FLAG_Z = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_nbcd_8_d(void)
+{
+ uint* r_dst = &DY;
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_nbcd_8_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ m68ki_write_8(ea, res);
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_nbcd_8_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ m68ki_write_8(ea, res);
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_nbcd_8_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ m68ki_write_8(ea, res);
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_nbcd_8_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ m68ki_write_8(ea, res);
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_nbcd_8_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ m68ki_write_8(ea, res);
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_nbcd_8_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ m68ki_write_8(ea, res);
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_nbcd_8_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ m68ki_write_8(ea, res);
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_nbcd_8_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ m68ki_write_8(ea, res);
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_nbcd_8_al(void)
+{
+ uint ea = EA_AL_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = -dst - XFLAG_AS_1();
+
+ if(res)
+ {
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(((res|dst) & 0x0f) == 0x0)
+ res = (res & 0xf0) + 6;
+
+ res = MASK_OUT_ABOVE_8(res+0x9a);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+
+ m68ki_write_8(ea, res);
+
+ FLAG_Z |= res;
+ FLAG_C = CFLAG_SET;
+ FLAG_X = XFLAG_SET;
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ }
+ else
+ {
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_X = XFLAG_CLEAR;
+ FLAG_N = NFLAG_CLEAR;
+ }
+}
+
+
+static void m68k_op_neg_8_d(void)
+{
+ uint* r_dst = &DY;
+ uint res = 0 - MASK_OUT_ABOVE_8(*r_dst);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = *r_dst & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_neg_8_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = src & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_8_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = src & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_8_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = src & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_8_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = src & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_8_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = src & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_8_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = src & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_8_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = src & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_8_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = src & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_8_al(void)
+{
+ uint ea = EA_AL_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_C = FLAG_X = CFLAG_8(res);
+ FLAG_V = src & res;
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_16_d(void)
+{
+ uint* r_dst = &DY;
+ uint res = 0 - MASK_OUT_ABOVE_16(*r_dst);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = FLAG_X = CFLAG_16(res);
+ FLAG_V = (*r_dst & res)>>8;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_neg_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = FLAG_X = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = FLAG_X = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = FLAG_X = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = FLAG_X = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = FLAG_X = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = FLAG_X = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_C = FLAG_X = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_32_d(void)
+{
+ uint* r_dst = &DY;
+ uint res = 0 - *r_dst;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_C = FLAG_X = CFLAG_SUB_32(*r_dst, 0, res);
+ FLAG_V = (*r_dst & res)>>24;
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_neg_32_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_32_pi(void)
+{
+ uint ea = EA_AY_PI_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_32_pd(void)
+{
+ uint ea = EA_AY_PD_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_32_di(void)
+{
+ uint ea = EA_AY_DI_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_32_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_32_aw(void)
+{
+ uint ea = EA_AW_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_neg_32_al(void)
+{
+ uint ea = EA_AL_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_C = FLAG_X = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_negx_8_d(void)
+{
+ uint* r_dst = &DY;
+ uint res = 0 - MASK_OUT_ABOVE_8(*r_dst) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = *r_dst & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+}
+
+
+static void m68k_op_negx_8_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = src & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_negx_8_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = src & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_negx_8_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = src & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_negx_8_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = src & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_negx_8_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = src & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_negx_8_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = src & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_negx_8_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = src & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_negx_8_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = src & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_negx_8_al(void)
+{
+ uint ea = EA_AL_8();
+ uint src = m68ki_read_8(ea);
+ uint res = 0 - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = src & res;
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_negx_16_d(void)
+{
+ uint* r_dst = &DY;
+ uint res = 0 - MASK_OUT_ABOVE_16(*r_dst) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = (*r_dst & res)>>8;
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+}
+
+
+static void m68k_op_negx_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_negx_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_negx_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_negx_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_negx_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_negx_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_negx_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = 0 - MASK_OUT_ABOVE_16(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = (src & res)>>8;
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_negx_32_d(void)
+{
+ uint* r_dst = &DY;
+ uint res = 0 - MASK_OUT_ABOVE_32(*r_dst) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(*r_dst, 0, res);
+ FLAG_V = (*r_dst & res)>>24;
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ *r_dst = res;
+}
+
+
+static void m68k_op_negx_32_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_negx_32_pi(void)
+{
+ uint ea = EA_AY_PI_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_negx_32_pd(void)
+{
+ uint ea = EA_AY_PD_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_negx_32_di(void)
+{
+ uint ea = EA_AY_DI_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_negx_32_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_negx_32_aw(void)
+{
+ uint ea = EA_AW_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_negx_32_al(void)
+{
+ uint ea = EA_AL_32();
+ uint src = m68ki_read_32(ea);
+ uint res = 0 - MASK_OUT_ABOVE_32(src) - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, 0, res);
+ FLAG_V = (src & res)>>24;
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_nop(void)
+{
+}
+
+
+static void m68k_op_not_8_d(void)
+{
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_8(~*r_dst);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_8_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_8_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_8_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_8_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_8_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_8_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_8_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_8_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_8_al(void)
+{
+ uint ea = EA_AL_8();
+ uint res = MASK_OUT_ABOVE_8(~m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_16_d(void)
+{
+ uint* r_dst = &DY;
+ uint res = MASK_OUT_ABOVE_16(~*r_dst);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint res = MASK_OUT_ABOVE_16(~m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_32_d(void)
+{
+ uint* r_dst = &DY;
+ uint res = *r_dst = MASK_OUT_ABOVE_32(~*r_dst);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_32_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_32_pi(void)
+{
+ uint ea = EA_AY_PI_32();
+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_32_pd(void)
+{
+ uint ea = EA_AY_PD_32();
+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_32_di(void)
+{
+ uint ea = EA_AY_DI_32();
+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_32_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_32_aw(void)
+{
+ uint ea = EA_AW_32();
+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_not_32_al(void)
+{
+ uint ea = EA_AL_32();
+ uint res = MASK_OUT_ABOVE_32(~m68ki_read_32(ea));
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= MASK_OUT_ABOVE_8(DY)));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_ai(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_AI_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_pi(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_PI_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_pi7(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_A7_PI_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_pd(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_PD_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_pd7(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_A7_PD_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_di(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_DI_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_ix(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AY_IX_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_aw(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AW_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_al(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_AL_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_pcdi(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_PCDI_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_pcix(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_PCIX_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_er_i(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DX |= OPER_I_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= MASK_OUT_ABOVE_16(DY)));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_ai(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_AI_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_pi(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_PI_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_pd(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_PD_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_di(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_DI_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_ix(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AY_IX_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_aw(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AW_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_al(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_AL_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_pcdi(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_PCDI_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_pcix(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_PCIX_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_er_i(void)
+{
+ uint res = MASK_OUT_ABOVE_16((DX |= OPER_I_16()));
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_d(void)
+{
+ uint res = DX |= DY;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_ai(void)
+{
+ uint res = DX |= OPER_AY_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_pi(void)
+{
+ uint res = DX |= OPER_AY_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_pd(void)
+{
+ uint res = DX |= OPER_AY_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_di(void)
+{
+ uint res = DX |= OPER_AY_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_ix(void)
+{
+ uint res = DX |= OPER_AY_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_aw(void)
+{
+ uint res = DX |= OPER_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_al(void)
+{
+ uint res = DX |= OPER_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_pcdi(void)
+{
+ uint res = DX |= OPER_PCDI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_pcix(void)
+{
+ uint res = DX |= OPER_PCIX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_er_i(void)
+{
+ uint res = DX |= OPER_I_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_re_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_re_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_re_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_re_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_re_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_re_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_re_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_re_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_8_re_al(void)
+{
+ uint ea = EA_AL_8();
+ uint res = MASK_OUT_ABOVE_8(DX | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_re_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_re_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_re_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_re_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_re_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_re_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_16_re_al(void)
+{
+ uint ea = EA_AL_16();
+ uint res = MASK_OUT_ABOVE_16(DX | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_re_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+ uint res = DX | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_re_pi(void)
+{
+ uint ea = EA_AY_PI_32();
+ uint res = DX | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_re_pd(void)
+{
+ uint ea = EA_AY_PD_32();
+ uint res = DX | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_re_di(void)
+{
+ uint ea = EA_AY_DI_32();
+ uint res = DX | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_re_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+ uint res = DX | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_re_aw(void)
+{
+ uint ea = EA_AW_32();
+ uint res = DX | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_or_32_re_al(void)
+{
+ uint ea = EA_AL_32();
+ uint res = DX | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8((DY |= OPER_I_8()));
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_ai(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_AI_8();
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_pi(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PI_8();
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_pi7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PI_8();
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_pd(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PD_8();
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_pd7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PD_8();
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_di(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_DI_8();
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_ix(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_IX_8();
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_aw(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AW_8();
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_8_al(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AL_8();
+ uint res = MASK_OUT_ABOVE_8(src | m68ki_read_8(ea));
+
+ m68ki_write_8(ea, res);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_16_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY |= OPER_I_16());
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_16_ai(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_AI_16();
+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_16_pi(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PI_16();
+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_16_pd(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PD_16();
+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_16_di(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_DI_16();
+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_16_ix(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_IX_16();
+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_16_aw(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AW_16();
+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_16_al(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AL_16();
+ uint res = MASK_OUT_ABOVE_16(src | m68ki_read_16(ea));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_32_d(void)
+{
+ uint res = DY |= OPER_I_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_32_ai(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_AI_32();
+ uint res = src | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_32_pi(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PI_32();
+ uint res = src | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_32_pd(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PD_32();
+ uint res = src | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_32_di(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_DI_32();
+ uint res = src | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_32_ix(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_IX_32();
+ uint res = src | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_32_aw(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AW_32();
+ uint res = src | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_32_al(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AL_32();
+ uint res = src | m68ki_read_32(ea);
+
+ m68ki_write_32(ea, res);
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ori_16_toc(void)
+{
+ m68ki_set_ccr(m68ki_get_ccr() | OPER_I_16());
+}
+
+
+static void m68k_op_ori_16_tos(void)
+{
+ if(FLAG_S)
+ {
+ uint src = OPER_I_16();
+ m68ki_set_sr(m68ki_get_sr() | src);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_pea_32_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+
+ m68ki_push_32(ea);
+}
+
+
+static void m68k_op_pea_32_di(void)
+{
+ uint ea = EA_AY_DI_32();
+
+ m68ki_push_32(ea);
+}
+
+
+static void m68k_op_pea_32_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+
+ m68ki_push_32(ea);
+}
+
+
+static void m68k_op_pea_32_aw(void)
+{
+ uint ea = EA_AW_32();
+
+ m68ki_push_32(ea);
+}
+
+
+static void m68k_op_pea_32_al(void)
+{
+ uint ea = EA_AL_32();
+
+ m68ki_push_32(ea);
+}
+
+
+static void m68k_op_pea_32_pcdi(void)
+{
+ uint ea = EA_PCDI_32();
+
+ m68ki_push_32(ea);
+}
+
+
+static void m68k_op_pea_32_pcix(void)
+{
+ uint ea = EA_PCIX_32();
+
+ m68ki_push_32(ea);
+}
+
+
+static void m68k_op_reset(void)
+{
+ if(FLAG_S)
+ {
+ m68ki_output_reset() /* auto-disable (see m68kcpu.h) */
+ USE_CYCLES(CYC_RESET);
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_ror_8_s(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint shift = orig_shift & 7;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = ROR_8(src, shift);
+
+ if(orig_shift != 0)
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = src << (9-orig_shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_16_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = ROR_16(src, shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src << (9-shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_32_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint64 src = *r_dst;
+ uint res = ROR_32(src, shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = src << (9-shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_8_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+ uint shift = orig_shift & 7;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = ROR_8(src, shift);
+
+ if(orig_shift != 0)
+ {
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+ FLAG_C = src << (8-((shift-1)&7));
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_8(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_16_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+ uint shift = orig_shift & 15;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = ROR_16(src, shift);
+
+ if(orig_shift != 0)
+ {
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ FLAG_C = (src >> ((shift - 1) & 15)) << 8;
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_16(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_32_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+ uint shift = orig_shift & 31;
+ uint64 src = *r_dst;
+ uint res = ROR_32(src, shift);
+
+ if(orig_shift != 0)
+ {
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ *r_dst = res;
+ FLAG_C = (src >> ((shift - 1) & 31)) << 8;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_32(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_16(src, 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_16(src, 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_16(src, 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_16(src, 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_16(src, 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_16(src, 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_ror_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_16(src, 1);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src << 8;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_8_s(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint shift = orig_shift & 7;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = ROL_8(src, shift);
+
+ if(orig_shift != 0)
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_C = src << orig_shift;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_16_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = ROL_16(src, shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src >> (8-shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_32_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint64 src = *r_dst;
+ uint res = ROL_32(src, shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_C = src >> (24-shift);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_8_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+ uint shift = orig_shift & 7;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = ROL_8(src, shift);
+
+ if(orig_shift != 0)
+ {
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ if(shift != 0)
+ {
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+ FLAG_C = src << shift;
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = (src & 1)<<8;
+ FLAG_N = NFLAG_8(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_8(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_16_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+ uint shift = orig_shift & 15;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, shift));
+
+ if(orig_shift != 0)
+ {
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ if(shift != 0)
+ {
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ FLAG_C = (src << shift) >> 8;
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+ FLAG_C = (src & 1)<<8;
+ FLAG_N = NFLAG_16(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_16(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_32_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+ uint shift = orig_shift & 31;
+ uint64 src = *r_dst;
+ uint res = ROL_32(src, shift);
+
+ if(orig_shift != 0)
+ {
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ *r_dst = res;
+
+ FLAG_C = (src >> ((32 - shift) & 0x1f)) << 8;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_N = NFLAG_32(src);
+ FLAG_Z = src;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rol_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = MASK_OUT_ABOVE_16(ROL_16(src, 1));
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_C = src >> 7;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_8_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = ROR_9(src | (XFLAG_AS_1() << 8), shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res;
+ res = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_16_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_32_s(void)
+{
+#if M68K_USE_64_BIT
+
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint64 src = *r_dst;
+ uint64 res = src | (((uint64)XFLAG_AS_1()) << 32);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ res = ROR_33_64(res, shift);
+
+ FLAG_C = FLAG_X = res >> 24;
+ res = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+
+#else
+
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = *r_dst;
+ uint res = MASK_OUT_ABOVE_32((ROR_33(src, shift) & ~(1 << (32 - shift))) | (XFLAG_AS_1() << (32 - shift)));
+ uint new_x_flag = src & (1 << (shift - 1));
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = res;
+
+ FLAG_C = FLAG_X = (new_x_flag != 0)<<8;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+
+#endif
+}
+
+
+static void m68k_op_roxr_8_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+
+ if(orig_shift != 0)
+ {
+ uint shift = orig_shift % 9;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = ROR_9(src | (XFLAG_AS_1() << 8), shift);
+
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res;
+ res = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = FLAG_X;
+ FLAG_N = NFLAG_8(*r_dst);
+ FLAG_Z = MASK_OUT_ABOVE_8(*r_dst);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_16_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+
+ if(orig_shift != 0)
+ {
+ uint shift = orig_shift % 17;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), shift);
+
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = FLAG_X;
+ FLAG_N = NFLAG_16(*r_dst);
+ FLAG_Z = MASK_OUT_ABOVE_16(*r_dst);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_32_r(void)
+{
+#if M68K_USE_64_BIT
+
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+
+ if(orig_shift != 0)
+ {
+ uint shift = orig_shift % 33;
+ uint64 src = *r_dst;
+ uint64 res = src | (((uint64)XFLAG_AS_1()) << 32);
+
+ res = ROR_33_64(res, shift);
+
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res >> 24;
+ res = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = FLAG_X;
+ FLAG_N = NFLAG_32(*r_dst);
+ FLAG_Z = *r_dst;
+ FLAG_V = VFLAG_CLEAR;
+
+#else
+
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+ uint shift = orig_shift % 33;
+ uint src = *r_dst;
+ uint res = MASK_OUT_ABOVE_32((ROR_33(src, shift) & ~(1 << (32 - shift))) | (XFLAG_AS_1() << (32 - shift)));
+ uint new_x_flag = src & (1 << (shift - 1));
+
+ if(orig_shift != 0)
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ if(shift != 0)
+ {
+ *r_dst = res;
+ FLAG_X = (new_x_flag != 0)<<8;
+ }
+ else
+ res = src;
+ FLAG_C = FLAG_X;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+
+#endif
+}
+
+
+static void m68k_op_roxr_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxr_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROR_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_8_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = ROL_9(src | (XFLAG_AS_1() << 8), shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res;
+ res = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_16_s(void)
+{
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), shift);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_32_s(void)
+{
+#if M68K_USE_64_BIT
+
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint64 src = *r_dst;
+ uint64 res = src | (((uint64)XFLAG_AS_1()) << 32);
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ res = ROL_33_64(res, shift);
+
+ FLAG_C = FLAG_X = res >> 24;
+ res = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = res;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+
+#else
+
+ uint* r_dst = &DY;
+ uint shift = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint src = *r_dst;
+ uint res = MASK_OUT_ABOVE_32((ROL_33(src, shift) & ~(1 << (shift - 1))) | (XFLAG_AS_1() << (shift - 1)));
+ uint new_x_flag = src & (1 << (32 - shift));
+
+ if(shift != 0)
+ USE_CYCLES(shift * CYC_SHIFT);
+
+ *r_dst = res;
+
+ FLAG_C = FLAG_X = (new_x_flag != 0)<<8;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+
+#endif
+}
+
+
+static void m68k_op_roxl_8_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+
+
+ if(orig_shift != 0)
+ {
+ uint shift = orig_shift % 9;
+ uint src = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = ROL_9(src | (XFLAG_AS_1() << 8), shift);
+
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res;
+ res = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = FLAG_X;
+ FLAG_N = NFLAG_8(*r_dst);
+ FLAG_Z = MASK_OUT_ABOVE_8(*r_dst);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_16_r(void)
+{
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+
+ if(orig_shift != 0)
+ {
+ uint shift = orig_shift % 17;
+ uint src = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), shift);
+
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = FLAG_X;
+ FLAG_N = NFLAG_16(*r_dst);
+ FLAG_Z = MASK_OUT_ABOVE_16(*r_dst);
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_32_r(void)
+{
+#if M68K_USE_64_BIT
+
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+
+ if(orig_shift != 0)
+ {
+ uint shift = orig_shift % 33;
+ uint64 src = *r_dst;
+ uint64 res = src | (((uint64)XFLAG_AS_1()) << 32);
+
+ res = ROL_33_64(res, shift);
+
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ FLAG_C = FLAG_X = res >> 24;
+ res = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = res;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ return;
+ }
+
+ FLAG_C = FLAG_X;
+ FLAG_N = NFLAG_32(*r_dst);
+ FLAG_Z = *r_dst;
+ FLAG_V = VFLAG_CLEAR;
+
+#else
+
+ uint* r_dst = &DY;
+ uint orig_shift = DX & 0x3f;
+ uint shift = orig_shift % 33;
+ uint src = *r_dst;
+ uint res = MASK_OUT_ABOVE_32((ROL_33(src, shift) & ~(1 << (shift - 1))) | (XFLAG_AS_1() << (shift - 1)));
+ uint new_x_flag = src & (1 << (32 - shift));
+
+ if(orig_shift != 0)
+ USE_CYCLES(orig_shift * CYC_SHIFT);
+
+ if(shift != 0)
+ {
+ *r_dst = res;
+ FLAG_X = (new_x_flag != 0)<<8;
+ }
+ else
+ res = src;
+ FLAG_C = FLAG_X;
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+
+#endif
+}
+
+
+static void m68k_op_roxl_16_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_16_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_16_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_16_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_16_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_16_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_roxl_16_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = m68ki_read_16(ea);
+ uint res = ROL_17(src | (XFLAG_AS_1() << 16), 1);
+
+ FLAG_C = FLAG_X = res >> 8;
+ res = MASK_OUT_ABOVE_16(res);
+
+ m68ki_write_16(ea, res);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_rte_32(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr;
+ uint new_pc;
+
+ new_sr = m68ki_pull_16();
+ new_pc = m68ki_pull_32();
+ m68ki_jump(new_pc);
+ m68ki_set_sr(new_sr);
+
+#if M68K_EMULATE_ADDRESS_ERROR
+ CPU_INSTR_MODE = INSTRUCTION_YES;
+ CPU_RUN_MODE = RUN_MODE_NORMAL;
+#endif
+
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_rtr_32(void)
+{
+ m68ki_set_ccr(m68ki_pull_16());
+ m68ki_jump(m68ki_pull_32());
+}
+
+
+static void m68k_op_rts_32(void)
+{
+ m68ki_jump(m68ki_pull_32());
+}
+
+
+static void m68k_op_sbcd_8_rr(void)
+{
+ uint* r_dst = &DX;
+ uint src = DY;
+ uint dst = *r_dst;
+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 0xf)
+ corf = 6;
+
+ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(res > 0xff)
+ {
+ res += 0xa0;
+ FLAG_X = FLAG_C = CFLAG_SET;
+ }
+ else if(res < corf)
+ FLAG_X = FLAG_C = CFLAG_SET;
+ else
+ FLAG_X = FLAG_C = 0;
+
+ res = MASK_OUT_ABOVE_8(res-corf);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ FLAG_Z |= res;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+}
+
+
+static void m68k_op_sbcd_8_mm_ax7(void)
+{
+ uint src = OPER_AY_PD_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 0xf)
+ corf = 6;
+ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(res > 0xff)
+ {
+ res += 0xa0;
+ FLAG_X = FLAG_C = CFLAG_SET;
+ }
+ else if(res < corf)
+ FLAG_X = FLAG_C = CFLAG_SET;
+ else
+ FLAG_X = FLAG_C = 0;
+
+ res = MASK_OUT_ABOVE_8(res-corf);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_sbcd_8_mm_ay7(void)
+{
+ uint src = OPER_A7_PD_8();
+ uint ea = EA_AX_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 0xf)
+ corf = 6;
+ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(res > 0xff)
+ {
+ res += 0xa0;
+ FLAG_X = FLAG_C = CFLAG_SET;
+ }
+ else if(res < corf)
+ FLAG_X = FLAG_C = CFLAG_SET;
+ else
+ FLAG_X = FLAG_C = 0;
+
+ res = MASK_OUT_ABOVE_8(res-corf);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_sbcd_8_mm_axy7(void)
+{
+ uint src = OPER_A7_PD_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 0xf)
+ corf = 6;
+ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(res > 0xff)
+ {
+ res += 0xa0;
+ FLAG_X = FLAG_C = CFLAG_SET;
+ }
+ else if(res < corf)
+ FLAG_X = FLAG_C = CFLAG_SET;
+ else
+ FLAG_X = FLAG_C = 0;
+
+ res = MASK_OUT_ABOVE_8(res-corf);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_sbcd_8_mm(void)
+{
+ uint src = OPER_AY_PD_8();
+ uint ea = EA_AX_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = LOW_NIBBLE(dst) - LOW_NIBBLE(src) - XFLAG_AS_1();
+ uint corf = 0;
+
+ if(res > 0xf)
+ corf = 6;
+ res += HIGH_NIBBLE(dst) - HIGH_NIBBLE(src);
+ FLAG_V = res; /* Undefined V behavior */
+
+ if(res > 0xff)
+ {
+ res += 0xa0;
+ FLAG_X = FLAG_C = CFLAG_SET;
+ }
+ else if(res < corf)
+ FLAG_X = FLAG_C = CFLAG_SET;
+ else
+ FLAG_X = FLAG_C = 0;
+
+ res = MASK_OUT_ABOVE_8(res-corf);
+
+ FLAG_V &= ~res; /* Undefined V behavior part II */
+ FLAG_N = NFLAG_8(res); /* Undefined N behavior */
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_st_8_d(void)
+{
+ DY |= 0xff;
+}
+
+
+static void m68k_op_st_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), 0xff);
+}
+
+
+static void m68k_op_st_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), 0xff);
+}
+
+
+static void m68k_op_st_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), 0xff);
+}
+
+
+static void m68k_op_st_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), 0xff);
+}
+
+
+static void m68k_op_st_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), 0xff);
+}
+
+
+static void m68k_op_st_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), 0xff);
+}
+
+
+static void m68k_op_st_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), 0xff);
+}
+
+
+static void m68k_op_st_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), 0xff);
+}
+
+
+static void m68k_op_st_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), 0xff);
+}
+
+
+static void m68k_op_sf_8_d(void)
+{
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_sf_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), 0);
+}
+
+
+static void m68k_op_sf_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), 0);
+}
+
+
+static void m68k_op_sf_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), 0);
+}
+
+
+static void m68k_op_sf_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), 0);
+}
+
+
+static void m68k_op_sf_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), 0);
+}
+
+
+static void m68k_op_sf_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), 0);
+}
+
+
+static void m68k_op_sf_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), 0);
+}
+
+
+static void m68k_op_sf_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), 0);
+}
+
+
+static void m68k_op_sf_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), 0);
+}
+
+
+static void m68k_op_shi_8_d(void)
+{
+ if(COND_HI())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_sls_8_d(void)
+{
+ if(COND_LS())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_scc_8_d(void)
+{
+ if(COND_CC())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_scs_8_d(void)
+{
+ if(COND_CS())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_sne_8_d(void)
+{
+ if(COND_NE())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_seq_8_d(void)
+{
+ if(COND_EQ())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_svc_8_d(void)
+{
+ if(COND_VC())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_svs_8_d(void)
+{
+ if(COND_VS())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_spl_8_d(void)
+{
+ if(COND_PL())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_smi_8_d(void)
+{
+ if(COND_MI())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_sge_8_d(void)
+{
+ if(COND_GE())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_slt_8_d(void)
+{
+ if(COND_LT())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_sgt_8_d(void)
+{
+ if(COND_GT())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_sle_8_d(void)
+{
+ if(COND_LE())
+ {
+ DY |= 0xff;
+ USE_CYCLES(CYC_SCC_R_TRUE);
+ return;
+ }
+ DY &= 0xffffff00;
+}
+
+
+static void m68k_op_shi_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_HI() ? 0xff : 0);
+}
+
+
+static void m68k_op_shi_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_HI() ? 0xff : 0);
+}
+
+
+static void m68k_op_shi_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_HI() ? 0xff : 0);
+}
+
+
+static void m68k_op_shi_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_HI() ? 0xff : 0);
+}
+
+
+static void m68k_op_shi_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_HI() ? 0xff : 0);
+}
+
+
+static void m68k_op_shi_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_HI() ? 0xff : 0);
+}
+
+
+static void m68k_op_shi_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_HI() ? 0xff : 0);
+}
+
+
+static void m68k_op_shi_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_HI() ? 0xff : 0);
+}
+
+
+static void m68k_op_shi_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_HI() ? 0xff : 0);
+}
+
+
+static void m68k_op_sls_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_LS() ? 0xff : 0);
+}
+
+
+static void m68k_op_sls_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_LS() ? 0xff : 0);
+}
+
+
+static void m68k_op_sls_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_LS() ? 0xff : 0);
+}
+
+
+static void m68k_op_sls_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_LS() ? 0xff : 0);
+}
+
+
+static void m68k_op_sls_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_LS() ? 0xff : 0);
+}
+
+
+static void m68k_op_sls_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_LS() ? 0xff : 0);
+}
+
+
+static void m68k_op_sls_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_LS() ? 0xff : 0);
+}
+
+
+static void m68k_op_sls_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_LS() ? 0xff : 0);
+}
+
+
+static void m68k_op_sls_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_LS() ? 0xff : 0);
+}
+
+
+static void m68k_op_scc_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_CC() ? 0xff : 0);
+}
+
+
+static void m68k_op_scc_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_CC() ? 0xff : 0);
+}
+
+
+static void m68k_op_scc_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_CC() ? 0xff : 0);
+}
+
+
+static void m68k_op_scc_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_CC() ? 0xff : 0);
+}
+
+
+static void m68k_op_scc_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_CC() ? 0xff : 0);
+}
+
+
+static void m68k_op_scc_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_CC() ? 0xff : 0);
+}
+
+
+static void m68k_op_scc_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_CC() ? 0xff : 0);
+}
+
+
+static void m68k_op_scc_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_CC() ? 0xff : 0);
+}
+
+
+static void m68k_op_scc_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_CC() ? 0xff : 0);
+}
+
+
+static void m68k_op_scs_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_CS() ? 0xff : 0);
+}
+
+
+static void m68k_op_scs_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_CS() ? 0xff : 0);
+}
+
+
+static void m68k_op_scs_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_CS() ? 0xff : 0);
+}
+
+
+static void m68k_op_scs_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_CS() ? 0xff : 0);
+}
+
+
+static void m68k_op_scs_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_CS() ? 0xff : 0);
+}
+
+
+static void m68k_op_scs_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_CS() ? 0xff : 0);
+}
+
+
+static void m68k_op_scs_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_CS() ? 0xff : 0);
+}
+
+
+static void m68k_op_scs_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_CS() ? 0xff : 0);
+}
+
+
+static void m68k_op_scs_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_CS() ? 0xff : 0);
+}
+
+
+static void m68k_op_sne_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_NE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sne_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_NE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sne_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_NE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sne_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_NE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sne_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_NE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sne_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_NE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sne_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_NE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sne_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_NE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sne_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_NE() ? 0xff : 0);
+}
+
+
+static void m68k_op_seq_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_EQ() ? 0xff : 0);
+}
+
+
+static void m68k_op_seq_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_EQ() ? 0xff : 0);
+}
+
+
+static void m68k_op_seq_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_EQ() ? 0xff : 0);
+}
+
+
+static void m68k_op_seq_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_EQ() ? 0xff : 0);
+}
+
+
+static void m68k_op_seq_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_EQ() ? 0xff : 0);
+}
+
+
+static void m68k_op_seq_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_EQ() ? 0xff : 0);
+}
+
+
+static void m68k_op_seq_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_EQ() ? 0xff : 0);
+}
+
+
+static void m68k_op_seq_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_EQ() ? 0xff : 0);
+}
+
+
+static void m68k_op_seq_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_EQ() ? 0xff : 0);
+}
+
+
+static void m68k_op_svc_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_VC() ? 0xff : 0);
+}
+
+
+static void m68k_op_svc_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_VC() ? 0xff : 0);
+}
+
+
+static void m68k_op_svc_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_VC() ? 0xff : 0);
+}
+
+
+static void m68k_op_svc_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_VC() ? 0xff : 0);
+}
+
+
+static void m68k_op_svc_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_VC() ? 0xff : 0);
+}
+
+
+static void m68k_op_svc_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_VC() ? 0xff : 0);
+}
+
+
+static void m68k_op_svc_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_VC() ? 0xff : 0);
+}
+
+
+static void m68k_op_svc_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_VC() ? 0xff : 0);
+}
+
+
+static void m68k_op_svc_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_VC() ? 0xff : 0);
+}
+
+
+static void m68k_op_svs_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_VS() ? 0xff : 0);
+}
+
+
+static void m68k_op_svs_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_VS() ? 0xff : 0);
+}
+
+
+static void m68k_op_svs_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_VS() ? 0xff : 0);
+}
+
+
+static void m68k_op_svs_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_VS() ? 0xff : 0);
+}
+
+
+static void m68k_op_svs_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_VS() ? 0xff : 0);
+}
+
+
+static void m68k_op_svs_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_VS() ? 0xff : 0);
+}
+
+
+static void m68k_op_svs_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_VS() ? 0xff : 0);
+}
+
+
+static void m68k_op_svs_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_VS() ? 0xff : 0);
+}
+
+
+static void m68k_op_svs_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_VS() ? 0xff : 0);
+}
+
+
+static void m68k_op_spl_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_PL() ? 0xff : 0);
+}
+
+
+static void m68k_op_spl_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_PL() ? 0xff : 0);
+}
+
+
+static void m68k_op_spl_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_PL() ? 0xff : 0);
+}
+
+
+static void m68k_op_spl_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_PL() ? 0xff : 0);
+}
+
+
+static void m68k_op_spl_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_PL() ? 0xff : 0);
+}
+
+
+static void m68k_op_spl_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_PL() ? 0xff : 0);
+}
+
+
+static void m68k_op_spl_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_PL() ? 0xff : 0);
+}
+
+
+static void m68k_op_spl_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_PL() ? 0xff : 0);
+}
+
+
+static void m68k_op_spl_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_PL() ? 0xff : 0);
+}
+
+
+static void m68k_op_smi_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_MI() ? 0xff : 0);
+}
+
+
+static void m68k_op_smi_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_MI() ? 0xff : 0);
+}
+
+
+static void m68k_op_smi_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_MI() ? 0xff : 0);
+}
+
+
+static void m68k_op_smi_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_MI() ? 0xff : 0);
+}
+
+
+static void m68k_op_smi_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_MI() ? 0xff : 0);
+}
+
+
+static void m68k_op_smi_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_MI() ? 0xff : 0);
+}
+
+
+static void m68k_op_smi_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_MI() ? 0xff : 0);
+}
+
+
+static void m68k_op_smi_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_MI() ? 0xff : 0);
+}
+
+
+static void m68k_op_smi_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_MI() ? 0xff : 0);
+}
+
+
+static void m68k_op_sge_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_GE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sge_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_GE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sge_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_GE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sge_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_GE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sge_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_GE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sge_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_GE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sge_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_GE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sge_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_GE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sge_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_GE() ? 0xff : 0);
+}
+
+
+static void m68k_op_slt_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_LT() ? 0xff : 0);
+}
+
+
+static void m68k_op_slt_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_LT() ? 0xff : 0);
+}
+
+
+static void m68k_op_slt_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_LT() ? 0xff : 0);
+}
+
+
+static void m68k_op_slt_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_LT() ? 0xff : 0);
+}
+
+
+static void m68k_op_slt_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_LT() ? 0xff : 0);
+}
+
+
+static void m68k_op_slt_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_LT() ? 0xff : 0);
+}
+
+
+static void m68k_op_slt_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_LT() ? 0xff : 0);
+}
+
+
+static void m68k_op_slt_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_LT() ? 0xff : 0);
+}
+
+
+static void m68k_op_slt_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_LT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sgt_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_GT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sgt_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_GT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sgt_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_GT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sgt_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_GT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sgt_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_GT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sgt_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_GT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sgt_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_GT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sgt_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_GT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sgt_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_GT() ? 0xff : 0);
+}
+
+
+static void m68k_op_sle_8_ai(void)
+{
+ m68ki_write_8(EA_AY_AI_8(), COND_LE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sle_8_pi(void)
+{
+ m68ki_write_8(EA_AY_PI_8(), COND_LE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sle_8_pi7(void)
+{
+ m68ki_write_8(EA_A7_PI_8(), COND_LE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sle_8_pd(void)
+{
+ m68ki_write_8(EA_AY_PD_8(), COND_LE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sle_8_pd7(void)
+{
+ m68ki_write_8(EA_A7_PD_8(), COND_LE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sle_8_di(void)
+{
+ m68ki_write_8(EA_AY_DI_8(), COND_LE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sle_8_ix(void)
+{
+ m68ki_write_8(EA_AY_IX_8(), COND_LE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sle_8_aw(void)
+{
+ m68ki_write_8(EA_AW_8(), COND_LE() ? 0xff : 0);
+}
+
+
+static void m68k_op_sle_8_al(void)
+{
+ m68ki_write_8(EA_AL_8(), COND_LE() ? 0xff : 0);
+}
+
+
+static void m68k_op_stop(void)
+{
+ if(FLAG_S)
+ {
+ uint new_sr = OPER_I_16();
+ CPU_STOPPED |= STOP_LEVEL_STOP;
+ m68ki_set_sr(new_sr);
+ if (CPU_STOPPED)
+ {
+ SET_CYCLES(m68ki_cpu.cycle_end - 4*MUL);
+ }
+ return;
+ }
+ m68ki_exception_privilege_violation();
+}
+
+
+static void m68k_op_sub_8_er_d(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_8(DY);
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_ai(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_AI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_pi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_pi7(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_A7_PI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_pd(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PD_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_pd7(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_A7_PD_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_di(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_DI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_ix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_IX_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_aw(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AW_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_al(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AL_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_pcdi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCDI_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_pcix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCIX_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_er_i(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_I_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_d(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_16(DY);
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_a(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_16(AY);
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_ai(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_AI_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_pi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PI_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_pd(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PD_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_di(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_DI_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_ix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_IX_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_aw(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AW_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_al(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AL_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_pcdi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCDI_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_pcix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCIX_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_16_er_i(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_I_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_d(void)
+{
+ uint* r_dst = &DX;
+ uint src = DY;
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_a(void)
+{
+ uint* r_dst = &DX;
+ uint src = AY;
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_ai(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_AI_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_pi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PI_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_pd(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_PD_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_di(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_DI_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_ix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AY_IX_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_aw(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AW_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_al(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_AL_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_pcdi(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCDI_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_pcix(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_PCIX_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_32_er_i(void)
+{
+ uint* r_dst = &DX;
+ uint src = OPER_I_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_sub_8_re_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_8_re_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_8_re_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_8_re_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_8_re_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_8_re_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_8_re_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_8_re_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_8_re_al(void)
+{
+ uint ea = EA_AL_8();
+ uint src = MASK_OUT_ABOVE_8(DX);
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_16_re_ai(void)
+{
+ uint ea = EA_AY_AI_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_16_re_pi(void)
+{
+ uint ea = EA_AY_PI_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_16_re_pd(void)
+{
+ uint ea = EA_AY_PD_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_16_re_di(void)
+{
+ uint ea = EA_AY_DI_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_16_re_ix(void)
+{
+ uint ea = EA_AY_IX_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_16_re_aw(void)
+{
+ uint ea = EA_AW_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_16_re_al(void)
+{
+ uint ea = EA_AL_16();
+ uint src = MASK_OUT_ABOVE_16(DX);
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_32_re_ai(void)
+{
+ uint ea = EA_AY_AI_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_32_re_pi(void)
+{
+ uint ea = EA_AY_PI_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_32_re_pd(void)
+{
+ uint ea = EA_AY_PD_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_32_re_di(void)
+{
+ uint ea = EA_AY_DI_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_32_re_ix(void)
+{
+ uint ea = EA_AY_IX_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_32_re_aw(void)
+{
+ uint ea = EA_AW_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_sub_32_re_al(void)
+{
+ uint ea = EA_AL_32();
+ uint src = DX;
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_suba_16_d(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - MAKE_INT_16(DY));
+}
+
+
+static void m68k_op_suba_16_a(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - MAKE_INT_16(AY));
+}
+
+
+static void m68k_op_suba_16_ai(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_AI_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_16_pi(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_PI_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_16_pd(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_PD_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_16_di(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_DI_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_16_ix(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AY_IX_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_16_aw(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AW_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_16_al(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_AL_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_16_pcdi(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_PCDI_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_16_pcix(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_PCIX_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_16_i(void)
+{
+ uint* r_dst = &AX;
+ uint src = MAKE_INT_16(OPER_I_16());
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_d(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - DY);
+}
+
+
+static void m68k_op_suba_32_a(void)
+{
+ uint* r_dst = &AX;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - AY);
+}
+
+
+static void m68k_op_suba_32_ai(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_AY_AI_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_pi(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_AY_PI_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_pd(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_AY_PD_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_di(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_AY_DI_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_ix(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_AY_IX_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_aw(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_AW_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_al(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_AL_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_pcdi(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_PCDI_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_pcix(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_PCIX_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_suba_32_i(void)
+{
+ uint* r_dst = &AX;
+ uint src = OPER_I_32();
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - src);
+}
+
+
+static void m68k_op_subi_8_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = OPER_I_8();
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_subi_8_ai(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_AI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_8_pi(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_8_pi7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_8_pd(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_8_pd7(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_8_di(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_DI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_8_ix(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AY_IX_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_8_aw(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AW_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_8_al(void)
+{
+ uint src = OPER_I_8();
+ uint ea = EA_AL_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_16_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = OPER_I_16();
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_subi_16_ai(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_AI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_16_pi(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_16_pd(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_PD_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_16_di(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_DI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_16_ix(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AY_IX_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_16_aw(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AW_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_16_al(void)
+{
+ uint src = OPER_I_16();
+ uint ea = EA_AL_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_32_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = OPER_I_32();
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_subi_32_ai(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_AI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_32_pi(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_32_pd(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_PD_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_32_di(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_DI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_32_ix(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AY_IX_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_32_aw(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AW_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subi_32_al(void)
+{
+ uint src = OPER_I_32();
+ uint ea = EA_AL_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_8_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_subq_8_ai(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_AI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_8_pi(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_8_pi7(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_A7_PI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_8_pd(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_8_pd7(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_8_di(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_DI_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_8_ix(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_IX_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_8_aw(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AW_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_8_al(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AL_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = MASK_OUT_ABOVE_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ m68ki_write_8(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_16_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | FLAG_Z;
+}
+
+
+static void m68k_op_subq_16_a(void)
+{
+ uint* r_dst = &AY;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - ((((REG_IR >> 9) - 1) & 7) + 1));
+}
+
+
+static void m68k_op_subq_16_ai(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_AI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_16_pi(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_16_pd(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PD_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_16_di(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_DI_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_16_ix(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_IX_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_16_aw(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AW_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_16_al(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AL_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = MASK_OUT_ABOVE_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ m68ki_write_16(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_32_d(void)
+{
+ uint* r_dst = &DY;
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint dst = *r_dst;
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ *r_dst = FLAG_Z;
+}
+
+
+static void m68k_op_subq_32_a(void)
+{
+ uint* r_dst = &AY;
+
+ *r_dst = MASK_OUT_ABOVE_32(*r_dst - ((((REG_IR >> 9) - 1) & 7) + 1));
+}
+
+
+static void m68k_op_subq_32_ai(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_AI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_32_pi(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_32_pd(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_PD_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_32_di(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_DI_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_32_ix(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AY_IX_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_32_aw(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AW_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subq_32_al(void)
+{
+ uint src = (((REG_IR >> 9) - 1) & 7) + 1;
+ uint ea = EA_AL_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = MASK_OUT_ABOVE_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ m68ki_write_32(ea, FLAG_Z);
+}
+
+
+static void m68k_op_subx_8_rr(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_8(DY);
+ uint dst = MASK_OUT_ABOVE_8(*r_dst);
+ uint res = dst - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ *r_dst = MASK_OUT_BELOW_8(*r_dst) | res;
+}
+
+
+static void m68k_op_subx_16_rr(void)
+{
+ uint* r_dst = &DX;
+ uint src = MASK_OUT_ABOVE_16(DY);
+ uint dst = MASK_OUT_ABOVE_16(*r_dst);
+ uint res = dst - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ *r_dst = MASK_OUT_BELOW_16(*r_dst) | res;
+}
+
+
+static void m68k_op_subx_32_rr(void)
+{
+ uint* r_dst = &DX;
+ uint src = DY;
+ uint dst = *r_dst;
+ uint res = dst - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ *r_dst = res;
+}
+
+
+static void m68k_op_subx_8_mm_ax7(void)
+{
+ uint src = OPER_AY_PD_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_subx_8_mm_ay7(void)
+{
+ uint src = OPER_A7_PD_8();
+ uint ea = EA_AX_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_subx_8_mm_axy7(void)
+{
+ uint src = OPER_A7_PD_8();
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_subx_8_mm(void)
+{
+ uint src = OPER_AY_PD_8();
+ uint ea = EA_AX_PD_8();
+ uint dst = m68ki_read_8(ea);
+ uint res = dst - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_X = FLAG_C = CFLAG_8(res);
+ FLAG_V = VFLAG_SUB_8(src, dst, res);
+
+ res = MASK_OUT_ABOVE_8(res);
+ FLAG_Z |= res;
+
+ m68ki_write_8(ea, res);
+}
+
+
+static void m68k_op_subx_16_mm(void)
+{
+ uint src = OPER_AY_PD_16();
+ uint ea = EA_AX_PD_16();
+ uint dst = m68ki_read_16(ea);
+ uint res = dst - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_X = FLAG_C = CFLAG_16(res);
+ FLAG_V = VFLAG_SUB_16(src, dst, res);
+
+ res = MASK_OUT_ABOVE_16(res);
+ FLAG_Z |= res;
+
+ m68ki_write_16(ea, res);
+}
+
+
+static void m68k_op_subx_32_mm(void)
+{
+ uint src = OPER_AY_PD_32();
+ uint ea = EA_AX_PD_32();
+ uint dst = m68ki_read_32(ea);
+ uint res = dst - src - XFLAG_AS_1();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_X = FLAG_C = CFLAG_SUB_32(src, dst, res);
+ FLAG_V = VFLAG_SUB_32(src, dst, res);
+
+ res = MASK_OUT_ABOVE_32(res);
+ FLAG_Z |= res;
+
+ m68ki_write_32(ea, res);
+}
+
+
+static void m68k_op_swap_32(void)
+{
+ uint* r_dst = &DY;
+
+ FLAG_Z = MASK_OUT_ABOVE_32(*r_dst<<16);
+ *r_dst = (*r_dst>>16) | FLAG_Z;
+
+ FLAG_Z = *r_dst;
+ FLAG_N = NFLAG_32(*r_dst);
+ FLAG_C = CFLAG_CLEAR;
+ FLAG_V = VFLAG_CLEAR;
+}
+
+
+static void m68k_op_tas_8_d(void)
+{
+ uint* r_dst = &DY;
+
+ FLAG_Z = MASK_OUT_ABOVE_8(*r_dst);
+ FLAG_N = NFLAG_8(*r_dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+ *r_dst |= 0x80;
+}
+
+
+static void m68k_op_tas_8_ai(void)
+{
+ uint ea = EA_AY_AI_8();
+ uint dst = m68ki_read_8(ea);
+
+ FLAG_Z = dst;
+ FLAG_N = NFLAG_8(dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback
+ disabled in order to function properly. Some Amiga software may also rely
+ on this, but only when accessing specific addresses so additional functionality
+ will be needed. */
+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);
+}
+
+
+static void m68k_op_tas_8_pi(void)
+{
+ uint ea = EA_AY_PI_8();
+ uint dst = m68ki_read_8(ea);
+
+ FLAG_Z = dst;
+ FLAG_N = NFLAG_8(dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback
+ disabled in order to function properly. Some Amiga software may also rely
+ on this, but only when accessing specific addresses so additional functionality
+ will be needed. */
+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);
+}
+
+
+static void m68k_op_tas_8_pi7(void)
+{
+ uint ea = EA_A7_PI_8();
+ uint dst = m68ki_read_8(ea);
+
+ FLAG_Z = dst;
+ FLAG_N = NFLAG_8(dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback
+ disabled in order to function properly. Some Amiga software may also rely
+ on this, but only when accessing specific addresses so additional functionality
+ will be needed. */
+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);
+}
+
+
+static void m68k_op_tas_8_pd(void)
+{
+ uint ea = EA_AY_PD_8();
+ uint dst = m68ki_read_8(ea);
+
+ FLAG_Z = dst;
+ FLAG_N = NFLAG_8(dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback
+ disabled in order to function properly. Some Amiga software may also rely
+ on this, but only when accessing specific addresses so additional functionality
+ will be needed. */
+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);
+}
+
+
+static void m68k_op_tas_8_pd7(void)
+{
+ uint ea = EA_A7_PD_8();
+ uint dst = m68ki_read_8(ea);
+
+ FLAG_Z = dst;
+ FLAG_N = NFLAG_8(dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback
+ disabled in order to function properly. Some Amiga software may also rely
+ on this, but only when accessing specific addresses so additional functionality
+ will be needed. */
+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);
+}
+
+
+static void m68k_op_tas_8_di(void)
+{
+ uint ea = EA_AY_DI_8();
+ uint dst = m68ki_read_8(ea);
+
+ FLAG_Z = dst;
+ FLAG_N = NFLAG_8(dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback
+ disabled in order to function properly. Some Amiga software may also rely
+ on this, but only when accessing specific addresses so additional functionality
+ will be needed. */
+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);
+}
+
+
+static void m68k_op_tas_8_ix(void)
+{
+ uint ea = EA_AY_IX_8();
+ uint dst = m68ki_read_8(ea);
+
+ FLAG_Z = dst;
+ FLAG_N = NFLAG_8(dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback
+ disabled in order to function properly. Some Amiga software may also rely
+ on this, but only when accessing specific addresses so additional functionality
+ will be needed. */
+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);
+}
+
+
+static void m68k_op_tas_8_aw(void)
+{
+ uint ea = EA_AW_8();
+ uint dst = m68ki_read_8(ea);
+
+ FLAG_Z = dst;
+ FLAG_N = NFLAG_8(dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback
+ disabled in order to function properly. Some Amiga software may also rely
+ on this, but only when accessing specific addresses so additional functionality
+ will be needed. */
+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);
+}
+
+
+static void m68k_op_tas_8_al(void)
+{
+ uint ea = EA_AL_8();
+ uint dst = m68ki_read_8(ea);
+
+ FLAG_Z = dst;
+ FLAG_N = NFLAG_8(dst);
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+
+ /* The Genesis/Megadrive games Gargoyles and Ex-Mutants need the TAS writeback
+ disabled in order to function properly. Some Amiga software may also rely
+ on this, but only when accessing specific addresses so additional functionality
+ will be needed. */
+ if (m68ki_tas_callback()) m68ki_write_8(ea, dst | 0x80);
+}
+
+
+static void m68k_op_trap(void)
+{
+ /* Trap#n stacks exception frame type 0 */
+ m68ki_exception_trapN(EXCEPTION_TRAP_BASE + (REG_IR & 0xf)); /* HJB 990403 */
+}
+
+
+static void m68k_op_trapv(void)
+{
+ if(COND_VC())
+ {
+ return;
+ }
+ m68ki_exception_trap(EXCEPTION_TRAPV); /* HJB 990403 */
+}
+
+
+static void m68k_op_tst_8_d(void)
+{
+ uint res = MASK_OUT_ABOVE_8(DY);
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_8_ai(void)
+{
+ uint res = OPER_AY_AI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_8_pi(void)
+{
+ uint res = OPER_AY_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_8_pi7(void)
+{
+ uint res = OPER_A7_PI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_8_pd(void)
+{
+ uint res = OPER_AY_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_8_pd7(void)
+{
+ uint res = OPER_A7_PD_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_8_di(void)
+{
+ uint res = OPER_AY_DI_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_8_ix(void)
+{
+ uint res = OPER_AY_IX_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_8_aw(void)
+{
+ uint res = OPER_AW_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_8_al(void)
+{
+ uint res = OPER_AL_8();
+
+ FLAG_N = NFLAG_8(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_16_d(void)
+{
+ uint res = MASK_OUT_ABOVE_16(DY);
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_16_ai(void)
+{
+ uint res = OPER_AY_AI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_16_pi(void)
+{
+ uint res = OPER_AY_PI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_16_pd(void)
+{
+ uint res = OPER_AY_PD_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_16_di(void)
+{
+ uint res = OPER_AY_DI_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_16_ix(void)
+{
+ uint res = OPER_AY_IX_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_16_aw(void)
+{
+ uint res = OPER_AW_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_16_al(void)
+{
+ uint res = OPER_AL_16();
+
+ FLAG_N = NFLAG_16(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_32_d(void)
+{
+ uint res = DY;
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_32_ai(void)
+{
+ uint res = OPER_AY_AI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_32_pi(void)
+{
+ uint res = OPER_AY_PI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_32_pd(void)
+{
+ uint res = OPER_AY_PD_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_32_di(void)
+{
+ uint res = OPER_AY_DI_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_32_ix(void)
+{
+ uint res = OPER_AY_IX_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_32_aw(void)
+{
+ uint res = OPER_AW_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_tst_32_al(void)
+{
+ uint res = OPER_AL_32();
+
+ FLAG_N = NFLAG_32(res);
+ FLAG_Z = res;
+ FLAG_V = VFLAG_CLEAR;
+ FLAG_C = CFLAG_CLEAR;
+}
+
+
+static void m68k_op_unlk_32_a7(void)
+{
+ REG_A[7] = m68ki_read_32(REG_A[7]);
+}
+
+
+static void m68k_op_unlk_32(void)
+{
+ uint* r_dst = &AY;
+
+ REG_A[7] = *r_dst;
+ *r_dst = m68ki_pull_32();
+}
+
+
+/* ======================================================================== */
+/* ========================= OPCODE TABLE BUILDER ========================= */
+/* ======================================================================== */
+
+#ifndef BUILD_TABLES
+ /* (NumPlay: the table is m68k_tab.h, made by tools/m68ktab.py) */
+#else
+
+/* This is used to generate the opcode handler jump table */
+typedef struct
+{
+ void (*opcode_handler)(void); /* handler function */
+ unsigned int mask; /* mask on opcode */
+ unsigned int match; /* what to match after masking */
+ unsigned char cycles; /* cycles each cpu type takes */
+} opcode_handler_struct;
+
+/* opcode handler jump table */
+static void (*m68ki_instruction_jump_table[0x10000])(void);
+
+/* Opcode handler table */
+static const opcode_handler_struct m68k_opcode_handler_table[] =
+{
+/* function mask match cyc */
+ {m68k_op_1010 , 0xf000, 0xa000, 4},
+ {m68k_op_1111 , 0xf000, 0xf000, 4},
+ {m68k_op_moveq_32 , 0xf100, 0x7000, 4},
+ {m68k_op_bra_8 , 0xff00, 0x6000, 10},
+ {m68k_op_bsr_8 , 0xff00, 0x6100, 18},
+ {m68k_op_bhi_8 , 0xff00, 0x6200, 10},
+ {m68k_op_bls_8 , 0xff00, 0x6300, 10},
+ {m68k_op_bcc_8 , 0xff00, 0x6400, 10},
+ {m68k_op_bcs_8 , 0xff00, 0x6500, 10},
+ {m68k_op_bne_8 , 0xff00, 0x6600, 10},
+ {m68k_op_beq_8 , 0xff00, 0x6700, 10},
+ {m68k_op_bvc_8 , 0xff00, 0x6800, 10},
+ {m68k_op_bvs_8 , 0xff00, 0x6900, 10},
+ {m68k_op_bpl_8 , 0xff00, 0x6a00, 10},
+ {m68k_op_bmi_8 , 0xff00, 0x6b00, 10},
+ {m68k_op_bge_8 , 0xff00, 0x6c00, 10},
+ {m68k_op_blt_8 , 0xff00, 0x6d00, 10},
+ {m68k_op_bgt_8 , 0xff00, 0x6e00, 10},
+ {m68k_op_ble_8 , 0xff00, 0x6f00, 10},
+ {m68k_op_btst_32_r_d , 0xf1f8, 0x0100, 6},
+ {m68k_op_movep_16_er , 0xf1f8, 0x0108, 16},
+ {m68k_op_btst_8_r_ai , 0xf1f8, 0x0110, 8},
+ {m68k_op_btst_8_r_pi , 0xf1f8, 0x0118, 8},
+ {m68k_op_btst_8_r_pd , 0xf1f8, 0x0120, 10},
+ {m68k_op_btst_8_r_di , 0xf1f8, 0x0128, 12},
+ {m68k_op_btst_8_r_ix , 0xf1f8, 0x0130, 14},
+ {m68k_op_bchg_32_r_d , 0xf1f8, 0x0140, 8},
+ {m68k_op_movep_32_er , 0xf1f8, 0x0148, 24},
+ {m68k_op_bchg_8_r_ai , 0xf1f8, 0x0150, 12},
+ {m68k_op_bchg_8_r_pi , 0xf1f8, 0x0158, 12},
+ {m68k_op_bchg_8_r_pd , 0xf1f8, 0x0160, 14},
+ {m68k_op_bchg_8_r_di , 0xf1f8, 0x0168, 16},
+ {m68k_op_bchg_8_r_ix , 0xf1f8, 0x0170, 18},
+ {m68k_op_bclr_32_r_d , 0xf1f8, 0x0180, 10},
+ {m68k_op_movep_16_re , 0xf1f8, 0x0188, 16},
+ {m68k_op_bclr_8_r_ai , 0xf1f8, 0x0190, 12},
+ {m68k_op_bclr_8_r_pi , 0xf1f8, 0x0198, 12},
+ {m68k_op_bclr_8_r_pd , 0xf1f8, 0x01a0, 14},
+ {m68k_op_bclr_8_r_di , 0xf1f8, 0x01a8, 16},
+ {m68k_op_bclr_8_r_ix , 0xf1f8, 0x01b0, 18},
+ {m68k_op_bset_32_r_d , 0xf1f8, 0x01c0, 8},
+ {m68k_op_movep_32_re , 0xf1f8, 0x01c8, 24},
+ {m68k_op_bset_8_r_ai , 0xf1f8, 0x01d0, 12},
+ {m68k_op_bset_8_r_pi , 0xf1f8, 0x01d8, 12},
+ {m68k_op_bset_8_r_pd , 0xf1f8, 0x01e0, 14},
+ {m68k_op_bset_8_r_di , 0xf1f8, 0x01e8, 16},
+ {m68k_op_bset_8_r_ix , 0xf1f8, 0x01f0, 18},
+ {m68k_op_move_8_d_d , 0xf1f8, 0x1000, 4},
+ {m68k_op_move_8_d_ai , 0xf1f8, 0x1010, 8},
+ {m68k_op_move_8_d_pi , 0xf1f8, 0x1018, 8},
+ {m68k_op_move_8_d_pd , 0xf1f8, 0x1020, 10},
+ {m68k_op_move_8_d_di , 0xf1f8, 0x1028, 12},
+ {m68k_op_move_8_d_ix , 0xf1f8, 0x1030, 14},
+ {m68k_op_move_8_ai_d , 0xf1f8, 0x1080, 8},
+ {m68k_op_move_8_ai_ai , 0xf1f8, 0x1090, 12},
+ {m68k_op_move_8_ai_pi , 0xf1f8, 0x1098, 12},
+ {m68k_op_move_8_ai_pd , 0xf1f8, 0x10a0, 14},
+ {m68k_op_move_8_ai_di , 0xf1f8, 0x10a8, 16},
+ {m68k_op_move_8_ai_ix , 0xf1f8, 0x10b0, 18},
+ {m68k_op_move_8_pi_d , 0xf1f8, 0x10c0, 8},
+ {m68k_op_move_8_pi_ai , 0xf1f8, 0x10d0, 12},
+ {m68k_op_move_8_pi_pi , 0xf1f8, 0x10d8, 12},
+ {m68k_op_move_8_pi_pd , 0xf1f8, 0x10e0, 14},
+ {m68k_op_move_8_pi_di , 0xf1f8, 0x10e8, 16},
+ {m68k_op_move_8_pi_ix , 0xf1f8, 0x10f0, 18},
+ {m68k_op_move_8_pd_d , 0xf1f8, 0x1100, 8},
+ {m68k_op_move_8_pd_ai , 0xf1f8, 0x1110, 12},
+ {m68k_op_move_8_pd_pi , 0xf1f8, 0x1118, 12},
+ {m68k_op_move_8_pd_pd , 0xf1f8, 0x1120, 14},
+ {m68k_op_move_8_pd_di , 0xf1f8, 0x1128, 16},
+ {m68k_op_move_8_pd_ix , 0xf1f8, 0x1130, 18},
+ {m68k_op_move_8_di_d , 0xf1f8, 0x1140, 12},
+ {m68k_op_move_8_di_ai , 0xf1f8, 0x1150, 16},
+ {m68k_op_move_8_di_pi , 0xf1f8, 0x1158, 16},
+ {m68k_op_move_8_di_pd , 0xf1f8, 0x1160, 18},
+ {m68k_op_move_8_di_di , 0xf1f8, 0x1168, 20},
+ {m68k_op_move_8_di_ix , 0xf1f8, 0x1170, 22},
+ {m68k_op_move_8_ix_d , 0xf1f8, 0x1180, 14},
+ {m68k_op_move_8_ix_ai , 0xf1f8, 0x1190, 18},
+ {m68k_op_move_8_ix_pi , 0xf1f8, 0x1198, 18},
+ {m68k_op_move_8_ix_pd , 0xf1f8, 0x11a0, 20},
+ {m68k_op_move_8_ix_di , 0xf1f8, 0x11a8, 22},
+ {m68k_op_move_8_ix_ix , 0xf1f8, 0x11b0, 24},
+ {m68k_op_move_32_d_d , 0xf1f8, 0x2000, 4},
+ {m68k_op_move_32_d_a , 0xf1f8, 0x2008, 4},
+ {m68k_op_move_32_d_ai , 0xf1f8, 0x2010, 12},
+ {m68k_op_move_32_d_pi , 0xf1f8, 0x2018, 12},
+ {m68k_op_move_32_d_pd , 0xf1f8, 0x2020, 14},
+ {m68k_op_move_32_d_di , 0xf1f8, 0x2028, 16},
+ {m68k_op_move_32_d_ix , 0xf1f8, 0x2030, 18},
+ {m68k_op_movea_32_d , 0xf1f8, 0x2040, 4},
+ {m68k_op_movea_32_a , 0xf1f8, 0x2048, 4},
+ {m68k_op_movea_32_ai , 0xf1f8, 0x2050, 12},
+ {m68k_op_movea_32_pi , 0xf1f8, 0x2058, 12},
+ {m68k_op_movea_32_pd , 0xf1f8, 0x2060, 14},
+ {m68k_op_movea_32_di , 0xf1f8, 0x2068, 16},
+ {m68k_op_movea_32_ix , 0xf1f8, 0x2070, 18},
+ {m68k_op_move_32_ai_d , 0xf1f8, 0x2080, 12},
+ {m68k_op_move_32_ai_a , 0xf1f8, 0x2088, 12},
+ {m68k_op_move_32_ai_ai , 0xf1f8, 0x2090, 20},
+ {m68k_op_move_32_ai_pi , 0xf1f8, 0x2098, 20},
+ {m68k_op_move_32_ai_pd , 0xf1f8, 0x20a0, 22},
+ {m68k_op_move_32_ai_di , 0xf1f8, 0x20a8, 24},
+ {m68k_op_move_32_ai_ix , 0xf1f8, 0x20b0, 26},
+ {m68k_op_move_32_pi_d , 0xf1f8, 0x20c0, 12},
+ {m68k_op_move_32_pi_a , 0xf1f8, 0x20c8, 12},
+ {m68k_op_move_32_pi_ai , 0xf1f8, 0x20d0, 20},
+ {m68k_op_move_32_pi_pi , 0xf1f8, 0x20d8, 20},
+ {m68k_op_move_32_pi_pd , 0xf1f8, 0x20e0, 22},
+ {m68k_op_move_32_pi_di , 0xf1f8, 0x20e8, 24},
+ {m68k_op_move_32_pi_ix , 0xf1f8, 0x20f0, 26},
+ {m68k_op_move_32_pd_d , 0xf1f8, 0x2100, 12},
+ {m68k_op_move_32_pd_a , 0xf1f8, 0x2108, 12},
+ {m68k_op_move_32_pd_ai , 0xf1f8, 0x2110, 20},
+ {m68k_op_move_32_pd_pi , 0xf1f8, 0x2118, 20},
+ {m68k_op_move_32_pd_pd , 0xf1f8, 0x2120, 22},
+ {m68k_op_move_32_pd_di , 0xf1f8, 0x2128, 24},
+ {m68k_op_move_32_pd_ix , 0xf1f8, 0x2130, 26},
+ {m68k_op_move_32_di_d , 0xf1f8, 0x2140, 16},
+ {m68k_op_move_32_di_a , 0xf1f8, 0x2148, 16},
+ {m68k_op_move_32_di_ai , 0xf1f8, 0x2150, 24},
+ {m68k_op_move_32_di_pi , 0xf1f8, 0x2158, 24},
+ {m68k_op_move_32_di_pd , 0xf1f8, 0x2160, 26},
+ {m68k_op_move_32_di_di , 0xf1f8, 0x2168, 28},
+ {m68k_op_move_32_di_ix , 0xf1f8, 0x2170, 30},
+ {m68k_op_move_32_ix_d , 0xf1f8, 0x2180, 18},
+ {m68k_op_move_32_ix_a , 0xf1f8, 0x2188, 18},
+ {m68k_op_move_32_ix_ai , 0xf1f8, 0x2190, 26},
+ {m68k_op_move_32_ix_pi , 0xf1f8, 0x2198, 26},
+ {m68k_op_move_32_ix_pd , 0xf1f8, 0x21a0, 28},
+ {m68k_op_move_32_ix_di , 0xf1f8, 0x21a8, 30},
+ {m68k_op_move_32_ix_ix , 0xf1f8, 0x21b0, 32},
+ {m68k_op_move_16_d_d , 0xf1f8, 0x3000, 4},
+ {m68k_op_move_16_d_a , 0xf1f8, 0x3008, 4},
+ {m68k_op_move_16_d_ai , 0xf1f8, 0x3010, 8},
+ {m68k_op_move_16_d_pi , 0xf1f8, 0x3018, 8},
+ {m68k_op_move_16_d_pd , 0xf1f8, 0x3020, 10},
+ {m68k_op_move_16_d_di , 0xf1f8, 0x3028, 12},
+ {m68k_op_move_16_d_ix , 0xf1f8, 0x3030, 14},
+ {m68k_op_movea_16_d , 0xf1f8, 0x3040, 4},
+ {m68k_op_movea_16_a , 0xf1f8, 0x3048, 4},
+ {m68k_op_movea_16_ai , 0xf1f8, 0x3050, 8},
+ {m68k_op_movea_16_pi , 0xf1f8, 0x3058, 8},
+ {m68k_op_movea_16_pd , 0xf1f8, 0x3060, 10},
+ {m68k_op_movea_16_di , 0xf1f8, 0x3068, 12},
+ {m68k_op_movea_16_ix , 0xf1f8, 0x3070, 14},
+ {m68k_op_move_16_ai_d , 0xf1f8, 0x3080, 8},
+ {m68k_op_move_16_ai_a , 0xf1f8, 0x3088, 8},
+ {m68k_op_move_16_ai_ai , 0xf1f8, 0x3090, 12},
+ {m68k_op_move_16_ai_pi , 0xf1f8, 0x3098, 12},
+ {m68k_op_move_16_ai_pd , 0xf1f8, 0x30a0, 14},
+ {m68k_op_move_16_ai_di , 0xf1f8, 0x30a8, 16},
+ {m68k_op_move_16_ai_ix , 0xf1f8, 0x30b0, 18},
+ {m68k_op_move_16_pi_d , 0xf1f8, 0x30c0, 8},
+ {m68k_op_move_16_pi_a , 0xf1f8, 0x30c8, 8},
+ {m68k_op_move_16_pi_ai , 0xf1f8, 0x30d0, 12},
+ {m68k_op_move_16_pi_pi , 0xf1f8, 0x30d8, 12},
+ {m68k_op_move_16_pi_pd , 0xf1f8, 0x30e0, 14},
+ {m68k_op_move_16_pi_di , 0xf1f8, 0x30e8, 16},
+ {m68k_op_move_16_pi_ix , 0xf1f8, 0x30f0, 18},
+ {m68k_op_move_16_pd_d , 0xf1f8, 0x3100, 8},
+ {m68k_op_move_16_pd_a , 0xf1f8, 0x3108, 8},
+ {m68k_op_move_16_pd_ai , 0xf1f8, 0x3110, 12},
+ {m68k_op_move_16_pd_pi , 0xf1f8, 0x3118, 12},
+ {m68k_op_move_16_pd_pd , 0xf1f8, 0x3120, 14},
+ {m68k_op_move_16_pd_di , 0xf1f8, 0x3128, 16},
+ {m68k_op_move_16_pd_ix , 0xf1f8, 0x3130, 18},
+ {m68k_op_move_16_di_d , 0xf1f8, 0x3140, 12},
+ {m68k_op_move_16_di_a , 0xf1f8, 0x3148, 12},
+ {m68k_op_move_16_di_ai , 0xf1f8, 0x3150, 16},
+ {m68k_op_move_16_di_pi , 0xf1f8, 0x3158, 16},
+ {m68k_op_move_16_di_pd , 0xf1f8, 0x3160, 18},
+ {m68k_op_move_16_di_di , 0xf1f8, 0x3168, 20},
+ {m68k_op_move_16_di_ix , 0xf1f8, 0x3170, 22},
+ {m68k_op_move_16_ix_d , 0xf1f8, 0x3180, 14},
+ {m68k_op_move_16_ix_a , 0xf1f8, 0x3188, 14},
+ {m68k_op_move_16_ix_ai , 0xf1f8, 0x3190, 18},
+ {m68k_op_move_16_ix_pi , 0xf1f8, 0x3198, 18},
+ {m68k_op_move_16_ix_pd , 0xf1f8, 0x31a0, 20},
+ {m68k_op_move_16_ix_di , 0xf1f8, 0x31a8, 22},
+ {m68k_op_move_16_ix_ix , 0xf1f8, 0x31b0, 24},
+ {m68k_op_chk_16_d , 0xf1f8, 0x4180, 10},
+ {m68k_op_chk_16_ai , 0xf1f8, 0x4190, 14},
+ {m68k_op_chk_16_pi , 0xf1f8, 0x4198, 14},
+ {m68k_op_chk_16_pd , 0xf1f8, 0x41a0, 16},
+ {m68k_op_chk_16_di , 0xf1f8, 0x41a8, 18},
+ {m68k_op_chk_16_ix , 0xf1f8, 0x41b0, 20},
+ {m68k_op_lea_32_ai , 0xf1f8, 0x41d0, 4},
+ {m68k_op_lea_32_di , 0xf1f8, 0x41e8, 8},
+ {m68k_op_lea_32_ix , 0xf1f8, 0x41f0, 12},
+ {m68k_op_addq_8_d , 0xf1f8, 0x5000, 4},
+ {m68k_op_addq_8_ai , 0xf1f8, 0x5010, 12},
+ {m68k_op_addq_8_pi , 0xf1f8, 0x5018, 12},
+ {m68k_op_addq_8_pd , 0xf1f8, 0x5020, 14},
+ {m68k_op_addq_8_di , 0xf1f8, 0x5028, 16},
+ {m68k_op_addq_8_ix , 0xf1f8, 0x5030, 18},
+ {m68k_op_addq_16_d , 0xf1f8, 0x5040, 4},
+ {m68k_op_addq_16_a , 0xf1f8, 0x5048, 8}, /* see Yacht.txt */
+ {m68k_op_addq_16_ai , 0xf1f8, 0x5050, 12},
+ {m68k_op_addq_16_pi , 0xf1f8, 0x5058, 12},
+ {m68k_op_addq_16_pd , 0xf1f8, 0x5060, 14},
+ {m68k_op_addq_16_di , 0xf1f8, 0x5068, 16},
+ {m68k_op_addq_16_ix , 0xf1f8, 0x5070, 18},
+ {m68k_op_addq_32_d , 0xf1f8, 0x5080, 8},
+ {m68k_op_addq_32_a , 0xf1f8, 0x5088, 8},
+ {m68k_op_addq_32_ai , 0xf1f8, 0x5090, 20},
+ {m68k_op_addq_32_pi , 0xf1f8, 0x5098, 20},
+ {m68k_op_addq_32_pd , 0xf1f8, 0x50a0, 22},
+ {m68k_op_addq_32_di , 0xf1f8, 0x50a8, 24},
+ {m68k_op_addq_32_ix , 0xf1f8, 0x50b0, 26},
+ {m68k_op_subq_8_d , 0xf1f8, 0x5100, 4},
+ {m68k_op_subq_8_ai , 0xf1f8, 0x5110, 12},
+ {m68k_op_subq_8_pi , 0xf1f8, 0x5118, 12},
+ {m68k_op_subq_8_pd , 0xf1f8, 0x5120, 14},
+ {m68k_op_subq_8_di , 0xf1f8, 0x5128, 16},
+ {m68k_op_subq_8_ix , 0xf1f8, 0x5130, 18},
+ {m68k_op_subq_16_d , 0xf1f8, 0x5140, 4},
+ {m68k_op_subq_16_a , 0xf1f8, 0x5148, 8},
+ {m68k_op_subq_16_ai , 0xf1f8, 0x5150, 12},
+ {m68k_op_subq_16_pi , 0xf1f8, 0x5158, 12},
+ {m68k_op_subq_16_pd , 0xf1f8, 0x5160, 14},
+ {m68k_op_subq_16_di , 0xf1f8, 0x5168, 16},
+ {m68k_op_subq_16_ix , 0xf1f8, 0x5170, 18},
+ {m68k_op_subq_32_d , 0xf1f8, 0x5180, 8},
+ {m68k_op_subq_32_a , 0xf1f8, 0x5188, 8},
+ {m68k_op_subq_32_ai , 0xf1f8, 0x5190, 20},
+ {m68k_op_subq_32_pi , 0xf1f8, 0x5198, 20},
+ {m68k_op_subq_32_pd , 0xf1f8, 0x51a0, 22},
+ {m68k_op_subq_32_di , 0xf1f8, 0x51a8, 24},
+ {m68k_op_subq_32_ix , 0xf1f8, 0x51b0, 26},
+ {m68k_op_or_8_er_d , 0xf1f8, 0x8000, 4},
+ {m68k_op_or_8_er_ai , 0xf1f8, 0x8010, 8},
+ {m68k_op_or_8_er_pi , 0xf1f8, 0x8018, 8},
+ {m68k_op_or_8_er_pd , 0xf1f8, 0x8020, 10},
+ {m68k_op_or_8_er_di , 0xf1f8, 0x8028, 12},
+ {m68k_op_or_8_er_ix , 0xf1f8, 0x8030, 14},
+ {m68k_op_or_16_er_d , 0xf1f8, 0x8040, 4},
+ {m68k_op_or_16_er_ai , 0xf1f8, 0x8050, 8},
+ {m68k_op_or_16_er_pi , 0xf1f8, 0x8058, 8},
+ {m68k_op_or_16_er_pd , 0xf1f8, 0x8060, 10},
+ {m68k_op_or_16_er_di , 0xf1f8, 0x8068, 12},
+ {m68k_op_or_16_er_ix , 0xf1f8, 0x8070, 14},
+ {m68k_op_or_32_er_d , 0xf1f8, 0x8080, 8},
+ {m68k_op_or_32_er_ai , 0xf1f8, 0x8090, 14},
+ {m68k_op_or_32_er_pi , 0xf1f8, 0x8098, 14},
+ {m68k_op_or_32_er_pd , 0xf1f8, 0x80a0, 16},
+ {m68k_op_or_32_er_di , 0xf1f8, 0x80a8, 18},
+ {m68k_op_or_32_er_ix , 0xf1f8, 0x80b0, 20},
+ {m68k_op_divu_16_d , 0xf1f8, 0x80c0, 0},
+ {m68k_op_divu_16_ai , 0xf1f8, 0x80d0, 4},
+ {m68k_op_divu_16_pi , 0xf1f8, 0x80d8, 4},
+ {m68k_op_divu_16_pd , 0xf1f8, 0x80e0, 6},
+ {m68k_op_divu_16_di , 0xf1f8, 0x80e8, 8},
+ {m68k_op_divu_16_ix , 0xf1f8, 0x80f0, 10},
+ {m68k_op_sbcd_8_rr , 0xf1f8, 0x8100, 6},
+ {m68k_op_sbcd_8_mm , 0xf1f8, 0x8108, 18},
+ {m68k_op_or_8_re_ai , 0xf1f8, 0x8110, 12},
+ {m68k_op_or_8_re_pi , 0xf1f8, 0x8118, 12},
+ {m68k_op_or_8_re_pd , 0xf1f8, 0x8120, 14},
+ {m68k_op_or_8_re_di , 0xf1f8, 0x8128, 16},
+ {m68k_op_or_8_re_ix , 0xf1f8, 0x8130, 18},
+ {m68k_op_or_16_re_ai , 0xf1f8, 0x8150, 12},
+ {m68k_op_or_16_re_pi , 0xf1f8, 0x8158, 12},
+ {m68k_op_or_16_re_pd , 0xf1f8, 0x8160, 14},
+ {m68k_op_or_16_re_di , 0xf1f8, 0x8168, 16},
+ {m68k_op_or_16_re_ix , 0xf1f8, 0x8170, 18},
+ {m68k_op_or_32_re_ai , 0xf1f8, 0x8190, 20},
+ {m68k_op_or_32_re_pi , 0xf1f8, 0x8198, 20},
+ {m68k_op_or_32_re_pd , 0xf1f8, 0x81a0, 22},
+ {m68k_op_or_32_re_di , 0xf1f8, 0x81a8, 24},
+ {m68k_op_or_32_re_ix , 0xf1f8, 0x81b0, 26},
+ {m68k_op_divs_16_d , 0xf1f8, 0x81c0, 0},
+ {m68k_op_divs_16_ai , 0xf1f8, 0x81d0, 4},
+ {m68k_op_divs_16_pi , 0xf1f8, 0x81d8, 4},
+ {m68k_op_divs_16_pd , 0xf1f8, 0x81e0, 6},
+ {m68k_op_divs_16_di , 0xf1f8, 0x81e8, 8},
+ {m68k_op_divs_16_ix , 0xf1f8, 0x81f0, 10},
+ {m68k_op_sub_8_er_d , 0xf1f8, 0x9000, 4},
+ {m68k_op_sub_8_er_ai , 0xf1f8, 0x9010, 8},
+ {m68k_op_sub_8_er_pi , 0xf1f8, 0x9018, 8},
+ {m68k_op_sub_8_er_pd , 0xf1f8, 0x9020, 10},
+ {m68k_op_sub_8_er_di , 0xf1f8, 0x9028, 12},
+ {m68k_op_sub_8_er_ix , 0xf1f8, 0x9030, 14},
+ {m68k_op_sub_16_er_d , 0xf1f8, 0x9040, 4},
+ {m68k_op_sub_16_er_a , 0xf1f8, 0x9048, 4},
+ {m68k_op_sub_16_er_ai , 0xf1f8, 0x9050, 8},
+ {m68k_op_sub_16_er_pi , 0xf1f8, 0x9058, 8},
+ {m68k_op_sub_16_er_pd , 0xf1f8, 0x9060, 10},
+ {m68k_op_sub_16_er_di , 0xf1f8, 0x9068, 12},
+ {m68k_op_sub_16_er_ix , 0xf1f8, 0x9070, 14},
+ {m68k_op_sub_32_er_d , 0xf1f8, 0x9080, 8},
+ {m68k_op_sub_32_er_a , 0xf1f8, 0x9088, 8},
+ {m68k_op_sub_32_er_ai , 0xf1f8, 0x9090, 14},
+ {m68k_op_sub_32_er_pi , 0xf1f8, 0x9098, 14},
+ {m68k_op_sub_32_er_pd , 0xf1f8, 0x90a0, 16},
+ {m68k_op_sub_32_er_di , 0xf1f8, 0x90a8, 18},
+ {m68k_op_sub_32_er_ix , 0xf1f8, 0x90b0, 20},
+ {m68k_op_suba_16_d , 0xf1f8, 0x90c0, 8},
+ {m68k_op_suba_16_a , 0xf1f8, 0x90c8, 8},
+ {m68k_op_suba_16_ai , 0xf1f8, 0x90d0, 12},
+ {m68k_op_suba_16_pi , 0xf1f8, 0x90d8, 12},
+ {m68k_op_suba_16_pd , 0xf1f8, 0x90e0, 14},
+ {m68k_op_suba_16_di , 0xf1f8, 0x90e8, 16},
+ {m68k_op_suba_16_ix , 0xf1f8, 0x90f0, 18},
+ {m68k_op_subx_8_rr , 0xf1f8, 0x9100, 4},
+ {m68k_op_subx_8_mm , 0xf1f8, 0x9108, 18},
+ {m68k_op_sub_8_re_ai , 0xf1f8, 0x9110, 12},
+ {m68k_op_sub_8_re_pi , 0xf1f8, 0x9118, 12},
+ {m68k_op_sub_8_re_pd , 0xf1f8, 0x9120, 14},
+ {m68k_op_sub_8_re_di , 0xf1f8, 0x9128, 16},
+ {m68k_op_sub_8_re_ix , 0xf1f8, 0x9130, 18},
+ {m68k_op_subx_16_rr , 0xf1f8, 0x9140, 4},
+ {m68k_op_subx_16_mm , 0xf1f8, 0x9148, 18},
+ {m68k_op_sub_16_re_ai , 0xf1f8, 0x9150, 12},
+ {m68k_op_sub_16_re_pi , 0xf1f8, 0x9158, 12},
+ {m68k_op_sub_16_re_pd , 0xf1f8, 0x9160, 14},
+ {m68k_op_sub_16_re_di , 0xf1f8, 0x9168, 16},
+ {m68k_op_sub_16_re_ix , 0xf1f8, 0x9170, 18},
+ {m68k_op_subx_32_rr , 0xf1f8, 0x9180, 8},
+ {m68k_op_subx_32_mm , 0xf1f8, 0x9188, 30},
+ {m68k_op_sub_32_re_ai , 0xf1f8, 0x9190, 20},
+ {m68k_op_sub_32_re_pi , 0xf1f8, 0x9198, 20},
+ {m68k_op_sub_32_re_pd , 0xf1f8, 0x91a0, 22},
+ {m68k_op_sub_32_re_di , 0xf1f8, 0x91a8, 24},
+ {m68k_op_sub_32_re_ix , 0xf1f8, 0x91b0, 26},
+ {m68k_op_suba_32_d , 0xf1f8, 0x91c0, 8},
+ {m68k_op_suba_32_a , 0xf1f8, 0x91c8, 8},
+ {m68k_op_suba_32_ai , 0xf1f8, 0x91d0, 14},
+ {m68k_op_suba_32_pi , 0xf1f8, 0x91d8, 14},
+ {m68k_op_suba_32_pd , 0xf1f8, 0x91e0, 16},
+ {m68k_op_suba_32_di , 0xf1f8, 0x91e8, 18},
+ {m68k_op_suba_32_ix , 0xf1f8, 0x91f0, 20},
+ {m68k_op_cmp_8_d , 0xf1f8, 0xb000, 4},
+ {m68k_op_cmp_8_ai , 0xf1f8, 0xb010, 8},
+ {m68k_op_cmp_8_pi , 0xf1f8, 0xb018, 8},
+ {m68k_op_cmp_8_pd , 0xf1f8, 0xb020, 10},
+ {m68k_op_cmp_8_di , 0xf1f8, 0xb028, 12},
+ {m68k_op_cmp_8_ix , 0xf1f8, 0xb030, 14},
+ {m68k_op_cmp_16_d , 0xf1f8, 0xb040, 4},
+ {m68k_op_cmp_16_a , 0xf1f8, 0xb048, 4},
+ {m68k_op_cmp_16_ai , 0xf1f8, 0xb050, 8},
+ {m68k_op_cmp_16_pi , 0xf1f8, 0xb058, 8},
+ {m68k_op_cmp_16_pd , 0xf1f8, 0xb060, 10},
+ {m68k_op_cmp_16_di , 0xf1f8, 0xb068, 12},
+ {m68k_op_cmp_16_ix , 0xf1f8, 0xb070, 14},
+ {m68k_op_cmp_32_d , 0xf1f8, 0xb080, 6},
+ {m68k_op_cmp_32_a , 0xf1f8, 0xb088, 6},
+ {m68k_op_cmp_32_ai , 0xf1f8, 0xb090, 14},
+ {m68k_op_cmp_32_pi , 0xf1f8, 0xb098, 14},
+ {m68k_op_cmp_32_pd , 0xf1f8, 0xb0a0, 16},
+ {m68k_op_cmp_32_di , 0xf1f8, 0xb0a8, 18},
+ {m68k_op_cmp_32_ix , 0xf1f8, 0xb0b0, 20},
+ {m68k_op_cmpa_16_d , 0xf1f8, 0xb0c0, 6},
+ {m68k_op_cmpa_16_a , 0xf1f8, 0xb0c8, 6},
+ {m68k_op_cmpa_16_ai , 0xf1f8, 0xb0d0, 10},
+ {m68k_op_cmpa_16_pi , 0xf1f8, 0xb0d8, 10},
+ {m68k_op_cmpa_16_pd , 0xf1f8, 0xb0e0, 12},
+ {m68k_op_cmpa_16_di , 0xf1f8, 0xb0e8, 14},
+ {m68k_op_cmpa_16_ix , 0xf1f8, 0xb0f0, 16},
+ {m68k_op_eor_8_d , 0xf1f8, 0xb100, 4},
+ {m68k_op_cmpm_8 , 0xf1f8, 0xb108, 12},
+ {m68k_op_eor_8_ai , 0xf1f8, 0xb110, 12},
+ {m68k_op_eor_8_pi , 0xf1f8, 0xb118, 12},
+ {m68k_op_eor_8_pd , 0xf1f8, 0xb120, 14},
+ {m68k_op_eor_8_di , 0xf1f8, 0xb128, 16},
+ {m68k_op_eor_8_ix , 0xf1f8, 0xb130, 18},
+ {m68k_op_eor_16_d , 0xf1f8, 0xb140, 4},
+ {m68k_op_cmpm_16 , 0xf1f8, 0xb148, 12},
+ {m68k_op_eor_16_ai , 0xf1f8, 0xb150, 12},
+ {m68k_op_eor_16_pi , 0xf1f8, 0xb158, 12},
+ {m68k_op_eor_16_pd , 0xf1f8, 0xb160, 14},
+ {m68k_op_eor_16_di , 0xf1f8, 0xb168, 16},
+ {m68k_op_eor_16_ix , 0xf1f8, 0xb170, 18},
+ {m68k_op_eor_32_d , 0xf1f8, 0xb180, 8},
+ {m68k_op_cmpm_32 , 0xf1f8, 0xb188, 20},
+ {m68k_op_eor_32_ai , 0xf1f8, 0xb190, 20},
+ {m68k_op_eor_32_pi , 0xf1f8, 0xb198, 20},
+ {m68k_op_eor_32_pd , 0xf1f8, 0xb1a0, 22},
+ {m68k_op_eor_32_di , 0xf1f8, 0xb1a8, 24},
+ {m68k_op_eor_32_ix , 0xf1f8, 0xb1b0, 26},
+ {m68k_op_cmpa_32_d , 0xf1f8, 0xb1c0, 6},
+ {m68k_op_cmpa_32_a , 0xf1f8, 0xb1c8, 6},
+ {m68k_op_cmpa_32_ai , 0xf1f8, 0xb1d0, 14},
+ {m68k_op_cmpa_32_pi , 0xf1f8, 0xb1d8, 14},
+ {m68k_op_cmpa_32_pd , 0xf1f8, 0xb1e0, 16},
+ {m68k_op_cmpa_32_di , 0xf1f8, 0xb1e8, 18},
+ {m68k_op_cmpa_32_ix , 0xf1f8, 0xb1f0, 20},
+ {m68k_op_and_8_er_d , 0xf1f8, 0xc000, 4},
+ {m68k_op_and_8_er_ai , 0xf1f8, 0xc010, 8},
+ {m68k_op_and_8_er_pi , 0xf1f8, 0xc018, 8},
+ {m68k_op_and_8_er_pd , 0xf1f8, 0xc020, 10},
+ {m68k_op_and_8_er_di , 0xf1f8, 0xc028, 12},
+ {m68k_op_and_8_er_ix , 0xf1f8, 0xc030, 14},
+ {m68k_op_and_16_er_d , 0xf1f8, 0xc040, 4},
+ {m68k_op_and_16_er_ai , 0xf1f8, 0xc050, 8},
+ {m68k_op_and_16_er_pi , 0xf1f8, 0xc058, 8},
+ {m68k_op_and_16_er_pd , 0xf1f8, 0xc060, 10},
+ {m68k_op_and_16_er_di , 0xf1f8, 0xc068, 12},
+ {m68k_op_and_16_er_ix , 0xf1f8, 0xc070, 14},
+ {m68k_op_and_32_er_d , 0xf1f8, 0xc080, 8},
+ {m68k_op_and_32_er_ai , 0xf1f8, 0xc090, 14},
+ {m68k_op_and_32_er_pi , 0xf1f8, 0xc098, 14},
+ {m68k_op_and_32_er_pd , 0xf1f8, 0xc0a0, 16},
+ {m68k_op_and_32_er_di , 0xf1f8, 0xc0a8, 18},
+ {m68k_op_and_32_er_ix , 0xf1f8, 0xc0b0, 20},
+ {m68k_op_mulu_16_d , 0xf1f8, 0xc0c0, 0},
+ {m68k_op_mulu_16_ai , 0xf1f8, 0xc0d0, 4},
+ {m68k_op_mulu_16_pi , 0xf1f8, 0xc0d8, 4},
+ {m68k_op_mulu_16_pd , 0xf1f8, 0xc0e0, 6},
+ {m68k_op_mulu_16_di , 0xf1f8, 0xc0e8, 8},
+ {m68k_op_mulu_16_ix , 0xf1f8, 0xc0f0, 10},
+ {m68k_op_abcd_8_rr , 0xf1f8, 0xc100, 6},
+ {m68k_op_abcd_8_mm , 0xf1f8, 0xc108, 18},
+ {m68k_op_and_8_re_ai , 0xf1f8, 0xc110, 12},
+ {m68k_op_and_8_re_pi , 0xf1f8, 0xc118, 12},
+ {m68k_op_and_8_re_pd , 0xf1f8, 0xc120, 14},
+ {m68k_op_and_8_re_di , 0xf1f8, 0xc128, 16},
+ {m68k_op_and_8_re_ix , 0xf1f8, 0xc130, 18},
+ {m68k_op_exg_32_dd , 0xf1f8, 0xc140, 6},
+ {m68k_op_exg_32_aa , 0xf1f8, 0xc148, 6},
+ {m68k_op_and_16_re_ai , 0xf1f8, 0xc150, 12},
+ {m68k_op_and_16_re_pi , 0xf1f8, 0xc158, 12},
+ {m68k_op_and_16_re_pd , 0xf1f8, 0xc160, 14},
+ {m68k_op_and_16_re_di , 0xf1f8, 0xc168, 16},
+ {m68k_op_and_16_re_ix , 0xf1f8, 0xc170, 18},
+ {m68k_op_exg_32_da , 0xf1f8, 0xc188, 6},
+ {m68k_op_and_32_re_ai , 0xf1f8, 0xc190, 20},
+ {m68k_op_and_32_re_pi , 0xf1f8, 0xc198, 20},
+ {m68k_op_and_32_re_pd , 0xf1f8, 0xc1a0, 22},
+ {m68k_op_and_32_re_di , 0xf1f8, 0xc1a8, 24},
+ {m68k_op_and_32_re_ix , 0xf1f8, 0xc1b0, 26},
+ {m68k_op_muls_16_d , 0xf1f8, 0xc1c0, 0},
+ {m68k_op_muls_16_ai , 0xf1f8, 0xc1d0, 4},
+ {m68k_op_muls_16_pi , 0xf1f8, 0xc1d8, 4},
+ {m68k_op_muls_16_pd , 0xf1f8, 0xc1e0, 6},
+ {m68k_op_muls_16_di , 0xf1f8, 0xc1e8, 8},
+ {m68k_op_muls_16_ix , 0xf1f8, 0xc1f0, 10},
+ {m68k_op_add_8_er_d , 0xf1f8, 0xd000, 4},
+ {m68k_op_add_8_er_ai , 0xf1f8, 0xd010, 8},
+ {m68k_op_add_8_er_pi , 0xf1f8, 0xd018, 8},
+ {m68k_op_add_8_er_pd , 0xf1f8, 0xd020, 10},
+ {m68k_op_add_8_er_di , 0xf1f8, 0xd028, 12},
+ {m68k_op_add_8_er_ix , 0xf1f8, 0xd030, 14},
+ {m68k_op_add_16_er_d , 0xf1f8, 0xd040, 4},
+ {m68k_op_add_16_er_a , 0xf1f8, 0xd048, 4},
+ {m68k_op_add_16_er_ai , 0xf1f8, 0xd050, 8},
+ {m68k_op_add_16_er_pi , 0xf1f8, 0xd058, 8},
+ {m68k_op_add_16_er_pd , 0xf1f8, 0xd060, 10},
+ {m68k_op_add_16_er_di , 0xf1f8, 0xd068, 12},
+ {m68k_op_add_16_er_ix , 0xf1f8, 0xd070, 14},
+ {m68k_op_add_32_er_d , 0xf1f8, 0xd080, 8},
+ {m68k_op_add_32_er_a , 0xf1f8, 0xd088, 8},
+ {m68k_op_add_32_er_ai , 0xf1f8, 0xd090, 14},
+ {m68k_op_add_32_er_pi , 0xf1f8, 0xd098, 14},
+ {m68k_op_add_32_er_pd , 0xf1f8, 0xd0a0, 16},
+ {m68k_op_add_32_er_di , 0xf1f8, 0xd0a8, 18},
+ {m68k_op_add_32_er_ix , 0xf1f8, 0xd0b0, 20},
+ {m68k_op_adda_16_d , 0xf1f8, 0xd0c0, 8},
+ {m68k_op_adda_16_a , 0xf1f8, 0xd0c8, 8},
+ {m68k_op_adda_16_ai , 0xf1f8, 0xd0d0, 12},
+ {m68k_op_adda_16_pi , 0xf1f8, 0xd0d8, 12},
+ {m68k_op_adda_16_pd , 0xf1f8, 0xd0e0, 14},
+ {m68k_op_adda_16_di , 0xf1f8, 0xd0e8, 16},
+ {m68k_op_adda_16_ix , 0xf1f8, 0xd0f0, 18},
+ {m68k_op_addx_8_rr , 0xf1f8, 0xd100, 4},
+ {m68k_op_addx_8_mm , 0xf1f8, 0xd108, 18},
+ {m68k_op_add_8_re_ai , 0xf1f8, 0xd110, 12},
+ {m68k_op_add_8_re_pi , 0xf1f8, 0xd118, 12},
+ {m68k_op_add_8_re_pd , 0xf1f8, 0xd120, 14},
+ {m68k_op_add_8_re_di , 0xf1f8, 0xd128, 16},
+ {m68k_op_add_8_re_ix , 0xf1f8, 0xd130, 18},
+ {m68k_op_addx_16_rr , 0xf1f8, 0xd140, 4},
+ {m68k_op_addx_16_mm , 0xf1f8, 0xd148, 18},
+ {m68k_op_add_16_re_ai , 0xf1f8, 0xd150, 12},
+ {m68k_op_add_16_re_pi , 0xf1f8, 0xd158, 12},
+ {m68k_op_add_16_re_pd , 0xf1f8, 0xd160, 14},
+ {m68k_op_add_16_re_di , 0xf1f8, 0xd168, 16},
+ {m68k_op_add_16_re_ix , 0xf1f8, 0xd170, 18},
+ {m68k_op_addx_32_rr , 0xf1f8, 0xd180, 8},
+ {m68k_op_addx_32_mm , 0xf1f8, 0xd188, 30},
+ {m68k_op_add_32_re_ai , 0xf1f8, 0xd190, 20},
+ {m68k_op_add_32_re_pi , 0xf1f8, 0xd198, 20},
+ {m68k_op_add_32_re_pd , 0xf1f8, 0xd1a0, 22},
+ {m68k_op_add_32_re_di , 0xf1f8, 0xd1a8, 24},
+ {m68k_op_add_32_re_ix , 0xf1f8, 0xd1b0, 26},
+ {m68k_op_adda_32_d , 0xf1f8, 0xd1c0, 8},
+ {m68k_op_adda_32_a , 0xf1f8, 0xd1c8, 8},
+ {m68k_op_adda_32_ai , 0xf1f8, 0xd1d0, 14},
+ {m68k_op_adda_32_pi , 0xf1f8, 0xd1d8, 14},
+ {m68k_op_adda_32_pd , 0xf1f8, 0xd1e0, 16},
+ {m68k_op_adda_32_di , 0xf1f8, 0xd1e8, 18},
+ {m68k_op_adda_32_ix , 0xf1f8, 0xd1f0, 20},
+ {m68k_op_asr_8_s , 0xf1f8, 0xe000, 6},
+ {m68k_op_lsr_8_s , 0xf1f8, 0xe008, 6},
+ {m68k_op_roxr_8_s , 0xf1f8, 0xe010, 6},
+ {m68k_op_ror_8_s , 0xf1f8, 0xe018, 6},
+ {m68k_op_asr_8_r , 0xf1f8, 0xe020, 6},
+ {m68k_op_lsr_8_r , 0xf1f8, 0xe028, 6},
+ {m68k_op_roxr_8_r , 0xf1f8, 0xe030, 6},
+ {m68k_op_ror_8_r , 0xf1f8, 0xe038, 6},
+ {m68k_op_asr_16_s , 0xf1f8, 0xe040, 6},
+ {m68k_op_lsr_16_s , 0xf1f8, 0xe048, 6},
+ {m68k_op_roxr_16_s , 0xf1f8, 0xe050, 6},
+ {m68k_op_ror_16_s , 0xf1f8, 0xe058, 6},
+ {m68k_op_asr_16_r , 0xf1f8, 0xe060, 6},
+ {m68k_op_lsr_16_r , 0xf1f8, 0xe068, 6},
+ {m68k_op_roxr_16_r , 0xf1f8, 0xe070, 6},
+ {m68k_op_ror_16_r , 0xf1f8, 0xe078, 6},
+ {m68k_op_asr_32_s , 0xf1f8, 0xe080, 8},
+ {m68k_op_lsr_32_s , 0xf1f8, 0xe088, 8},
+ {m68k_op_roxr_32_s , 0xf1f8, 0xe090, 8},
+ {m68k_op_ror_32_s , 0xf1f8, 0xe098, 8},
+ {m68k_op_asr_32_r , 0xf1f8, 0xe0a0, 8},
+ {m68k_op_lsr_32_r , 0xf1f8, 0xe0a8, 8},
+ {m68k_op_roxr_32_r , 0xf1f8, 0xe0b0, 8},
+ {m68k_op_ror_32_r , 0xf1f8, 0xe0b8, 8},
+ {m68k_op_asl_8_s , 0xf1f8, 0xe100, 6},
+ {m68k_op_lsl_8_s , 0xf1f8, 0xe108, 6},
+ {m68k_op_roxl_8_s , 0xf1f8, 0xe110, 6},
+ {m68k_op_rol_8_s , 0xf1f8, 0xe118, 6},
+ {m68k_op_asl_8_r , 0xf1f8, 0xe120, 6},
+ {m68k_op_lsl_8_r , 0xf1f8, 0xe128, 6},
+ {m68k_op_roxl_8_r , 0xf1f8, 0xe130, 6},
+ {m68k_op_rol_8_r , 0xf1f8, 0xe138, 6},
+ {m68k_op_asl_16_s , 0xf1f8, 0xe140, 6},
+ {m68k_op_lsl_16_s , 0xf1f8, 0xe148, 6},
+ {m68k_op_roxl_16_s , 0xf1f8, 0xe150, 6},
+ {m68k_op_rol_16_s , 0xf1f8, 0xe158, 6},
+ {m68k_op_asl_16_r , 0xf1f8, 0xe160, 6},
+ {m68k_op_lsl_16_r , 0xf1f8, 0xe168, 6},
+ {m68k_op_roxl_16_r , 0xf1f8, 0xe170, 6},
+ {m68k_op_rol_16_r , 0xf1f8, 0xe178, 6},
+ {m68k_op_asl_32_s , 0xf1f8, 0xe180, 8},
+ {m68k_op_lsl_32_s , 0xf1f8, 0xe188, 8},
+ {m68k_op_roxl_32_s , 0xf1f8, 0xe190, 8},
+ {m68k_op_rol_32_s , 0xf1f8, 0xe198, 8},
+ {m68k_op_asl_32_r , 0xf1f8, 0xe1a0, 8},
+ {m68k_op_lsl_32_r , 0xf1f8, 0xe1a8, 8},
+ {m68k_op_roxl_32_r , 0xf1f8, 0xe1b0, 8},
+ {m68k_op_rol_32_r , 0xf1f8, 0xe1b8, 8},
+ {m68k_op_trap , 0xfff0, 0x4e40, 4},
+ {m68k_op_btst_8_r_pi7 , 0xf1ff, 0x011f, 8},
+ {m68k_op_btst_8_r_pd7 , 0xf1ff, 0x0127, 10},
+ {m68k_op_btst_8_r_aw , 0xf1ff, 0x0138, 12},
+ {m68k_op_btst_8_r_al , 0xf1ff, 0x0139, 16},
+ {m68k_op_btst_8_r_pcdi , 0xf1ff, 0x013a, 12},
+ {m68k_op_btst_8_r_pcix , 0xf1ff, 0x013b, 14},
+ {m68k_op_btst_8_r_i , 0xf1ff, 0x013c, 10},
+ {m68k_op_bchg_8_r_pi7 , 0xf1ff, 0x015f, 12},
+ {m68k_op_bchg_8_r_pd7 , 0xf1ff, 0x0167, 14},
+ {m68k_op_bchg_8_r_aw , 0xf1ff, 0x0178, 16},
+ {m68k_op_bchg_8_r_al , 0xf1ff, 0x0179, 20},
+ {m68k_op_bclr_8_r_pi7 , 0xf1ff, 0x019f, 12},
+ {m68k_op_bclr_8_r_pd7 , 0xf1ff, 0x01a7, 14},
+ {m68k_op_bclr_8_r_aw , 0xf1ff, 0x01b8, 16},
+ {m68k_op_bclr_8_r_al , 0xf1ff, 0x01b9, 20},
+ {m68k_op_bset_8_r_pi7 , 0xf1ff, 0x01df, 12},
+ {m68k_op_bset_8_r_pd7 , 0xf1ff, 0x01e7, 14},
+ {m68k_op_bset_8_r_aw , 0xf1ff, 0x01f8, 16},
+ {m68k_op_bset_8_r_al , 0xf1ff, 0x01f9, 20},
+ {m68k_op_move_8_d_pi7 , 0xf1ff, 0x101f, 8},
+ {m68k_op_move_8_d_pd7 , 0xf1ff, 0x1027, 10},
+ {m68k_op_move_8_d_aw , 0xf1ff, 0x1038, 12},
+ {m68k_op_move_8_d_al , 0xf1ff, 0x1039, 16},
+ {m68k_op_move_8_d_pcdi , 0xf1ff, 0x103a, 12},
+ {m68k_op_move_8_d_pcix , 0xf1ff, 0x103b, 14},
+ {m68k_op_move_8_d_i , 0xf1ff, 0x103c, 8},
+ {m68k_op_move_8_ai_pi7 , 0xf1ff, 0x109f, 12},
+ {m68k_op_move_8_ai_pd7 , 0xf1ff, 0x10a7, 14},
+ {m68k_op_move_8_ai_aw , 0xf1ff, 0x10b8, 16},
+ {m68k_op_move_8_ai_al , 0xf1ff, 0x10b9, 20},
+ {m68k_op_move_8_ai_pcdi , 0xf1ff, 0x10ba, 16},
+ {m68k_op_move_8_ai_pcix , 0xf1ff, 0x10bb, 18},
+ {m68k_op_move_8_ai_i , 0xf1ff, 0x10bc, 12},
+ {m68k_op_move_8_pi_pi7 , 0xf1ff, 0x10df, 12},
+ {m68k_op_move_8_pi_pd7 , 0xf1ff, 0x10e7, 14},
+ {m68k_op_move_8_pi_aw , 0xf1ff, 0x10f8, 16},
+ {m68k_op_move_8_pi_al , 0xf1ff, 0x10f9, 20},
+ {m68k_op_move_8_pi_pcdi , 0xf1ff, 0x10fa, 16},
+ {m68k_op_move_8_pi_pcix , 0xf1ff, 0x10fb, 18},
+ {m68k_op_move_8_pi_i , 0xf1ff, 0x10fc, 12},
+ {m68k_op_move_8_pd_pi7 , 0xf1ff, 0x111f, 12},
+ {m68k_op_move_8_pd_pd7 , 0xf1ff, 0x1127, 14},
+ {m68k_op_move_8_pd_aw , 0xf1ff, 0x1138, 16},
+ {m68k_op_move_8_pd_al , 0xf1ff, 0x1139, 20},
+ {m68k_op_move_8_pd_pcdi , 0xf1ff, 0x113a, 16},
+ {m68k_op_move_8_pd_pcix , 0xf1ff, 0x113b, 18},
+ {m68k_op_move_8_pd_i , 0xf1ff, 0x113c, 12},
+ {m68k_op_move_8_di_pi7 , 0xf1ff, 0x115f, 16},
+ {m68k_op_move_8_di_pd7 , 0xf1ff, 0x1167, 18},
+ {m68k_op_move_8_di_aw , 0xf1ff, 0x1178, 20},
+ {m68k_op_move_8_di_al , 0xf1ff, 0x1179, 24},
+ {m68k_op_move_8_di_pcdi , 0xf1ff, 0x117a, 20},
+ {m68k_op_move_8_di_pcix , 0xf1ff, 0x117b, 22},
+ {m68k_op_move_8_di_i , 0xf1ff, 0x117c, 16},
+ {m68k_op_move_8_ix_pi7 , 0xf1ff, 0x119f, 18},
+ {m68k_op_move_8_ix_pd7 , 0xf1ff, 0x11a7, 20},
+ {m68k_op_move_8_ix_aw , 0xf1ff, 0x11b8, 22},
+ {m68k_op_move_8_ix_al , 0xf1ff, 0x11b9, 26},
+ {m68k_op_move_8_ix_pcdi , 0xf1ff, 0x11ba, 22},
+ {m68k_op_move_8_ix_pcix , 0xf1ff, 0x11bb, 24},
+ {m68k_op_move_8_ix_i , 0xf1ff, 0x11bc, 18},
+ {m68k_op_move_32_d_aw , 0xf1ff, 0x2038, 16},
+ {m68k_op_move_32_d_al , 0xf1ff, 0x2039, 20},
+ {m68k_op_move_32_d_pcdi , 0xf1ff, 0x203a, 16},
+ {m68k_op_move_32_d_pcix , 0xf1ff, 0x203b, 18},
+ {m68k_op_move_32_d_i , 0xf1ff, 0x203c, 12},
+ {m68k_op_movea_32_aw , 0xf1ff, 0x2078, 16},
+ {m68k_op_movea_32_al , 0xf1ff, 0x2079, 20},
+ {m68k_op_movea_32_pcdi , 0xf1ff, 0x207a, 16},
+ {m68k_op_movea_32_pcix , 0xf1ff, 0x207b, 18},
+ {m68k_op_movea_32_i , 0xf1ff, 0x207c, 12},
+ {m68k_op_move_32_ai_aw , 0xf1ff, 0x20b8, 24},
+ {m68k_op_move_32_ai_al , 0xf1ff, 0x20b9, 28},
+ {m68k_op_move_32_ai_pcdi , 0xf1ff, 0x20ba, 24},
+ {m68k_op_move_32_ai_pcix , 0xf1ff, 0x20bb, 26},
+ {m68k_op_move_32_ai_i , 0xf1ff, 0x20bc, 20},
+ {m68k_op_move_32_pi_aw , 0xf1ff, 0x20f8, 24},
+ {m68k_op_move_32_pi_al , 0xf1ff, 0x20f9, 28},
+ {m68k_op_move_32_pi_pcdi , 0xf1ff, 0x20fa, 24},
+ {m68k_op_move_32_pi_pcix , 0xf1ff, 0x20fb, 26},
+ {m68k_op_move_32_pi_i , 0xf1ff, 0x20fc, 20},
+ {m68k_op_move_32_pd_aw , 0xf1ff, 0x2138, 24},
+ {m68k_op_move_32_pd_al , 0xf1ff, 0x2139, 28},
+ {m68k_op_move_32_pd_pcdi , 0xf1ff, 0x213a, 24},
+ {m68k_op_move_32_pd_pcix , 0xf1ff, 0x213b, 26},
+ {m68k_op_move_32_pd_i , 0xf1ff, 0x213c, 20},
+ {m68k_op_move_32_di_aw , 0xf1ff, 0x2178, 28},
+ {m68k_op_move_32_di_al , 0xf1ff, 0x2179, 32},
+ {m68k_op_move_32_di_pcdi , 0xf1ff, 0x217a, 28},
+ {m68k_op_move_32_di_pcix , 0xf1ff, 0x217b, 30},
+ {m68k_op_move_32_di_i , 0xf1ff, 0x217c, 24},
+ {m68k_op_move_32_ix_aw , 0xf1ff, 0x21b8, 30},
+ {m68k_op_move_32_ix_al , 0xf1ff, 0x21b9, 34},
+ {m68k_op_move_32_ix_pcdi , 0xf1ff, 0x21ba, 30},
+ {m68k_op_move_32_ix_pcix , 0xf1ff, 0x21bb, 32},
+ {m68k_op_move_32_ix_i , 0xf1ff, 0x21bc, 26},
+ {m68k_op_move_16_d_aw , 0xf1ff, 0x3038, 12},
+ {m68k_op_move_16_d_al , 0xf1ff, 0x3039, 16},
+ {m68k_op_move_16_d_pcdi , 0xf1ff, 0x303a, 12},
+ {m68k_op_move_16_d_pcix , 0xf1ff, 0x303b, 14},
+ {m68k_op_move_16_d_i , 0xf1ff, 0x303c, 8},
+ {m68k_op_movea_16_aw , 0xf1ff, 0x3078, 12},
+ {m68k_op_movea_16_al , 0xf1ff, 0x3079, 16},
+ {m68k_op_movea_16_pcdi , 0xf1ff, 0x307a, 12},
+ {m68k_op_movea_16_pcix , 0xf1ff, 0x307b, 14},
+ {m68k_op_movea_16_i , 0xf1ff, 0x307c, 8},
+ {m68k_op_move_16_ai_aw , 0xf1ff, 0x30b8, 16},
+ {m68k_op_move_16_ai_al , 0xf1ff, 0x30b9, 20},
+ {m68k_op_move_16_ai_pcdi , 0xf1ff, 0x30ba, 16},
+ {m68k_op_move_16_ai_pcix , 0xf1ff, 0x30bb, 18},
+ {m68k_op_move_16_ai_i , 0xf1ff, 0x30bc, 12},
+ {m68k_op_move_16_pi_aw , 0xf1ff, 0x30f8, 16},
+ {m68k_op_move_16_pi_al , 0xf1ff, 0x30f9, 20},
+ {m68k_op_move_16_pi_pcdi , 0xf1ff, 0x30fa, 16},
+ {m68k_op_move_16_pi_pcix , 0xf1ff, 0x30fb, 18},
+ {m68k_op_move_16_pi_i , 0xf1ff, 0x30fc, 12},
+ {m68k_op_move_16_pd_aw , 0xf1ff, 0x3138, 16},
+ {m68k_op_move_16_pd_al , 0xf1ff, 0x3139, 20},
+ {m68k_op_move_16_pd_pcdi , 0xf1ff, 0x313a, 16},
+ {m68k_op_move_16_pd_pcix , 0xf1ff, 0x313b, 18},
+ {m68k_op_move_16_pd_i , 0xf1ff, 0x313c, 12},
+ {m68k_op_move_16_di_aw , 0xf1ff, 0x3178, 20},
+ {m68k_op_move_16_di_al , 0xf1ff, 0x3179, 24},
+ {m68k_op_move_16_di_pcdi , 0xf1ff, 0x317a, 20},
+ {m68k_op_move_16_di_pcix , 0xf1ff, 0x317b, 22},
+ {m68k_op_move_16_di_i , 0xf1ff, 0x317c, 16},
+ {m68k_op_move_16_ix_aw , 0xf1ff, 0x31b8, 22},
+ {m68k_op_move_16_ix_al , 0xf1ff, 0x31b9, 26},
+ {m68k_op_move_16_ix_pcdi , 0xf1ff, 0x31ba, 22},
+ {m68k_op_move_16_ix_pcix , 0xf1ff, 0x31bb, 24},
+ {m68k_op_move_16_ix_i , 0xf1ff, 0x31bc, 18},
+ {m68k_op_chk_16_aw , 0xf1ff, 0x41b8, 18},
+ {m68k_op_chk_16_al , 0xf1ff, 0x41b9, 22},
+ {m68k_op_chk_16_pcdi , 0xf1ff, 0x41ba, 18},
+ {m68k_op_chk_16_pcix , 0xf1ff, 0x41bb, 20},
+ {m68k_op_chk_16_i , 0xf1ff, 0x41bc, 14},
+ {m68k_op_lea_32_aw , 0xf1ff, 0x41f8, 8},
+ {m68k_op_lea_32_al , 0xf1ff, 0x41f9, 12},
+ {m68k_op_lea_32_pcdi , 0xf1ff, 0x41fa, 8},
+ {m68k_op_lea_32_pcix , 0xf1ff, 0x41fb, 12},
+ {m68k_op_addq_8_pi7 , 0xf1ff, 0x501f, 12},
+ {m68k_op_addq_8_pd7 , 0xf1ff, 0x5027, 14},
+ {m68k_op_addq_8_aw , 0xf1ff, 0x5038, 16},
+ {m68k_op_addq_8_al , 0xf1ff, 0x5039, 20},
+ {m68k_op_addq_16_aw , 0xf1ff, 0x5078, 16},
+ {m68k_op_addq_16_al , 0xf1ff, 0x5079, 20},
+ {m68k_op_addq_32_aw , 0xf1ff, 0x50b8, 24},
+ {m68k_op_addq_32_al , 0xf1ff, 0x50b9, 28},
+ {m68k_op_subq_8_pi7 , 0xf1ff, 0x511f, 12},
+ {m68k_op_subq_8_pd7 , 0xf1ff, 0x5127, 14},
+ {m68k_op_subq_8_aw , 0xf1ff, 0x5138, 16},
+ {m68k_op_subq_8_al , 0xf1ff, 0x5139, 20},
+ {m68k_op_subq_16_aw , 0xf1ff, 0x5178, 16},
+ {m68k_op_subq_16_al , 0xf1ff, 0x5179, 20},
+ {m68k_op_subq_32_aw , 0xf1ff, 0x51b8, 24},
+ {m68k_op_subq_32_al , 0xf1ff, 0x51b9, 28},
+ {m68k_op_or_8_er_pi7 , 0xf1ff, 0x801f, 8},
+ {m68k_op_or_8_er_pd7 , 0xf1ff, 0x8027, 10},
+ {m68k_op_or_8_er_aw , 0xf1ff, 0x8038, 12},
+ {m68k_op_or_8_er_al , 0xf1ff, 0x8039, 16},
+ {m68k_op_or_8_er_pcdi , 0xf1ff, 0x803a, 12},
+ {m68k_op_or_8_er_pcix , 0xf1ff, 0x803b, 14},
+ {m68k_op_or_8_er_i , 0xf1ff, 0x803c, 8},
+ {m68k_op_or_16_er_aw , 0xf1ff, 0x8078, 12},
+ {m68k_op_or_16_er_al , 0xf1ff, 0x8079, 16},
+ {m68k_op_or_16_er_pcdi , 0xf1ff, 0x807a, 12},
+ {m68k_op_or_16_er_pcix , 0xf1ff, 0x807b, 14},
+ {m68k_op_or_16_er_i , 0xf1ff, 0x807c, 8},
+ {m68k_op_or_32_er_aw , 0xf1ff, 0x80b8, 18},
+ {m68k_op_or_32_er_al , 0xf1ff, 0x80b9, 22},
+ {m68k_op_or_32_er_pcdi , 0xf1ff, 0x80ba, 18},
+ {m68k_op_or_32_er_pcix , 0xf1ff, 0x80bb, 20},
+ {m68k_op_or_32_er_i , 0xf1ff, 0x80bc, 16},
+ {m68k_op_divu_16_aw , 0xf1ff, 0x80f8, 8},
+ {m68k_op_divu_16_al , 0xf1ff, 0x80f9, 12},
+ {m68k_op_divu_16_pcdi , 0xf1ff, 0x80fa, 8},
+ {m68k_op_divu_16_pcix , 0xf1ff, 0x80fb, 10},
+ {m68k_op_divu_16_i , 0xf1ff, 0x80fc, 4},
+ {m68k_op_sbcd_8_mm_ay7 , 0xf1ff, 0x810f, 18},
+ {m68k_op_or_8_re_pi7 , 0xf1ff, 0x811f, 12},
+ {m68k_op_or_8_re_pd7 , 0xf1ff, 0x8127, 14},
+ {m68k_op_or_8_re_aw , 0xf1ff, 0x8138, 16},
+ {m68k_op_or_8_re_al , 0xf1ff, 0x8139, 20},
+ {m68k_op_or_16_re_aw , 0xf1ff, 0x8178, 16},
+ {m68k_op_or_16_re_al , 0xf1ff, 0x8179, 20},
+ {m68k_op_or_32_re_aw , 0xf1ff, 0x81b8, 24},
+ {m68k_op_or_32_re_al , 0xf1ff, 0x81b9, 28},
+ {m68k_op_divs_16_aw , 0xf1ff, 0x81f8, 8},
+ {m68k_op_divs_16_al , 0xf1ff, 0x81f9, 12},
+ {m68k_op_divs_16_pcdi , 0xf1ff, 0x81fa, 8},
+ {m68k_op_divs_16_pcix , 0xf1ff, 0x81fb, 10},
+ {m68k_op_divs_16_i , 0xf1ff, 0x81fc, 4},
+ {m68k_op_sub_8_er_pi7 , 0xf1ff, 0x901f, 8},
+ {m68k_op_sub_8_er_pd7 , 0xf1ff, 0x9027, 10},
+ {m68k_op_sub_8_er_aw , 0xf1ff, 0x9038, 12},
+ {m68k_op_sub_8_er_al , 0xf1ff, 0x9039, 16},
+ {m68k_op_sub_8_er_pcdi , 0xf1ff, 0x903a, 12},
+ {m68k_op_sub_8_er_pcix , 0xf1ff, 0x903b, 14},
+ {m68k_op_sub_8_er_i , 0xf1ff, 0x903c, 8},
+ {m68k_op_sub_16_er_aw , 0xf1ff, 0x9078, 12},
+ {m68k_op_sub_16_er_al , 0xf1ff, 0x9079, 16},
+ {m68k_op_sub_16_er_pcdi , 0xf1ff, 0x907a, 12},
+ {m68k_op_sub_16_er_pcix , 0xf1ff, 0x907b, 14},
+ {m68k_op_sub_16_er_i , 0xf1ff, 0x907c, 8},
+ {m68k_op_sub_32_er_aw , 0xf1ff, 0x90b8, 18},
+ {m68k_op_sub_32_er_al , 0xf1ff, 0x90b9, 22},
+ {m68k_op_sub_32_er_pcdi , 0xf1ff, 0x90ba, 18},
+ {m68k_op_sub_32_er_pcix , 0xf1ff, 0x90bb, 20},
+ {m68k_op_sub_32_er_i , 0xf1ff, 0x90bc, 16},
+ {m68k_op_suba_16_aw , 0xf1ff, 0x90f8, 16},
+ {m68k_op_suba_16_al , 0xf1ff, 0x90f9, 20},
+ {m68k_op_suba_16_pcdi , 0xf1ff, 0x90fa, 16},
+ {m68k_op_suba_16_pcix , 0xf1ff, 0x90fb, 18},
+ {m68k_op_suba_16_i , 0xf1ff, 0x90fc, 12},
+ {m68k_op_subx_8_mm_ay7 , 0xf1ff, 0x910f, 18},
+ {m68k_op_sub_8_re_pi7 , 0xf1ff, 0x911f, 12},
+ {m68k_op_sub_8_re_pd7 , 0xf1ff, 0x9127, 14},
+ {m68k_op_sub_8_re_aw , 0xf1ff, 0x9138, 16},
+ {m68k_op_sub_8_re_al , 0xf1ff, 0x9139, 20},
+ {m68k_op_sub_16_re_aw , 0xf1ff, 0x9178, 16},
+ {m68k_op_sub_16_re_al , 0xf1ff, 0x9179, 20},
+ {m68k_op_sub_32_re_aw , 0xf1ff, 0x91b8, 24},
+ {m68k_op_sub_32_re_al , 0xf1ff, 0x91b9, 28},
+ {m68k_op_suba_32_aw , 0xf1ff, 0x91f8, 18},
+ {m68k_op_suba_32_al , 0xf1ff, 0x91f9, 22},
+ {m68k_op_suba_32_pcdi , 0xf1ff, 0x91fa, 18},
+ {m68k_op_suba_32_pcix , 0xf1ff, 0x91fb, 20},
+ {m68k_op_suba_32_i , 0xf1ff, 0x91fc, 16},
+ {m68k_op_cmp_8_pi7 , 0xf1ff, 0xb01f, 8},
+ {m68k_op_cmp_8_pd7 , 0xf1ff, 0xb027, 10},
+ {m68k_op_cmp_8_aw , 0xf1ff, 0xb038, 12},
+ {m68k_op_cmp_8_al , 0xf1ff, 0xb039, 16},
+ {m68k_op_cmp_8_pcdi , 0xf1ff, 0xb03a, 12},
+ {m68k_op_cmp_8_pcix , 0xf1ff, 0xb03b, 14},
+ {m68k_op_cmp_8_i , 0xf1ff, 0xb03c, 8},
+ {m68k_op_cmp_16_aw , 0xf1ff, 0xb078, 12},
+ {m68k_op_cmp_16_al , 0xf1ff, 0xb079, 16},
+ {m68k_op_cmp_16_pcdi , 0xf1ff, 0xb07a, 12},
+ {m68k_op_cmp_16_pcix , 0xf1ff, 0xb07b, 14},
+ {m68k_op_cmp_16_i , 0xf1ff, 0xb07c, 8},
+ {m68k_op_cmp_32_aw , 0xf1ff, 0xb0b8, 18},
+ {m68k_op_cmp_32_al , 0xf1ff, 0xb0b9, 22},
+ {m68k_op_cmp_32_pcdi , 0xf1ff, 0xb0ba, 18},
+ {m68k_op_cmp_32_pcix , 0xf1ff, 0xb0bb, 20},
+ {m68k_op_cmp_32_i , 0xf1ff, 0xb0bc, 14},
+ {m68k_op_cmpa_16_aw , 0xf1ff, 0xb0f8, 14},
+ {m68k_op_cmpa_16_al , 0xf1ff, 0xb0f9, 18},
+ {m68k_op_cmpa_16_pcdi , 0xf1ff, 0xb0fa, 14},
+ {m68k_op_cmpa_16_pcix , 0xf1ff, 0xb0fb, 16},
+ {m68k_op_cmpa_16_i , 0xf1ff, 0xb0fc, 10},
+ {m68k_op_cmpm_8_ay7 , 0xf1ff, 0xb10f, 12},
+ {m68k_op_eor_8_pi7 , 0xf1ff, 0xb11f, 12},
+ {m68k_op_eor_8_pd7 , 0xf1ff, 0xb127, 14},
+ {m68k_op_eor_8_aw , 0xf1ff, 0xb138, 16},
+ {m68k_op_eor_8_al , 0xf1ff, 0xb139, 20},
+ {m68k_op_eor_16_aw , 0xf1ff, 0xb178, 16},
+ {m68k_op_eor_16_al , 0xf1ff, 0xb179, 20},
+ {m68k_op_eor_32_aw , 0xf1ff, 0xb1b8, 24},
+ {m68k_op_eor_32_al , 0xf1ff, 0xb1b9, 28},
+ {m68k_op_cmpa_32_aw , 0xf1ff, 0xb1f8, 18},
+ {m68k_op_cmpa_32_al , 0xf1ff, 0xb1f9, 22},
+ {m68k_op_cmpa_32_pcdi , 0xf1ff, 0xb1fa, 18},
+ {m68k_op_cmpa_32_pcix , 0xf1ff, 0xb1fb, 20},
+ {m68k_op_cmpa_32_i , 0xf1ff, 0xb1fc, 14},
+ {m68k_op_and_8_er_pi7 , 0xf1ff, 0xc01f, 8},
+ {m68k_op_and_8_er_pd7 , 0xf1ff, 0xc027, 10},
+ {m68k_op_and_8_er_aw , 0xf1ff, 0xc038, 12},
+ {m68k_op_and_8_er_al , 0xf1ff, 0xc039, 16},
+ {m68k_op_and_8_er_pcdi , 0xf1ff, 0xc03a, 12},
+ {m68k_op_and_8_er_pcix , 0xf1ff, 0xc03b, 14},
+ {m68k_op_and_8_er_i , 0xf1ff, 0xc03c, 8},
+ {m68k_op_and_16_er_aw , 0xf1ff, 0xc078, 12},
+ {m68k_op_and_16_er_al , 0xf1ff, 0xc079, 16},
+ {m68k_op_and_16_er_pcdi , 0xf1ff, 0xc07a, 12},
+ {m68k_op_and_16_er_pcix , 0xf1ff, 0xc07b, 14},
+ {m68k_op_and_16_er_i , 0xf1ff, 0xc07c, 8},
+ {m68k_op_and_32_er_aw , 0xf1ff, 0xc0b8, 18},
+ {m68k_op_and_32_er_al , 0xf1ff, 0xc0b9, 22},
+ {m68k_op_and_32_er_pcdi , 0xf1ff, 0xc0ba, 18},
+ {m68k_op_and_32_er_pcix , 0xf1ff, 0xc0bb, 20},
+ {m68k_op_and_32_er_i , 0xf1ff, 0xc0bc, 16},
+ {m68k_op_mulu_16_aw , 0xf1ff, 0xc0f8, 8},
+ {m68k_op_mulu_16_al , 0xf1ff, 0xc0f9, 12},
+ {m68k_op_mulu_16_pcdi , 0xf1ff, 0xc0fa, 8},
+ {m68k_op_mulu_16_pcix , 0xf1ff, 0xc0fb, 10},
+ {m68k_op_mulu_16_i , 0xf1ff, 0xc0fc, 4},
+ {m68k_op_abcd_8_mm_ay7 , 0xf1ff, 0xc10f, 18},
+ {m68k_op_and_8_re_pi7 , 0xf1ff, 0xc11f, 12},
+ {m68k_op_and_8_re_pd7 , 0xf1ff, 0xc127, 14},
+ {m68k_op_and_8_re_aw , 0xf1ff, 0xc138, 16},
+ {m68k_op_and_8_re_al , 0xf1ff, 0xc139, 20},
+ {m68k_op_and_16_re_aw , 0xf1ff, 0xc178, 16},
+ {m68k_op_and_16_re_al , 0xf1ff, 0xc179, 20},
+ {m68k_op_and_32_re_aw , 0xf1ff, 0xc1b8, 24},
+ {m68k_op_and_32_re_al , 0xf1ff, 0xc1b9, 28},
+ {m68k_op_muls_16_aw , 0xf1ff, 0xc1f8, 8},
+ {m68k_op_muls_16_al , 0xf1ff, 0xc1f9, 12},
+ {m68k_op_muls_16_pcdi , 0xf1ff, 0xc1fa, 8},
+ {m68k_op_muls_16_pcix , 0xf1ff, 0xc1fb, 10},
+ {m68k_op_muls_16_i , 0xf1ff, 0xc1fc, 4},
+ {m68k_op_add_8_er_pi7 , 0xf1ff, 0xd01f, 8},
+ {m68k_op_add_8_er_pd7 , 0xf1ff, 0xd027, 10},
+ {m68k_op_add_8_er_aw , 0xf1ff, 0xd038, 12},
+ {m68k_op_add_8_er_al , 0xf1ff, 0xd039, 16},
+ {m68k_op_add_8_er_pcdi , 0xf1ff, 0xd03a, 12},
+ {m68k_op_add_8_er_pcix , 0xf1ff, 0xd03b, 14},
+ {m68k_op_add_8_er_i , 0xf1ff, 0xd03c, 8},
+ {m68k_op_add_16_er_aw , 0xf1ff, 0xd078, 12},
+ {m68k_op_add_16_er_al , 0xf1ff, 0xd079, 16},
+ {m68k_op_add_16_er_pcdi , 0xf1ff, 0xd07a, 12},
+ {m68k_op_add_16_er_pcix , 0xf1ff, 0xd07b, 14},
+ {m68k_op_add_16_er_i , 0xf1ff, 0xd07c, 8},
+ {m68k_op_add_32_er_aw , 0xf1ff, 0xd0b8, 18},
+ {m68k_op_add_32_er_al , 0xf1ff, 0xd0b9, 22},
+ {m68k_op_add_32_er_pcdi , 0xf1ff, 0xd0ba, 18},
+ {m68k_op_add_32_er_pcix , 0xf1ff, 0xd0bb, 20},
+ {m68k_op_add_32_er_i , 0xf1ff, 0xd0bc, 16},
+ {m68k_op_adda_16_aw , 0xf1ff, 0xd0f8, 16},
+ {m68k_op_adda_16_al , 0xf1ff, 0xd0f9, 20},
+ {m68k_op_adda_16_pcdi , 0xf1ff, 0xd0fa, 16},
+ {m68k_op_adda_16_pcix , 0xf1ff, 0xd0fb, 18},
+ {m68k_op_adda_16_i , 0xf1ff, 0xd0fc, 12},
+ {m68k_op_addx_8_mm_ay7 , 0xf1ff, 0xd10f, 18},
+ {m68k_op_add_8_re_pi7 , 0xf1ff, 0xd11f, 12},
+ {m68k_op_add_8_re_pd7 , 0xf1ff, 0xd127, 14},
+ {m68k_op_add_8_re_aw , 0xf1ff, 0xd138, 16},
+ {m68k_op_add_8_re_al , 0xf1ff, 0xd139, 20},
+ {m68k_op_add_16_re_aw , 0xf1ff, 0xd178, 16},
+ {m68k_op_add_16_re_al , 0xf1ff, 0xd179, 20},
+ {m68k_op_add_32_re_aw , 0xf1ff, 0xd1b8, 24},
+ {m68k_op_add_32_re_al , 0xf1ff, 0xd1b9, 28},
+ {m68k_op_adda_32_aw , 0xf1ff, 0xd1f8, 18},
+ {m68k_op_adda_32_al , 0xf1ff, 0xd1f9, 22},
+ {m68k_op_adda_32_pcdi , 0xf1ff, 0xd1fa, 18},
+ {m68k_op_adda_32_pcix , 0xf1ff, 0xd1fb, 20},
+ {m68k_op_adda_32_i , 0xf1ff, 0xd1fc, 16},
+ {m68k_op_ori_8_d , 0xfff8, 0x0000, 8},
+ {m68k_op_ori_8_ai , 0xfff8, 0x0010, 16},
+ {m68k_op_ori_8_pi , 0xfff8, 0x0018, 16},
+ {m68k_op_ori_8_pd , 0xfff8, 0x0020, 18},
+ {m68k_op_ori_8_di , 0xfff8, 0x0028, 20},
+ {m68k_op_ori_8_ix , 0xfff8, 0x0030, 22},
+ {m68k_op_ori_16_d , 0xfff8, 0x0040, 8},
+ {m68k_op_ori_16_ai , 0xfff8, 0x0050, 16},
+ {m68k_op_ori_16_pi , 0xfff8, 0x0058, 16},
+ {m68k_op_ori_16_pd , 0xfff8, 0x0060, 18},
+ {m68k_op_ori_16_di , 0xfff8, 0x0068, 20},
+ {m68k_op_ori_16_ix , 0xfff8, 0x0070, 22},
+ {m68k_op_ori_32_d , 0xfff8, 0x0080, 16},
+ {m68k_op_ori_32_ai , 0xfff8, 0x0090, 28},
+ {m68k_op_ori_32_pi , 0xfff8, 0x0098, 28},
+ {m68k_op_ori_32_pd , 0xfff8, 0x00a0, 30},
+ {m68k_op_ori_32_di , 0xfff8, 0x00a8, 32},
+ {m68k_op_ori_32_ix , 0xfff8, 0x00b0, 34},
+ {m68k_op_andi_8_d , 0xfff8, 0x0200, 8},
+ {m68k_op_andi_8_ai , 0xfff8, 0x0210, 16},
+ {m68k_op_andi_8_pi , 0xfff8, 0x0218, 16},
+ {m68k_op_andi_8_pd , 0xfff8, 0x0220, 18},
+ {m68k_op_andi_8_di , 0xfff8, 0x0228, 20},
+ {m68k_op_andi_8_ix , 0xfff8, 0x0230, 22},
+ {m68k_op_andi_16_d , 0xfff8, 0x0240, 8},
+ {m68k_op_andi_16_ai , 0xfff8, 0x0250, 16},
+ {m68k_op_andi_16_pi , 0xfff8, 0x0258, 16},
+ {m68k_op_andi_16_pd , 0xfff8, 0x0260, 18},
+ {m68k_op_andi_16_di , 0xfff8, 0x0268, 20},
+ {m68k_op_andi_16_ix , 0xfff8, 0x0270, 22},
+ {m68k_op_andi_32_d , 0xfff8, 0x0280, 16}, /* see Yacht.txt */
+ {m68k_op_andi_32_ai , 0xfff8, 0x0290, 28},
+ {m68k_op_andi_32_pi , 0xfff8, 0x0298, 28},
+ {m68k_op_andi_32_pd , 0xfff8, 0x02a0, 30},
+ {m68k_op_andi_32_di , 0xfff8, 0x02a8, 32},
+ {m68k_op_andi_32_ix , 0xfff8, 0x02b0, 34},
+ {m68k_op_subi_8_d , 0xfff8, 0x0400, 8},
+ {m68k_op_subi_8_ai , 0xfff8, 0x0410, 16},
+ {m68k_op_subi_8_pi , 0xfff8, 0x0418, 16},
+ {m68k_op_subi_8_pd , 0xfff8, 0x0420, 18},
+ {m68k_op_subi_8_di , 0xfff8, 0x0428, 20},
+ {m68k_op_subi_8_ix , 0xfff8, 0x0430, 22},
+ {m68k_op_subi_16_d , 0xfff8, 0x0440, 8},
+ {m68k_op_subi_16_ai , 0xfff8, 0x0450, 16},
+ {m68k_op_subi_16_pi , 0xfff8, 0x0458, 16},
+ {m68k_op_subi_16_pd , 0xfff8, 0x0460, 18},
+ {m68k_op_subi_16_di , 0xfff8, 0x0468, 20},
+ {m68k_op_subi_16_ix , 0xfff8, 0x0470, 22},
+ {m68k_op_subi_32_d , 0xfff8, 0x0480, 16},
+ {m68k_op_subi_32_ai , 0xfff8, 0x0490, 28},
+ {m68k_op_subi_32_pi , 0xfff8, 0x0498, 28},
+ {m68k_op_subi_32_pd , 0xfff8, 0x04a0, 30},
+ {m68k_op_subi_32_di , 0xfff8, 0x04a8, 32},
+ {m68k_op_subi_32_ix , 0xfff8, 0x04b0, 34},
+ {m68k_op_addi_8_d , 0xfff8, 0x0600, 8},
+ {m68k_op_addi_8_ai , 0xfff8, 0x0610, 16},
+ {m68k_op_addi_8_pi , 0xfff8, 0x0618, 16},
+ {m68k_op_addi_8_pd , 0xfff8, 0x0620, 18},
+ {m68k_op_addi_8_di , 0xfff8, 0x0628, 20},
+ {m68k_op_addi_8_ix , 0xfff8, 0x0630, 22},
+ {m68k_op_addi_16_d , 0xfff8, 0x0640, 8},
+ {m68k_op_addi_16_ai , 0xfff8, 0x0650, 16},
+ {m68k_op_addi_16_pi , 0xfff8, 0x0658, 16},
+ {m68k_op_addi_16_pd , 0xfff8, 0x0660, 18},
+ {m68k_op_addi_16_di , 0xfff8, 0x0668, 20},
+ {m68k_op_addi_16_ix , 0xfff8, 0x0670, 22},
+ {m68k_op_addi_32_d , 0xfff8, 0x0680, 16},
+ {m68k_op_addi_32_ai , 0xfff8, 0x0690, 28},
+ {m68k_op_addi_32_pi , 0xfff8, 0x0698, 28},
+ {m68k_op_addi_32_pd , 0xfff8, 0x06a0, 30},
+ {m68k_op_addi_32_di , 0xfff8, 0x06a8, 32},
+ {m68k_op_addi_32_ix , 0xfff8, 0x06b0, 34},
+ {m68k_op_btst_32_s_d , 0xfff8, 0x0800, 10},
+ {m68k_op_btst_8_s_ai , 0xfff8, 0x0810, 12},
+ {m68k_op_btst_8_s_pi , 0xfff8, 0x0818, 12},
+ {m68k_op_btst_8_s_pd , 0xfff8, 0x0820, 14},
+ {m68k_op_btst_8_s_di , 0xfff8, 0x0828, 16},
+ {m68k_op_btst_8_s_ix , 0xfff8, 0x0830, 18},
+ {m68k_op_bchg_32_s_d , 0xfff8, 0x0840, 12},
+ {m68k_op_bchg_8_s_ai , 0xfff8, 0x0850, 16},
+ {m68k_op_bchg_8_s_pi , 0xfff8, 0x0858, 16},
+ {m68k_op_bchg_8_s_pd , 0xfff8, 0x0860, 18},
+ {m68k_op_bchg_8_s_di , 0xfff8, 0x0868, 20},
+ {m68k_op_bchg_8_s_ix , 0xfff8, 0x0870, 22},
+ {m68k_op_bclr_32_s_d , 0xfff8, 0x0880, 14},
+ {m68k_op_bclr_8_s_ai , 0xfff8, 0x0890, 16},
+ {m68k_op_bclr_8_s_pi , 0xfff8, 0x0898, 16},
+ {m68k_op_bclr_8_s_pd , 0xfff8, 0x08a0, 18},
+ {m68k_op_bclr_8_s_di , 0xfff8, 0x08a8, 20},
+ {m68k_op_bclr_8_s_ix , 0xfff8, 0x08b0, 22},
+ {m68k_op_bset_32_s_d , 0xfff8, 0x08c0, 12},
+ {m68k_op_bset_8_s_ai , 0xfff8, 0x08d0, 16},
+ {m68k_op_bset_8_s_pi , 0xfff8, 0x08d8, 16},
+ {m68k_op_bset_8_s_pd , 0xfff8, 0x08e0, 18},
+ {m68k_op_bset_8_s_di , 0xfff8, 0x08e8, 20},
+ {m68k_op_bset_8_s_ix , 0xfff8, 0x08f0, 22},
+ {m68k_op_eori_8_d , 0xfff8, 0x0a00, 8},
+ {m68k_op_eori_8_ai , 0xfff8, 0x0a10, 16},
+ {m68k_op_eori_8_pi , 0xfff8, 0x0a18, 16},
+ {m68k_op_eori_8_pd , 0xfff8, 0x0a20, 18},
+ {m68k_op_eori_8_di , 0xfff8, 0x0a28, 20},
+ {m68k_op_eori_8_ix , 0xfff8, 0x0a30, 22},
+ {m68k_op_eori_16_d , 0xfff8, 0x0a40, 8},
+ {m68k_op_eori_16_ai , 0xfff8, 0x0a50, 16},
+ {m68k_op_eori_16_pi , 0xfff8, 0x0a58, 16},
+ {m68k_op_eori_16_pd , 0xfff8, 0x0a60, 18},
+ {m68k_op_eori_16_di , 0xfff8, 0x0a68, 20},
+ {m68k_op_eori_16_ix , 0xfff8, 0x0a70, 22},
+ {m68k_op_eori_32_d , 0xfff8, 0x0a80, 16},
+ {m68k_op_eori_32_ai , 0xfff8, 0x0a90, 28},
+ {m68k_op_eori_32_pi , 0xfff8, 0x0a98, 28},
+ {m68k_op_eori_32_pd , 0xfff8, 0x0aa0, 30},
+ {m68k_op_eori_32_di , 0xfff8, 0x0aa8, 32},
+ {m68k_op_eori_32_ix , 0xfff8, 0x0ab0, 34},
+ {m68k_op_cmpi_8_d , 0xfff8, 0x0c00, 8},
+ {m68k_op_cmpi_8_ai , 0xfff8, 0x0c10, 12},
+ {m68k_op_cmpi_8_pi , 0xfff8, 0x0c18, 12},
+ {m68k_op_cmpi_8_pd , 0xfff8, 0x0c20, 14},
+ {m68k_op_cmpi_8_di , 0xfff8, 0x0c28, 16},
+ {m68k_op_cmpi_8_ix , 0xfff8, 0x0c30, 18},
+ {m68k_op_cmpi_16_d , 0xfff8, 0x0c40, 8},
+ {m68k_op_cmpi_16_ai , 0xfff8, 0x0c50, 12},
+ {m68k_op_cmpi_16_pi , 0xfff8, 0x0c58, 12},
+ {m68k_op_cmpi_16_pd , 0xfff8, 0x0c60, 14},
+ {m68k_op_cmpi_16_di , 0xfff8, 0x0c68, 16},
+ {m68k_op_cmpi_16_ix , 0xfff8, 0x0c70, 18},
+ {m68k_op_cmpi_32_d , 0xfff8, 0x0c80, 14},
+ {m68k_op_cmpi_32_ai , 0xfff8, 0x0c90, 20},
+ {m68k_op_cmpi_32_pi , 0xfff8, 0x0c98, 20},
+ {m68k_op_cmpi_32_pd , 0xfff8, 0x0ca0, 22},
+ {m68k_op_cmpi_32_di , 0xfff8, 0x0ca8, 24},
+ {m68k_op_cmpi_32_ix , 0xfff8, 0x0cb0, 26},
+ {m68k_op_move_8_aw_d , 0xfff8, 0x11c0, 12},
+ {m68k_op_move_8_aw_ai , 0xfff8, 0x11d0, 16},
+ {m68k_op_move_8_aw_pi , 0xfff8, 0x11d8, 16},
+ {m68k_op_move_8_aw_pd , 0xfff8, 0x11e0, 18},
+ {m68k_op_move_8_aw_di , 0xfff8, 0x11e8, 20},
+ {m68k_op_move_8_aw_ix , 0xfff8, 0x11f0, 22},
+ {m68k_op_move_8_al_d , 0xfff8, 0x13c0, 16},
+ {m68k_op_move_8_al_ai , 0xfff8, 0x13d0, 20},
+ {m68k_op_move_8_al_pi , 0xfff8, 0x13d8, 20},
+ {m68k_op_move_8_al_pd , 0xfff8, 0x13e0, 22},
+ {m68k_op_move_8_al_di , 0xfff8, 0x13e8, 24},
+ {m68k_op_move_8_al_ix , 0xfff8, 0x13f0, 26},
+ {m68k_op_move_8_pi7_d , 0xfff8, 0x1ec0, 8},
+ {m68k_op_move_8_pi7_ai , 0xfff8, 0x1ed0, 12},
+ {m68k_op_move_8_pi7_pi , 0xfff8, 0x1ed8, 12},
+ {m68k_op_move_8_pi7_pd , 0xfff8, 0x1ee0, 14},
+ {m68k_op_move_8_pi7_di , 0xfff8, 0x1ee8, 16},
+ {m68k_op_move_8_pi7_ix , 0xfff8, 0x1ef0, 18},
+ {m68k_op_move_8_pd7_d , 0xfff8, 0x1f00, 8},
+ {m68k_op_move_8_pd7_ai , 0xfff8, 0x1f10, 12},
+ {m68k_op_move_8_pd7_pi , 0xfff8, 0x1f18, 12},
+ {m68k_op_move_8_pd7_pd , 0xfff8, 0x1f20, 14},
+ {m68k_op_move_8_pd7_di , 0xfff8, 0x1f28, 16},
+ {m68k_op_move_8_pd7_ix , 0xfff8, 0x1f30, 18},
+ {m68k_op_move_32_aw_d , 0xfff8, 0x21c0, 16},
+ {m68k_op_move_32_aw_a , 0xfff8, 0x21c8, 16},
+ {m68k_op_move_32_aw_ai , 0xfff8, 0x21d0, 24},
+ {m68k_op_move_32_aw_pi , 0xfff8, 0x21d8, 24},
+ {m68k_op_move_32_aw_pd , 0xfff8, 0x21e0, 26},
+ {m68k_op_move_32_aw_di , 0xfff8, 0x21e8, 28},
+ {m68k_op_move_32_aw_ix , 0xfff8, 0x21f0, 30},
+ {m68k_op_move_32_al_d , 0xfff8, 0x23c0, 20},
+ {m68k_op_move_32_al_a , 0xfff8, 0x23c8, 20},
+ {m68k_op_move_32_al_ai , 0xfff8, 0x23d0, 28},
+ {m68k_op_move_32_al_pi , 0xfff8, 0x23d8, 28},
+ {m68k_op_move_32_al_pd , 0xfff8, 0x23e0, 30},
+ {m68k_op_move_32_al_di , 0xfff8, 0x23e8, 32},
+ {m68k_op_move_32_al_ix , 0xfff8, 0x23f0, 34},
+ {m68k_op_move_16_aw_d , 0xfff8, 0x31c0, 12},
+ {m68k_op_move_16_aw_a , 0xfff8, 0x31c8, 12},
+ {m68k_op_move_16_aw_ai , 0xfff8, 0x31d0, 16},
+ {m68k_op_move_16_aw_pi , 0xfff8, 0x31d8, 16},
+ {m68k_op_move_16_aw_pd , 0xfff8, 0x31e0, 18},
+ {m68k_op_move_16_aw_di , 0xfff8, 0x31e8, 20},
+ {m68k_op_move_16_aw_ix , 0xfff8, 0x31f0, 22},
+ {m68k_op_move_16_al_d , 0xfff8, 0x33c0, 16},
+ {m68k_op_move_16_al_a , 0xfff8, 0x33c8, 16},
+ {m68k_op_move_16_al_ai , 0xfff8, 0x33d0, 20},
+ {m68k_op_move_16_al_pi , 0xfff8, 0x33d8, 20},
+ {m68k_op_move_16_al_pd , 0xfff8, 0x33e0, 22},
+ {m68k_op_move_16_al_di , 0xfff8, 0x33e8, 24},
+ {m68k_op_move_16_al_ix , 0xfff8, 0x33f0, 26},
+ {m68k_op_negx_8_d , 0xfff8, 0x4000, 4},
+ {m68k_op_negx_8_ai , 0xfff8, 0x4010, 12},
+ {m68k_op_negx_8_pi , 0xfff8, 0x4018, 12},
+ {m68k_op_negx_8_pd , 0xfff8, 0x4020, 14},
+ {m68k_op_negx_8_di , 0xfff8, 0x4028, 16},
+ {m68k_op_negx_8_ix , 0xfff8, 0x4030, 18},
+ {m68k_op_negx_16_d , 0xfff8, 0x4040, 4},
+ {m68k_op_negx_16_ai , 0xfff8, 0x4050, 12},
+ {m68k_op_negx_16_pi , 0xfff8, 0x4058, 12},
+ {m68k_op_negx_16_pd , 0xfff8, 0x4060, 14},
+ {m68k_op_negx_16_di , 0xfff8, 0x4068, 16},
+ {m68k_op_negx_16_ix , 0xfff8, 0x4070, 18},
+ {m68k_op_negx_32_d , 0xfff8, 0x4080, 6},
+ {m68k_op_negx_32_ai , 0xfff8, 0x4090, 20},
+ {m68k_op_negx_32_pi , 0xfff8, 0x4098, 20},
+ {m68k_op_negx_32_pd , 0xfff8, 0x40a0, 22},
+ {m68k_op_negx_32_di , 0xfff8, 0x40a8, 24},
+ {m68k_op_negx_32_ix , 0xfff8, 0x40b0, 26},
+ {m68k_op_move_16_frs_d , 0xfff8, 0x40c0, 6},
+ {m68k_op_move_16_frs_ai , 0xfff8, 0x40d0, 12},
+ {m68k_op_move_16_frs_pi , 0xfff8, 0x40d8, 12},
+ {m68k_op_move_16_frs_pd , 0xfff8, 0x40e0, 14},
+ {m68k_op_move_16_frs_di , 0xfff8, 0x40e8, 16},
+ {m68k_op_move_16_frs_ix , 0xfff8, 0x40f0, 18},
+ {m68k_op_clr_8_d , 0xfff8, 0x4200, 4},
+ {m68k_op_clr_8_ai , 0xfff8, 0x4210, 12},
+ {m68k_op_clr_8_pi , 0xfff8, 0x4218, 12},
+ {m68k_op_clr_8_pd , 0xfff8, 0x4220, 14},
+ {m68k_op_clr_8_di , 0xfff8, 0x4228, 16},
+ {m68k_op_clr_8_ix , 0xfff8, 0x4230, 18},
+ {m68k_op_clr_16_d , 0xfff8, 0x4240, 4},
+ {m68k_op_clr_16_ai , 0xfff8, 0x4250, 12},
+ {m68k_op_clr_16_pi , 0xfff8, 0x4258, 12},
+ {m68k_op_clr_16_pd , 0xfff8, 0x4260, 14},
+ {m68k_op_clr_16_di , 0xfff8, 0x4268, 16},
+ {m68k_op_clr_16_ix , 0xfff8, 0x4270, 18},
+ {m68k_op_clr_32_d , 0xfff8, 0x4280, 6},
+ {m68k_op_clr_32_ai , 0xfff8, 0x4290, 20},
+ {m68k_op_clr_32_pi , 0xfff8, 0x4298, 20},
+ {m68k_op_clr_32_pd , 0xfff8, 0x42a0, 22},
+ {m68k_op_clr_32_di , 0xfff8, 0x42a8, 24},
+ {m68k_op_clr_32_ix , 0xfff8, 0x42b0, 26},
+ {m68k_op_neg_8_d , 0xfff8, 0x4400, 4},
+ {m68k_op_neg_8_ai , 0xfff8, 0x4410, 12},
+ {m68k_op_neg_8_pi , 0xfff8, 0x4418, 12},
+ {m68k_op_neg_8_pd , 0xfff8, 0x4420, 14},
+ {m68k_op_neg_8_di , 0xfff8, 0x4428, 16},
+ {m68k_op_neg_8_ix , 0xfff8, 0x4430, 18},
+ {m68k_op_neg_16_d , 0xfff8, 0x4440, 4},
+ {m68k_op_neg_16_ai , 0xfff8, 0x4450, 12},
+ {m68k_op_neg_16_pi , 0xfff8, 0x4458, 12},
+ {m68k_op_neg_16_pd , 0xfff8, 0x4460, 14},
+ {m68k_op_neg_16_di , 0xfff8, 0x4468, 16},
+ {m68k_op_neg_16_ix , 0xfff8, 0x4470, 18},
+ {m68k_op_neg_32_d , 0xfff8, 0x4480, 6},
+ {m68k_op_neg_32_ai , 0xfff8, 0x4490, 20},
+ {m68k_op_neg_32_pi , 0xfff8, 0x4498, 20},
+ {m68k_op_neg_32_pd , 0xfff8, 0x44a0, 22},
+ {m68k_op_neg_32_di , 0xfff8, 0x44a8, 24},
+ {m68k_op_neg_32_ix , 0xfff8, 0x44b0, 26},
+ {m68k_op_move_16_toc_d , 0xfff8, 0x44c0, 12},
+ {m68k_op_move_16_toc_ai , 0xfff8, 0x44d0, 16},
+ {m68k_op_move_16_toc_pi , 0xfff8, 0x44d8, 16},
+ {m68k_op_move_16_toc_pd , 0xfff8, 0x44e0, 18},
+ {m68k_op_move_16_toc_di , 0xfff8, 0x44e8, 20},
+ {m68k_op_move_16_toc_ix , 0xfff8, 0x44f0, 22},
+ {m68k_op_not_8_d , 0xfff8, 0x4600, 4},
+ {m68k_op_not_8_ai , 0xfff8, 0x4610, 12},
+ {m68k_op_not_8_pi , 0xfff8, 0x4618, 12},
+ {m68k_op_not_8_pd , 0xfff8, 0x4620, 14},
+ {m68k_op_not_8_di , 0xfff8, 0x4628, 16},
+ {m68k_op_not_8_ix , 0xfff8, 0x4630, 18},
+ {m68k_op_not_16_d , 0xfff8, 0x4640, 4},
+ {m68k_op_not_16_ai , 0xfff8, 0x4650, 12},
+ {m68k_op_not_16_pi , 0xfff8, 0x4658, 12},
+ {m68k_op_not_16_pd , 0xfff8, 0x4660, 14},
+ {m68k_op_not_16_di , 0xfff8, 0x4668, 16},
+ {m68k_op_not_16_ix , 0xfff8, 0x4670, 18},
+ {m68k_op_not_32_d , 0xfff8, 0x4680, 6},
+ {m68k_op_not_32_ai , 0xfff8, 0x4690, 20},
+ {m68k_op_not_32_pi , 0xfff8, 0x4698, 20},
+ {m68k_op_not_32_pd , 0xfff8, 0x46a0, 22},
+ {m68k_op_not_32_di , 0xfff8, 0x46a8, 24},
+ {m68k_op_not_32_ix , 0xfff8, 0x46b0, 26},
+ {m68k_op_move_16_tos_d , 0xfff8, 0x46c0, 12},
+ {m68k_op_move_16_tos_ai , 0xfff8, 0x46d0, 16},
+ {m68k_op_move_16_tos_pi , 0xfff8, 0x46d8, 16},
+ {m68k_op_move_16_tos_pd , 0xfff8, 0x46e0, 18},
+ {m68k_op_move_16_tos_di , 0xfff8, 0x46e8, 20},
+ {m68k_op_move_16_tos_ix , 0xfff8, 0x46f0, 22},
+ {m68k_op_nbcd_8_d , 0xfff8, 0x4800, 6},
+ {m68k_op_nbcd_8_ai , 0xfff8, 0x4810, 12},
+ {m68k_op_nbcd_8_pi , 0xfff8, 0x4818, 12},
+ {m68k_op_nbcd_8_pd , 0xfff8, 0x4820, 14},
+ {m68k_op_nbcd_8_di , 0xfff8, 0x4828, 16},
+ {m68k_op_nbcd_8_ix , 0xfff8, 0x4830, 18},
+ {m68k_op_swap_32 , 0xfff8, 0x4840, 4},
+ {m68k_op_pea_32_ai , 0xfff8, 0x4850, 12},
+ {m68k_op_pea_32_di , 0xfff8, 0x4868, 16},
+ {m68k_op_pea_32_ix , 0xfff8, 0x4870, 20},
+ {m68k_op_ext_16 , 0xfff8, 0x4880, 4},
+ {m68k_op_movem_16_re_ai , 0xfff8, 0x4890, 8},
+ {m68k_op_movem_16_re_pd , 0xfff8, 0x48a0, 8},
+ {m68k_op_movem_16_re_di , 0xfff8, 0x48a8, 12},
+ {m68k_op_movem_16_re_ix , 0xfff8, 0x48b0, 14},
+ {m68k_op_ext_32 , 0xfff8, 0x48c0, 4},
+ {m68k_op_movem_32_re_ai , 0xfff8, 0x48d0, 8},
+ {m68k_op_movem_32_re_pd , 0xfff8, 0x48e0, 8},
+ {m68k_op_movem_32_re_di , 0xfff8, 0x48e8, 12},
+ {m68k_op_movem_32_re_ix , 0xfff8, 0x48f0, 14},
+ {m68k_op_tst_8_d , 0xfff8, 0x4a00, 4},
+ {m68k_op_tst_8_ai , 0xfff8, 0x4a10, 8},
+ {m68k_op_tst_8_pi , 0xfff8, 0x4a18, 8},
+ {m68k_op_tst_8_pd , 0xfff8, 0x4a20, 10},
+ {m68k_op_tst_8_di , 0xfff8, 0x4a28, 12},
+ {m68k_op_tst_8_ix , 0xfff8, 0x4a30, 14},
+ {m68k_op_tst_16_d , 0xfff8, 0x4a40, 4},
+ {m68k_op_tst_16_ai , 0xfff8, 0x4a50, 8},
+ {m68k_op_tst_16_pi , 0xfff8, 0x4a58, 8},
+ {m68k_op_tst_16_pd , 0xfff8, 0x4a60, 10},
+ {m68k_op_tst_16_di , 0xfff8, 0x4a68, 12},
+ {m68k_op_tst_16_ix , 0xfff8, 0x4a70, 14},
+ {m68k_op_tst_32_d , 0xfff8, 0x4a80, 4},
+ {m68k_op_tst_32_ai , 0xfff8, 0x4a90, 12},
+ {m68k_op_tst_32_pi , 0xfff8, 0x4a98, 12},
+ {m68k_op_tst_32_pd , 0xfff8, 0x4aa0, 14},
+ {m68k_op_tst_32_di , 0xfff8, 0x4aa8, 16},
+ {m68k_op_tst_32_ix , 0xfff8, 0x4ab0, 18},
+ {m68k_op_tas_8_d , 0xfff8, 0x4ac0, 4},
+ {m68k_op_tas_8_ai , 0xfff8, 0x4ad0, 14}, /* see Yacht.txt */
+ {m68k_op_tas_8_pi , 0xfff8, 0x4ad8, 14}, /* see Yacht.txt */
+ {m68k_op_tas_8_pd , 0xfff8, 0x4ae0, 16}, /* see Yacht.txt */
+ {m68k_op_tas_8_di , 0xfff8, 0x4ae8, 18}, /* see Yacht.txt */
+ {m68k_op_tas_8_ix , 0xfff8, 0x4af0, 20}, /* see Yacht.txt */
+ {m68k_op_movem_16_er_ai , 0xfff8, 0x4c90, 12},
+ {m68k_op_movem_16_er_pi , 0xfff8, 0x4c98, 12},
+ {m68k_op_movem_16_er_di , 0xfff8, 0x4ca8, 16},
+ {m68k_op_movem_16_er_ix , 0xfff8, 0x4cb0, 18},
+ {m68k_op_movem_32_er_ai , 0xfff8, 0x4cd0, 12},
+ {m68k_op_movem_32_er_pi , 0xfff8, 0x4cd8, 12},
+ {m68k_op_movem_32_er_di , 0xfff8, 0x4ce8, 16},
+ {m68k_op_movem_32_er_ix , 0xfff8, 0x4cf0, 18},
+ {m68k_op_link_16 , 0xfff8, 0x4e50, 16},
+ {m68k_op_unlk_32 , 0xfff8, 0x4e58, 12},
+ {m68k_op_move_32_tou , 0xfff8, 0x4e60, 4},
+ {m68k_op_move_32_fru , 0xfff8, 0x4e68, 4},
+ {m68k_op_jsr_32_ai , 0xfff8, 0x4e90, 16},
+ {m68k_op_jsr_32_di , 0xfff8, 0x4ea8, 18},
+ {m68k_op_jsr_32_ix , 0xfff8, 0x4eb0, 22},
+ {m68k_op_jmp_32_ai , 0xfff8, 0x4ed0, 8},
+ {m68k_op_jmp_32_di , 0xfff8, 0x4ee8, 10},
+ {m68k_op_jmp_32_ix , 0xfff8, 0x4ef0, 14},
+ {m68k_op_st_8_d , 0xfff8, 0x50c0, 6},
+ {m68k_op_dbt_16 , 0xfff8, 0x50c8, 12},
+ {m68k_op_st_8_ai , 0xfff8, 0x50d0, 12},
+ {m68k_op_st_8_pi , 0xfff8, 0x50d8, 12},
+ {m68k_op_st_8_pd , 0xfff8, 0x50e0, 14},
+ {m68k_op_st_8_di , 0xfff8, 0x50e8, 16},
+ {m68k_op_st_8_ix , 0xfff8, 0x50f0, 18},
+ {m68k_op_sf_8_d , 0xfff8, 0x51c0, 4},
+ {m68k_op_dbf_16 , 0xfff8, 0x51c8, 12},
+ {m68k_op_sf_8_ai , 0xfff8, 0x51d0, 12},
+ {m68k_op_sf_8_pi , 0xfff8, 0x51d8, 12},
+ {m68k_op_sf_8_pd , 0xfff8, 0x51e0, 14},
+ {m68k_op_sf_8_di , 0xfff8, 0x51e8, 16},
+ {m68k_op_sf_8_ix , 0xfff8, 0x51f0, 18},
+ {m68k_op_shi_8_d , 0xfff8, 0x52c0, 4},
+ {m68k_op_dbhi_16 , 0xfff8, 0x52c8, 12},
+ {m68k_op_shi_8_ai , 0xfff8, 0x52d0, 12},
+ {m68k_op_shi_8_pi , 0xfff8, 0x52d8, 12},
+ {m68k_op_shi_8_pd , 0xfff8, 0x52e0, 14},
+ {m68k_op_shi_8_di , 0xfff8, 0x52e8, 16},
+ {m68k_op_shi_8_ix , 0xfff8, 0x52f0, 18},
+ {m68k_op_sls_8_d , 0xfff8, 0x53c0, 4},
+ {m68k_op_dbls_16 , 0xfff8, 0x53c8, 12},
+ {m68k_op_sls_8_ai , 0xfff8, 0x53d0, 12},
+ {m68k_op_sls_8_pi , 0xfff8, 0x53d8, 12},
+ {m68k_op_sls_8_pd , 0xfff8, 0x53e0, 14},
+ {m68k_op_sls_8_di , 0xfff8, 0x53e8, 16},
+ {m68k_op_sls_8_ix , 0xfff8, 0x53f0, 18},
+ {m68k_op_scc_8_d , 0xfff8, 0x54c0, 4},
+ {m68k_op_dbcc_16 , 0xfff8, 0x54c8, 12},
+ {m68k_op_scc_8_ai , 0xfff8, 0x54d0, 12},
+ {m68k_op_scc_8_pi , 0xfff8, 0x54d8, 12},
+ {m68k_op_scc_8_pd , 0xfff8, 0x54e0, 14},
+ {m68k_op_scc_8_di , 0xfff8, 0x54e8, 16},
+ {m68k_op_scc_8_ix , 0xfff8, 0x54f0, 18},
+ {m68k_op_scs_8_d , 0xfff8, 0x55c0, 4},
+ {m68k_op_dbcs_16 , 0xfff8, 0x55c8, 12},
+ {m68k_op_scs_8_ai , 0xfff8, 0x55d0, 12},
+ {m68k_op_scs_8_pi , 0xfff8, 0x55d8, 12},
+ {m68k_op_scs_8_pd , 0xfff8, 0x55e0, 14},
+ {m68k_op_scs_8_di , 0xfff8, 0x55e8, 16},
+ {m68k_op_scs_8_ix , 0xfff8, 0x55f0, 18},
+ {m68k_op_sne_8_d , 0xfff8, 0x56c0, 4},
+ {m68k_op_dbne_16 , 0xfff8, 0x56c8, 12},
+ {m68k_op_sne_8_ai , 0xfff8, 0x56d0, 12},
+ {m68k_op_sne_8_pi , 0xfff8, 0x56d8, 12},
+ {m68k_op_sne_8_pd , 0xfff8, 0x56e0, 14},
+ {m68k_op_sne_8_di , 0xfff8, 0x56e8, 16},
+ {m68k_op_sne_8_ix , 0xfff8, 0x56f0, 18},
+ {m68k_op_seq_8_d , 0xfff8, 0x57c0, 4},
+ {m68k_op_dbeq_16 , 0xfff8, 0x57c8, 12},
+ {m68k_op_seq_8_ai , 0xfff8, 0x57d0, 12},
+ {m68k_op_seq_8_pi , 0xfff8, 0x57d8, 12},
+ {m68k_op_seq_8_pd , 0xfff8, 0x57e0, 14},
+ {m68k_op_seq_8_di , 0xfff8, 0x57e8, 16},
+ {m68k_op_seq_8_ix , 0xfff8, 0x57f0, 18},
+ {m68k_op_svc_8_d , 0xfff8, 0x58c0, 4},
+ {m68k_op_dbvc_16 , 0xfff8, 0x58c8, 12},
+ {m68k_op_svc_8_ai , 0xfff8, 0x58d0, 12},
+ {m68k_op_svc_8_pi , 0xfff8, 0x58d8, 12},
+ {m68k_op_svc_8_pd , 0xfff8, 0x58e0, 14},
+ {m68k_op_svc_8_di , 0xfff8, 0x58e8, 16},
+ {m68k_op_svc_8_ix , 0xfff8, 0x58f0, 18},
+ {m68k_op_svs_8_d , 0xfff8, 0x59c0, 4},
+ {m68k_op_dbvs_16 , 0xfff8, 0x59c8, 12},
+ {m68k_op_svs_8_ai , 0xfff8, 0x59d0, 12},
+ {m68k_op_svs_8_pi , 0xfff8, 0x59d8, 12},
+ {m68k_op_svs_8_pd , 0xfff8, 0x59e0, 14},
+ {m68k_op_svs_8_di , 0xfff8, 0x59e8, 16},
+ {m68k_op_svs_8_ix , 0xfff8, 0x59f0, 18},
+ {m68k_op_spl_8_d , 0xfff8, 0x5ac0, 4},
+ {m68k_op_dbpl_16 , 0xfff8, 0x5ac8, 12},
+ {m68k_op_spl_8_ai , 0xfff8, 0x5ad0, 12},
+ {m68k_op_spl_8_pi , 0xfff8, 0x5ad8, 12},
+ {m68k_op_spl_8_pd , 0xfff8, 0x5ae0, 14},
+ {m68k_op_spl_8_di , 0xfff8, 0x5ae8, 16},
+ {m68k_op_spl_8_ix , 0xfff8, 0x5af0, 18},
+ {m68k_op_smi_8_d , 0xfff8, 0x5bc0, 4},
+ {m68k_op_dbmi_16 , 0xfff8, 0x5bc8, 12},
+ {m68k_op_smi_8_ai , 0xfff8, 0x5bd0, 12},
+ {m68k_op_smi_8_pi , 0xfff8, 0x5bd8, 12},
+ {m68k_op_smi_8_pd , 0xfff8, 0x5be0, 14},
+ {m68k_op_smi_8_di , 0xfff8, 0x5be8, 16},
+ {m68k_op_smi_8_ix , 0xfff8, 0x5bf0, 18},
+ {m68k_op_sge_8_d , 0xfff8, 0x5cc0, 4},
+ {m68k_op_dbge_16 , 0xfff8, 0x5cc8, 12},
+ {m68k_op_sge_8_ai , 0xfff8, 0x5cd0, 12},
+ {m68k_op_sge_8_pi , 0xfff8, 0x5cd8, 12},
+ {m68k_op_sge_8_pd , 0xfff8, 0x5ce0, 14},
+ {m68k_op_sge_8_di , 0xfff8, 0x5ce8, 16},
+ {m68k_op_sge_8_ix , 0xfff8, 0x5cf0, 18},
+ {m68k_op_slt_8_d , 0xfff8, 0x5dc0, 4},
+ {m68k_op_dblt_16 , 0xfff8, 0x5dc8, 12},
+ {m68k_op_slt_8_ai , 0xfff8, 0x5dd0, 12},
+ {m68k_op_slt_8_pi , 0xfff8, 0x5dd8, 12},
+ {m68k_op_slt_8_pd , 0xfff8, 0x5de0, 14},
+ {m68k_op_slt_8_di , 0xfff8, 0x5de8, 16},
+ {m68k_op_slt_8_ix , 0xfff8, 0x5df0, 18},
+ {m68k_op_sgt_8_d , 0xfff8, 0x5ec0, 4},
+ {m68k_op_dbgt_16 , 0xfff8, 0x5ec8, 12},
+ {m68k_op_sgt_8_ai , 0xfff8, 0x5ed0, 12},
+ {m68k_op_sgt_8_pi , 0xfff8, 0x5ed8, 12},
+ {m68k_op_sgt_8_pd , 0xfff8, 0x5ee0, 14},
+ {m68k_op_sgt_8_di , 0xfff8, 0x5ee8, 16},
+ {m68k_op_sgt_8_ix , 0xfff8, 0x5ef0, 18},
+ {m68k_op_sle_8_d , 0xfff8, 0x5fc0, 4},
+ {m68k_op_dble_16 , 0xfff8, 0x5fc8, 12},
+ {m68k_op_sle_8_ai , 0xfff8, 0x5fd0, 12},
+ {m68k_op_sle_8_pi , 0xfff8, 0x5fd8, 12},
+ {m68k_op_sle_8_pd , 0xfff8, 0x5fe0, 14},
+ {m68k_op_sle_8_di , 0xfff8, 0x5fe8, 16},
+ {m68k_op_sle_8_ix , 0xfff8, 0x5ff0, 18},
+ {m68k_op_sbcd_8_mm_ax7 , 0xfff8, 0x8f08, 18},
+ {m68k_op_subx_8_mm_ax7 , 0xfff8, 0x9f08, 18},
+ {m68k_op_cmpm_8_ax7 , 0xfff8, 0xbf08, 12},
+ {m68k_op_abcd_8_mm_ax7 , 0xfff8, 0xcf08, 18},
+ {m68k_op_addx_8_mm_ax7 , 0xfff8, 0xdf08, 18},
+ {m68k_op_asr_16_ai , 0xfff8, 0xe0d0, 12},
+ {m68k_op_asr_16_pi , 0xfff8, 0xe0d8, 12},
+ {m68k_op_asr_16_pd , 0xfff8, 0xe0e0, 14},
+ {m68k_op_asr_16_di , 0xfff8, 0xe0e8, 16},
+ {m68k_op_asr_16_ix , 0xfff8, 0xe0f0, 18},
+ {m68k_op_asl_16_ai , 0xfff8, 0xe1d0, 12},
+ {m68k_op_asl_16_pi , 0xfff8, 0xe1d8, 12},
+ {m68k_op_asl_16_pd , 0xfff8, 0xe1e0, 14},
+ {m68k_op_asl_16_di , 0xfff8, 0xe1e8, 16},
+ {m68k_op_asl_16_ix , 0xfff8, 0xe1f0, 18},
+ {m68k_op_lsr_16_ai , 0xfff8, 0xe2d0, 12},
+ {m68k_op_lsr_16_pi , 0xfff8, 0xe2d8, 12},
+ {m68k_op_lsr_16_pd , 0xfff8, 0xe2e0, 14},
+ {m68k_op_lsr_16_di , 0xfff8, 0xe2e8, 16},
+ {m68k_op_lsr_16_ix , 0xfff8, 0xe2f0, 18},
+ {m68k_op_lsl_16_ai , 0xfff8, 0xe3d0, 12},
+ {m68k_op_lsl_16_pi , 0xfff8, 0xe3d8, 12},
+ {m68k_op_lsl_16_pd , 0xfff8, 0xe3e0, 14},
+ {m68k_op_lsl_16_di , 0xfff8, 0xe3e8, 16},
+ {m68k_op_lsl_16_ix , 0xfff8, 0xe3f0, 18},
+ {m68k_op_roxr_16_ai , 0xfff8, 0xe4d0, 12},
+ {m68k_op_roxr_16_pi , 0xfff8, 0xe4d8, 12},
+ {m68k_op_roxr_16_pd , 0xfff8, 0xe4e0, 14},
+ {m68k_op_roxr_16_di , 0xfff8, 0xe4e8, 16},
+ {m68k_op_roxr_16_ix , 0xfff8, 0xe4f0, 18},
+ {m68k_op_roxl_16_ai , 0xfff8, 0xe5d0, 12},
+ {m68k_op_roxl_16_pi , 0xfff8, 0xe5d8, 12},
+ {m68k_op_roxl_16_pd , 0xfff8, 0xe5e0, 14},
+ {m68k_op_roxl_16_di , 0xfff8, 0xe5e8, 16},
+ {m68k_op_roxl_16_ix , 0xfff8, 0xe5f0, 18},
+ {m68k_op_ror_16_ai , 0xfff8, 0xe6d0, 12},
+ {m68k_op_ror_16_pi , 0xfff8, 0xe6d8, 12},
+ {m68k_op_ror_16_pd , 0xfff8, 0xe6e0, 14},
+ {m68k_op_ror_16_di , 0xfff8, 0xe6e8, 16},
+ {m68k_op_ror_16_ix , 0xfff8, 0xe6f0, 18},
+ {m68k_op_rol_16_ai , 0xfff8, 0xe7d0, 12},
+ {m68k_op_rol_16_pi , 0xfff8, 0xe7d8, 12},
+ {m68k_op_rol_16_pd , 0xfff8, 0xe7e0, 14},
+ {m68k_op_rol_16_di , 0xfff8, 0xe7e8, 16},
+ {m68k_op_rol_16_ix , 0xfff8, 0xe7f0, 18},
+ {m68k_op_ori_8_pi7 , 0xffff, 0x001f, 16},
+ {m68k_op_ori_8_pd7 , 0xffff, 0x0027, 18},
+ {m68k_op_ori_8_aw , 0xffff, 0x0038, 20},
+ {m68k_op_ori_8_al , 0xffff, 0x0039, 24},
+ {m68k_op_ori_16_toc , 0xffff, 0x003c, 20},
+ {m68k_op_ori_16_aw , 0xffff, 0x0078, 20},
+ {m68k_op_ori_16_al , 0xffff, 0x0079, 24},
+ {m68k_op_ori_16_tos , 0xffff, 0x007c, 20},
+ {m68k_op_ori_32_aw , 0xffff, 0x00b8, 32},
+ {m68k_op_ori_32_al , 0xffff, 0x00b9, 36},
+ {m68k_op_andi_8_pi7 , 0xffff, 0x021f, 16},
+ {m68k_op_andi_8_pd7 , 0xffff, 0x0227, 18},
+ {m68k_op_andi_8_aw , 0xffff, 0x0238, 20},
+ {m68k_op_andi_8_al , 0xffff, 0x0239, 24},
+ {m68k_op_andi_16_toc , 0xffff, 0x023c, 20},
+ {m68k_op_andi_16_aw , 0xffff, 0x0278, 20},
+ {m68k_op_andi_16_al , 0xffff, 0x0279, 24},
+ {m68k_op_andi_16_tos , 0xffff, 0x027c, 20},
+ {m68k_op_andi_32_aw , 0xffff, 0x02b8, 32},
+ {m68k_op_andi_32_al , 0xffff, 0x02b9, 36},
+ {m68k_op_subi_8_pi7 , 0xffff, 0x041f, 16},
+ {m68k_op_subi_8_pd7 , 0xffff, 0x0427, 18},
+ {m68k_op_subi_8_aw , 0xffff, 0x0438, 20},
+ {m68k_op_subi_8_al , 0xffff, 0x0439, 24},
+ {m68k_op_subi_16_aw , 0xffff, 0x0478, 20},
+ {m68k_op_subi_16_al , 0xffff, 0x0479, 24},
+ {m68k_op_subi_32_aw , 0xffff, 0x04b8, 32},
+ {m68k_op_subi_32_al , 0xffff, 0x04b9, 36},
+ {m68k_op_addi_8_pi7 , 0xffff, 0x061f, 16},
+ {m68k_op_addi_8_pd7 , 0xffff, 0x0627, 18},
+ {m68k_op_addi_8_aw , 0xffff, 0x0638, 20},
+ {m68k_op_addi_8_al , 0xffff, 0x0639, 24},
+ {m68k_op_addi_16_aw , 0xffff, 0x0678, 20},
+ {m68k_op_addi_16_al , 0xffff, 0x0679, 24},
+ {m68k_op_addi_32_aw , 0xffff, 0x06b8, 32},
+ {m68k_op_addi_32_al , 0xffff, 0x06b9, 36},
+ {m68k_op_btst_8_s_pi7 , 0xffff, 0x081f, 12},
+ {m68k_op_btst_8_s_pd7 , 0xffff, 0x0827, 14},
+ {m68k_op_btst_8_s_aw , 0xffff, 0x0838, 16},
+ {m68k_op_btst_8_s_al , 0xffff, 0x0839, 20},
+ {m68k_op_btst_8_s_pcdi , 0xffff, 0x083a, 16},
+ {m68k_op_btst_8_s_pcix , 0xffff, 0x083b, 18},
+ {m68k_op_bchg_8_s_pi7 , 0xffff, 0x085f, 16},
+ {m68k_op_bchg_8_s_pd7 , 0xffff, 0x0867, 18},
+ {m68k_op_bchg_8_s_aw , 0xffff, 0x0878, 20},
+ {m68k_op_bchg_8_s_al , 0xffff, 0x0879, 24},
+ {m68k_op_bclr_8_s_pi7 , 0xffff, 0x089f, 16},
+ {m68k_op_bclr_8_s_pd7 , 0xffff, 0x08a7, 18},
+ {m68k_op_bclr_8_s_aw , 0xffff, 0x08b8, 20},
+ {m68k_op_bclr_8_s_al , 0xffff, 0x08b9, 24},
+ {m68k_op_bset_8_s_pi7 , 0xffff, 0x08df, 16},
+ {m68k_op_bset_8_s_pd7 , 0xffff, 0x08e7, 18},
+ {m68k_op_bset_8_s_aw , 0xffff, 0x08f8, 20},
+ {m68k_op_bset_8_s_al , 0xffff, 0x08f9, 24},
+ {m68k_op_eori_8_pi7 , 0xffff, 0x0a1f, 16},
+ {m68k_op_eori_8_pd7 , 0xffff, 0x0a27, 18},
+ {m68k_op_eori_8_aw , 0xffff, 0x0a38, 20},
+ {m68k_op_eori_8_al , 0xffff, 0x0a39, 24},
+ {m68k_op_eori_16_toc , 0xffff, 0x0a3c, 20},
+ {m68k_op_eori_16_aw , 0xffff, 0x0a78, 20},
+ {m68k_op_eori_16_al , 0xffff, 0x0a79, 24},
+ {m68k_op_eori_16_tos , 0xffff, 0x0a7c, 20},
+ {m68k_op_eori_32_aw , 0xffff, 0x0ab8, 32},
+ {m68k_op_eori_32_al , 0xffff, 0x0ab9, 36},
+ {m68k_op_cmpi_8_pi7 , 0xffff, 0x0c1f, 12},
+ {m68k_op_cmpi_8_pd7 , 0xffff, 0x0c27, 14},
+ {m68k_op_cmpi_8_aw , 0xffff, 0x0c38, 16},
+ {m68k_op_cmpi_8_al , 0xffff, 0x0c39, 20},
+ {m68k_op_cmpi_16_aw , 0xffff, 0x0c78, 16},
+ {m68k_op_cmpi_16_al , 0xffff, 0x0c79, 20},
+ {m68k_op_cmpi_32_aw , 0xffff, 0x0cb8, 24},
+ {m68k_op_cmpi_32_al , 0xffff, 0x0cb9, 28},
+ {m68k_op_move_8_aw_pi7 , 0xffff, 0x11df, 16},
+ {m68k_op_move_8_aw_pd7 , 0xffff, 0x11e7, 18},
+ {m68k_op_move_8_aw_aw , 0xffff, 0x11f8, 20},
+ {m68k_op_move_8_aw_al , 0xffff, 0x11f9, 24},
+ {m68k_op_move_8_aw_pcdi , 0xffff, 0x11fa, 20},
+ {m68k_op_move_8_aw_pcix , 0xffff, 0x11fb, 22},
+ {m68k_op_move_8_aw_i , 0xffff, 0x11fc, 16},
+ {m68k_op_move_8_al_pi7 , 0xffff, 0x13df, 20},
+ {m68k_op_move_8_al_pd7 , 0xffff, 0x13e7, 22},
+ {m68k_op_move_8_al_aw , 0xffff, 0x13f8, 24},
+ {m68k_op_move_8_al_al , 0xffff, 0x13f9, 28},
+ {m68k_op_move_8_al_pcdi , 0xffff, 0x13fa, 24},
+ {m68k_op_move_8_al_pcix , 0xffff, 0x13fb, 26},
+ {m68k_op_move_8_al_i , 0xffff, 0x13fc, 20},
+ {m68k_op_move_8_pi7_pi7 , 0xffff, 0x1edf, 12},
+ {m68k_op_move_8_pi7_pd7 , 0xffff, 0x1ee7, 14},
+ {m68k_op_move_8_pi7_aw , 0xffff, 0x1ef8, 16},
+ {m68k_op_move_8_pi7_al , 0xffff, 0x1ef9, 20},
+ {m68k_op_move_8_pi7_pcdi , 0xffff, 0x1efa, 16},
+ {m68k_op_move_8_pi7_pcix , 0xffff, 0x1efb, 18},
+ {m68k_op_move_8_pi7_i , 0xffff, 0x1efc, 12},
+ {m68k_op_move_8_pd7_pi7 , 0xffff, 0x1f1f, 12},
+ {m68k_op_move_8_pd7_pd7 , 0xffff, 0x1f27, 14},
+ {m68k_op_move_8_pd7_aw , 0xffff, 0x1f38, 16},
+ {m68k_op_move_8_pd7_al , 0xffff, 0x1f39, 20},
+ {m68k_op_move_8_pd7_pcdi , 0xffff, 0x1f3a, 16},
+ {m68k_op_move_8_pd7_pcix , 0xffff, 0x1f3b, 18},
+ {m68k_op_move_8_pd7_i , 0xffff, 0x1f3c, 12},
+ {m68k_op_move_32_aw_aw , 0xffff, 0x21f8, 28},
+ {m68k_op_move_32_aw_al , 0xffff, 0x21f9, 32},
+ {m68k_op_move_32_aw_pcdi , 0xffff, 0x21fa, 28},
+ {m68k_op_move_32_aw_pcix , 0xffff, 0x21fb, 30},
+ {m68k_op_move_32_aw_i , 0xffff, 0x21fc, 24},
+ {m68k_op_move_32_al_aw , 0xffff, 0x23f8, 32},
+ {m68k_op_move_32_al_al , 0xffff, 0x23f9, 36},
+ {m68k_op_move_32_al_pcdi , 0xffff, 0x23fa, 32},
+ {m68k_op_move_32_al_pcix , 0xffff, 0x23fb, 34},
+ {m68k_op_move_32_al_i , 0xffff, 0x23fc, 28},
+ {m68k_op_move_16_aw_aw , 0xffff, 0x31f8, 20},
+ {m68k_op_move_16_aw_al , 0xffff, 0x31f9, 24},
+ {m68k_op_move_16_aw_pcdi , 0xffff, 0x31fa, 20},
+ {m68k_op_move_16_aw_pcix , 0xffff, 0x31fb, 22},
+ {m68k_op_move_16_aw_i , 0xffff, 0x31fc, 16},
+ {m68k_op_move_16_al_aw , 0xffff, 0x33f8, 24},
+ {m68k_op_move_16_al_al , 0xffff, 0x33f9, 28},
+ {m68k_op_move_16_al_pcdi , 0xffff, 0x33fa, 24},
+ {m68k_op_move_16_al_pcix , 0xffff, 0x33fb, 26},
+ {m68k_op_move_16_al_i , 0xffff, 0x33fc, 20},
+ {m68k_op_negx_8_pi7 , 0xffff, 0x401f, 12},
+ {m68k_op_negx_8_pd7 , 0xffff, 0x4027, 14},
+ {m68k_op_negx_8_aw , 0xffff, 0x4038, 16},
+ {m68k_op_negx_8_al , 0xffff, 0x4039, 20},
+ {m68k_op_negx_16_aw , 0xffff, 0x4078, 16},
+ {m68k_op_negx_16_al , 0xffff, 0x4079, 20},
+ {m68k_op_negx_32_aw , 0xffff, 0x40b8, 24},
+ {m68k_op_negx_32_al , 0xffff, 0x40b9, 28},
+ {m68k_op_move_16_frs_aw , 0xffff, 0x40f8, 16},
+ {m68k_op_move_16_frs_al , 0xffff, 0x40f9, 20},
+ {m68k_op_clr_8_pi7 , 0xffff, 0x421f, 12},
+ {m68k_op_clr_8_pd7 , 0xffff, 0x4227, 14},
+ {m68k_op_clr_8_aw , 0xffff, 0x4238, 16},
+ {m68k_op_clr_8_al , 0xffff, 0x4239, 20},
+ {m68k_op_clr_16_aw , 0xffff, 0x4278, 16},
+ {m68k_op_clr_16_al , 0xffff, 0x4279, 20},
+ {m68k_op_clr_32_aw , 0xffff, 0x42b8, 24},
+ {m68k_op_clr_32_al , 0xffff, 0x42b9, 28},
+ {m68k_op_neg_8_pi7 , 0xffff, 0x441f, 12},
+ {m68k_op_neg_8_pd7 , 0xffff, 0x4427, 14},
+ {m68k_op_neg_8_aw , 0xffff, 0x4438, 16},
+ {m68k_op_neg_8_al , 0xffff, 0x4439, 20},
+ {m68k_op_neg_16_aw , 0xffff, 0x4478, 16},
+ {m68k_op_neg_16_al , 0xffff, 0x4479, 20},
+ {m68k_op_neg_32_aw , 0xffff, 0x44b8, 24},
+ {m68k_op_neg_32_al , 0xffff, 0x44b9, 28},
+ {m68k_op_move_16_toc_aw , 0xffff, 0x44f8, 20},
+ {m68k_op_move_16_toc_al , 0xffff, 0x44f9, 24},
+ {m68k_op_move_16_toc_pcdi , 0xffff, 0x44fa, 20},
+ {m68k_op_move_16_toc_pcix , 0xffff, 0x44fb, 22},
+ {m68k_op_move_16_toc_i , 0xffff, 0x44fc, 16},
+ {m68k_op_not_8_pi7 , 0xffff, 0x461f, 12},
+ {m68k_op_not_8_pd7 , 0xffff, 0x4627, 14},
+ {m68k_op_not_8_aw , 0xffff, 0x4638, 16},
+ {m68k_op_not_8_al , 0xffff, 0x4639, 20},
+ {m68k_op_not_16_aw , 0xffff, 0x4678, 16},
+ {m68k_op_not_16_al , 0xffff, 0x4679, 20},
+ {m68k_op_not_32_aw , 0xffff, 0x46b8, 24},
+ {m68k_op_not_32_al , 0xffff, 0x46b9, 28},
+ {m68k_op_move_16_tos_aw , 0xffff, 0x46f8, 20},
+ {m68k_op_move_16_tos_al , 0xffff, 0x46f9, 24},
+ {m68k_op_move_16_tos_pcdi , 0xffff, 0x46fa, 20},
+ {m68k_op_move_16_tos_pcix , 0xffff, 0x46fb, 22},
+ {m68k_op_move_16_tos_i , 0xffff, 0x46fc, 16},
+ {m68k_op_nbcd_8_pi7 , 0xffff, 0x481f, 12},
+ {m68k_op_nbcd_8_pd7 , 0xffff, 0x4827, 14},
+ {m68k_op_nbcd_8_aw , 0xffff, 0x4838, 16},
+ {m68k_op_nbcd_8_al , 0xffff, 0x4839, 20},
+ {m68k_op_pea_32_aw , 0xffff, 0x4878, 16},
+ {m68k_op_pea_32_al , 0xffff, 0x4879, 20},
+ {m68k_op_pea_32_pcdi , 0xffff, 0x487a, 16},
+ {m68k_op_pea_32_pcix , 0xffff, 0x487b, 20},
+ {m68k_op_movem_16_re_aw , 0xffff, 0x48b8, 12},
+ {m68k_op_movem_16_re_al , 0xffff, 0x48b9, 16},
+ {m68k_op_movem_32_re_aw , 0xffff, 0x48f8, 12},
+ {m68k_op_movem_32_re_al , 0xffff, 0x48f9, 16},
+ {m68k_op_tst_8_pi7 , 0xffff, 0x4a1f, 8},
+ {m68k_op_tst_8_pd7 , 0xffff, 0x4a27, 10},
+ {m68k_op_tst_8_aw , 0xffff, 0x4a38, 12},
+ {m68k_op_tst_8_al , 0xffff, 0x4a39, 16},
+ {m68k_op_tst_16_aw , 0xffff, 0x4a78, 12},
+ {m68k_op_tst_16_al , 0xffff, 0x4a79, 16},
+ {m68k_op_tst_32_aw , 0xffff, 0x4ab8, 16},
+ {m68k_op_tst_32_al , 0xffff, 0x4ab9, 20},
+ {m68k_op_tas_8_pi7 , 0xffff, 0x4adf, 14}, /* see Yacht.txt */
+ {m68k_op_tas_8_pd7 , 0xffff, 0x4ae7, 16}, /* see Yacht.txt */
+ {m68k_op_tas_8_aw , 0xffff, 0x4af8, 18}, /* see Yacht.txt */
+ {m68k_op_tas_8_al , 0xffff, 0x4af9, 22}, /* see Yacht.txt */
+ {m68k_op_illegal , 0xffff, 0x4afc, 4},
+ {m68k_op_movem_16_er_aw , 0xffff, 0x4cb8, 16},
+ {m68k_op_movem_16_er_al , 0xffff, 0x4cb9, 20},
+ {m68k_op_movem_16_er_pcdi , 0xffff, 0x4cba, 16},
+ {m68k_op_movem_16_er_pcix , 0xffff, 0x4cbb, 18},
+ {m68k_op_movem_32_er_aw , 0xffff, 0x4cf8, 16},
+ {m68k_op_movem_32_er_al , 0xffff, 0x4cf9, 20},
+ {m68k_op_movem_32_er_pcdi , 0xffff, 0x4cfa, 16},
+ {m68k_op_movem_32_er_pcix , 0xffff, 0x4cfb, 18},
+ {m68k_op_link_16_a7 , 0xffff, 0x4e57, 16},
+ {m68k_op_unlk_32_a7 , 0xffff, 0x4e5f, 12},
+ {m68k_op_reset , 0xffff, 0x4e70, 0},
+ {m68k_op_nop , 0xffff, 0x4e71, 4},
+ {m68k_op_stop , 0xffff, 0x4e72, 4},
+ {m68k_op_rte_32 , 0xffff, 0x4e73, 20},
+ {m68k_op_rts_32 , 0xffff, 0x4e75, 16},
+ {m68k_op_trapv , 0xffff, 0x4e76, 4},
+ {m68k_op_rtr_32 , 0xffff, 0x4e77, 20},
+ {m68k_op_jsr_32_aw , 0xffff, 0x4eb8, 18},
+ {m68k_op_jsr_32_al , 0xffff, 0x4eb9, 20},
+ {m68k_op_jsr_32_pcdi , 0xffff, 0x4eba, 18},
+ {m68k_op_jsr_32_pcix , 0xffff, 0x4ebb, 22},
+ {m68k_op_jmp_32_aw , 0xffff, 0x4ef8, 10},
+ {m68k_op_jmp_32_al , 0xffff, 0x4ef9, 12},
+ {m68k_op_jmp_32_pcdi , 0xffff, 0x4efa, 10},
+ {m68k_op_jmp_32_pcix , 0xffff, 0x4efb, 14},
+ {m68k_op_st_8_pi7 , 0xffff, 0x50df, 12},
+ {m68k_op_st_8_pd7 , 0xffff, 0x50e7, 14},
+ {m68k_op_st_8_aw , 0xffff, 0x50f8, 16},
+ {m68k_op_st_8_al , 0xffff, 0x50f9, 20},
+ {m68k_op_sf_8_pi7 , 0xffff, 0x51df, 12},
+ {m68k_op_sf_8_pd7 , 0xffff, 0x51e7, 14},
+ {m68k_op_sf_8_aw , 0xffff, 0x51f8, 16},
+ {m68k_op_sf_8_al , 0xffff, 0x51f9, 20},
+ {m68k_op_shi_8_pi7 , 0xffff, 0x52df, 12},
+ {m68k_op_shi_8_pd7 , 0xffff, 0x52e7, 14},
+ {m68k_op_shi_8_aw , 0xffff, 0x52f8, 16},
+ {m68k_op_shi_8_al , 0xffff, 0x52f9, 20},
+ {m68k_op_sls_8_pi7 , 0xffff, 0x53df, 12},
+ {m68k_op_sls_8_pd7 , 0xffff, 0x53e7, 14},
+ {m68k_op_sls_8_aw , 0xffff, 0x53f8, 16},
+ {m68k_op_sls_8_al , 0xffff, 0x53f9, 20},
+ {m68k_op_scc_8_pi7 , 0xffff, 0x54df, 12},
+ {m68k_op_scc_8_pd7 , 0xffff, 0x54e7, 14},
+ {m68k_op_scc_8_aw , 0xffff, 0x54f8, 16},
+ {m68k_op_scc_8_al , 0xffff, 0x54f9, 20},
+ {m68k_op_scs_8_pi7 , 0xffff, 0x55df, 12},
+ {m68k_op_scs_8_pd7 , 0xffff, 0x55e7, 14},
+ {m68k_op_scs_8_aw , 0xffff, 0x55f8, 16},
+ {m68k_op_scs_8_al , 0xffff, 0x55f9, 20},
+ {m68k_op_sne_8_pi7 , 0xffff, 0x56df, 12},
+ {m68k_op_sne_8_pd7 , 0xffff, 0x56e7, 14},
+ {m68k_op_sne_8_aw , 0xffff, 0x56f8, 16},
+ {m68k_op_sne_8_al , 0xffff, 0x56f9, 20},
+ {m68k_op_seq_8_pi7 , 0xffff, 0x57df, 12},
+ {m68k_op_seq_8_pd7 , 0xffff, 0x57e7, 14},
+ {m68k_op_seq_8_aw , 0xffff, 0x57f8, 16},
+ {m68k_op_seq_8_al , 0xffff, 0x57f9, 20},
+ {m68k_op_svc_8_pi7 , 0xffff, 0x58df, 12},
+ {m68k_op_svc_8_pd7 , 0xffff, 0x58e7, 14},
+ {m68k_op_svc_8_aw , 0xffff, 0x58f8, 16},
+ {m68k_op_svc_8_al , 0xffff, 0x58f9, 20},
+ {m68k_op_svs_8_pi7 , 0xffff, 0x59df, 12},
+ {m68k_op_svs_8_pd7 , 0xffff, 0x59e7, 14},
+ {m68k_op_svs_8_aw , 0xffff, 0x59f8, 16},
+ {m68k_op_svs_8_al , 0xffff, 0x59f9, 20},
+ {m68k_op_spl_8_pi7 , 0xffff, 0x5adf, 12},
+ {m68k_op_spl_8_pd7 , 0xffff, 0x5ae7, 14},
+ {m68k_op_spl_8_aw , 0xffff, 0x5af8, 16},
+ {m68k_op_spl_8_al , 0xffff, 0x5af9, 20},
+ {m68k_op_smi_8_pi7 , 0xffff, 0x5bdf, 12},
+ {m68k_op_smi_8_pd7 , 0xffff, 0x5be7, 14},
+ {m68k_op_smi_8_aw , 0xffff, 0x5bf8, 16},
+ {m68k_op_smi_8_al , 0xffff, 0x5bf9, 20},
+ {m68k_op_sge_8_pi7 , 0xffff, 0x5cdf, 12},
+ {m68k_op_sge_8_pd7 , 0xffff, 0x5ce7, 14},
+ {m68k_op_sge_8_aw , 0xffff, 0x5cf8, 16},
+ {m68k_op_sge_8_al , 0xffff, 0x5cf9, 20},
+ {m68k_op_slt_8_pi7 , 0xffff, 0x5ddf, 12},
+ {m68k_op_slt_8_pd7 , 0xffff, 0x5de7, 14},
+ {m68k_op_slt_8_aw , 0xffff, 0x5df8, 16},
+ {m68k_op_slt_8_al , 0xffff, 0x5df9, 20},
+ {m68k_op_sgt_8_pi7 , 0xffff, 0x5edf, 12},
+ {m68k_op_sgt_8_pd7 , 0xffff, 0x5ee7, 14},
+ {m68k_op_sgt_8_aw , 0xffff, 0x5ef8, 16},
+ {m68k_op_sgt_8_al , 0xffff, 0x5ef9, 20},
+ {m68k_op_sle_8_pi7 , 0xffff, 0x5fdf, 12},
+ {m68k_op_sle_8_pd7 , 0xffff, 0x5fe7, 14},
+ {m68k_op_sle_8_aw , 0xffff, 0x5ff8, 16},
+ {m68k_op_sle_8_al , 0xffff, 0x5ff9, 20},
+ {m68k_op_bra_16 , 0xffff, 0x6000, 10},
+ {m68k_op_bra_32 , 0xffff, 0x60ff, 10},
+ {m68k_op_bsr_16 , 0xffff, 0x6100, 18},
+ {m68k_op_bsr_32 , 0xffff, 0x61ff, 18},
+ {m68k_op_bhi_16 , 0xffff, 0x6200, 10},
+ {m68k_op_bhi_32 , 0xffff, 0x62ff, 10},
+ {m68k_op_bls_16 , 0xffff, 0x6300, 10},
+ {m68k_op_bls_32 , 0xffff, 0x63ff, 10},
+ {m68k_op_bcc_16 , 0xffff, 0x6400, 10},
+ {m68k_op_bcc_32 , 0xffff, 0x64ff, 10},
+ {m68k_op_bcs_16 , 0xffff, 0x6500, 10},
+ {m68k_op_bcs_32 , 0xffff, 0x65ff, 10},
+ {m68k_op_bne_16 , 0xffff, 0x6600, 10},
+ {m68k_op_bne_32 , 0xffff, 0x66ff, 10},
+ {m68k_op_beq_16 , 0xffff, 0x6700, 10},
+ {m68k_op_beq_32 , 0xffff, 0x67ff, 10},
+ {m68k_op_bvc_16 , 0xffff, 0x6800, 10},
+ {m68k_op_bvc_32 , 0xffff, 0x68ff, 10},
+ {m68k_op_bvs_16 , 0xffff, 0x6900, 10},
+ {m68k_op_bvs_32 , 0xffff, 0x69ff, 10},
+ {m68k_op_bpl_16 , 0xffff, 0x6a00, 10},
+ {m68k_op_bpl_32 , 0xffff, 0x6aff, 10},
+ {m68k_op_bmi_16 , 0xffff, 0x6b00, 10},
+ {m68k_op_bmi_32 , 0xffff, 0x6bff, 10},
+ {m68k_op_bge_16 , 0xffff, 0x6c00, 10},
+ {m68k_op_bge_32 , 0xffff, 0x6cff, 10},
+ {m68k_op_blt_16 , 0xffff, 0x6d00, 10},
+ {m68k_op_blt_32 , 0xffff, 0x6dff, 10},
+ {m68k_op_bgt_16 , 0xffff, 0x6e00, 10},
+ {m68k_op_bgt_32 , 0xffff, 0x6eff, 10},
+ {m68k_op_ble_16 , 0xffff, 0x6f00, 10},
+ {m68k_op_ble_32 , 0xffff, 0x6fff, 10},
+ {m68k_op_sbcd_8_mm_axy7 , 0xffff, 0x8f0f, 18},
+ {m68k_op_subx_8_mm_axy7 , 0xffff, 0x9f0f, 18},
+ {m68k_op_cmpm_8_axy7 , 0xffff, 0xbf0f, 12},
+ {m68k_op_abcd_8_mm_axy7 , 0xffff, 0xcf0f, 18},
+ {m68k_op_addx_8_mm_axy7 , 0xffff, 0xdf0f, 18},
+ {m68k_op_asr_16_aw , 0xffff, 0xe0f8, 16},
+ {m68k_op_asr_16_al , 0xffff, 0xe0f9, 20},
+ {m68k_op_asl_16_aw , 0xffff, 0xe1f8, 16},
+ {m68k_op_asl_16_al , 0xffff, 0xe1f9, 20},
+ {m68k_op_lsr_16_aw , 0xffff, 0xe2f8, 16},
+ {m68k_op_lsr_16_al , 0xffff, 0xe2f9, 20},
+ {m68k_op_lsl_16_aw , 0xffff, 0xe3f8, 16},
+ {m68k_op_lsl_16_al , 0xffff, 0xe3f9, 20},
+ {m68k_op_roxr_16_aw , 0xffff, 0xe4f8, 16},
+ {m68k_op_roxr_16_al , 0xffff, 0xe4f9, 20},
+ {m68k_op_roxl_16_aw , 0xffff, 0xe5f8, 16},
+ {m68k_op_roxl_16_al , 0xffff, 0xe5f9, 20},
+ {m68k_op_ror_16_aw , 0xffff, 0xe6f8, 16},
+ {m68k_op_ror_16_al , 0xffff, 0xe6f9, 20},
+ {m68k_op_rol_16_aw , 0xffff, 0xe7f8, 16},
+ {m68k_op_rol_16_al , 0xffff, 0xe7f9, 20},
+ {0, 0, 0, 0}
+};
+
+
+/* Build the opcode handler jump table */
+static void m68ki_build_opcode_table(void)
+{
+ const opcode_handler_struct *ostruct;
+ int instr;
+ int i;
+ int j;
+
+ for(i = 0; i < 0x10000; i++)
+ {
+ /* default to illegal */
+ m68ki_instruction_jump_table[i] = m68k_op_illegal;
+ m68ki_cycles[i] = 4;
+ }
+
+ ostruct = &m68k_opcode_handler_table[0];
+ while(ostruct->mask != 0xff00)
+ {
+ for(i = 0;i < 0x10000;i++)
+ {
+ if((i & ostruct->mask) == ostruct->match)
+ {
+ m68ki_instruction_jump_table[i] = ostruct->opcode_handler;
+ m68ki_cycles[i] = ostruct->cycles * MUL;
+ }
+ }
+ ostruct++;
+ }
+ while(ostruct->mask == 0xff00)
+ {
+ for(i = 0;i <= 0xff;i++)
+ {
+ m68ki_instruction_jump_table[ostruct->match | i] = ostruct->opcode_handler;
+ m68ki_cycles[ostruct->match | i] = ostruct->cycles * MUL;
+ }
+ ostruct++;
+ }
+ while(ostruct->mask == 0xf1f8)
+ {
+ for(i = 0;i < 8;i++)
+ {
+ for(j = 0;j < 8;j++)
+ {
+ instr = ostruct->match | (i << 9) | j;
+ m68ki_instruction_jump_table[instr] = ostruct->opcode_handler;
+ m68ki_cycles[instr] = ostruct->cycles * MUL;
+ }
+ }
+ ostruct++;
+ }
+ while(ostruct->mask == 0xfff0)
+ {
+ for(i = 0;i <= 0x0f;i++)
+ {
+ m68ki_instruction_jump_table[ostruct->match | i] = ostruct->opcode_handler;
+ m68ki_cycles[ostruct->match | i] = ostruct->cycles * MUL;
+ }
+ ostruct++;
+ }
+ while(ostruct->mask == 0xf1ff)
+ {
+ for(i = 0;i <= 0x07;i++)
+ {
+ m68ki_instruction_jump_table[ostruct->match | (i << 9)] = ostruct->opcode_handler;
+ m68ki_cycles[ostruct->match | (i << 9)] = ostruct->cycles * MUL;
+ }
+ ostruct++;
+ }
+ while(ostruct->mask == 0xfff8)
+ {
+ for(i = 0;i <= 0x07;i++)
+ {
+ m68ki_instruction_jump_table[ostruct->match | i] = ostruct->opcode_handler;
+ m68ki_cycles[ostruct->match | i] = ostruct->cycles * MUL;
+ }
+ ostruct++;
+ }
+ while(ostruct->mask == 0xffff)
+ {
+ m68ki_instruction_jump_table[ostruct->match] = ostruct->opcode_handler;
+ m68ki_cycles[ostruct->match] = ostruct->cycles * MUL;
+ ostruct++;
+ }
+}
+
+#endif
+
+/* ======================================================================== */
+/* ============================== END OF FILE ============================= */
+/* ======================================================================== */
+
+
diff --git a/games/retrogo/src/md/macros.h b/games/retrogo/src/md/macros.h
new file mode 100644
index 00000000..9b4223cd
--- /dev/null
+++ b/games/retrogo/src/md/macros.h
@@ -0,0 +1,70 @@
+#ifndef _MACROS_H_
+#define _MACROS_H_
+
+#ifdef LSB_FIRST
+
+#define READ_BYTE(BASE, ADDR) (BASE)[(ADDR)^1]
+
+#define READ_WORD(BASE, ADDR) (((BASE)[ADDR]<<8) | (BASE)[(ADDR)+1])
+
+#define READ_WORD_LONG(BASE, ADDR) (((BASE)[(ADDR)+1]<<24) | \
+ ((BASE)[(ADDR)]<<16) | \
+ ((BASE)[(ADDR)+3]<<8) | \
+ (BASE)[(ADDR)+2])
+
+#define WRITE_BYTE(BASE, ADDR, VAL) (BASE)[(ADDR)^1] = (VAL)&0xff
+
+#define WRITE_WORD(BASE, ADDR, VAL) (BASE)[ADDR] = ((VAL)>>8) & 0xff; \
+ (BASE)[(ADDR)+1] = (VAL)&0xff
+
+#define WRITE_WORD_LONG(BASE, ADDR, VAL) (BASE)[(ADDR+1)] = ((VAL)>>24) & 0xff; \
+ (BASE)[(ADDR)] = ((VAL)>>16)&0xff; \
+ (BASE)[(ADDR+3)] = ((VAL)>>8)&0xff; \
+ (BASE)[(ADDR+2)] = (VAL)&0xff
+
+#else
+
+#define READ_BYTE(BASE, ADDR) (BASE)[ADDR]
+#define READ_WORD(BASE, ADDR) *(uint16 *)((BASE) + (ADDR))
+#define READ_WORD_LONG(BASE, ADDR) *(uint32 *)((BASE) + (ADDR))
+#define WRITE_BYTE(BASE, ADDR, VAL) (BASE)[ADDR] = VAL & 0xff
+#define WRITE_WORD(BASE, ADDR, VAL) *(uint16 *)((BASE) + (ADDR)) = VAL & 0xffff
+#define WRITE_WORD_LONG(BASE, ADDR, VAL) *(uint32 *)((BASE) + (ADDR)) = VAL & 0xffffffff
+#endif
+
+/* C89 compatibility */
+#ifndef M_PI
+#define M_PI 3.14159265358979323846264338327f
+#endif /* M_PI */
+
+/* Set to your compiler's static inline keyword to enable it, or
+ * set it to blank to disable it.
+ * If you define INLINE in makefile or osd.h, it will override this value.
+ * NOTE: not enabling inline functions will SEVERELY slow down emulation.
+ */
+#ifndef INLINE
+#define INLINE static __inline__
+#endif /* INLINE */
+
+/* Alignment macros for cross compiler compatibility */
+#if defined(_MSC_VER)
+#define ALIGNED_(x) __declspec(align(x))
+#elif defined(__GNUC__)
+#define ALIGNED_(x) __attribute__ ((aligned(x)))
+#endif
+
+/* Default CD image file access (read-only) functions */
+/* If you need to override default stdio.h functions with custom filesystem API,
+ redefine following macros in platform specific include file (osd.h) or Makefile
+*/
+#ifndef cdStream
+#define cdStream FILE
+#define cdStreamOpen(fname) fopen(fname, "rb")
+#define cdStreamClose fclose
+#define cdStreamRead fread
+#define cdStreamSeek fseek
+#define cdStreamTell ftell
+#define cdStreamGets fgets
+#endif
+
+#endif /* _MACROS_H_ */
diff --git a/games/retrogo/src/md/md.c b/games/retrogo/src/md/md.c
new file mode 100644
index 00000000..718acb42
--- /dev/null
+++ b/games/retrogo/src/md/md.c
@@ -0,0 +1,196 @@
+/* The Mega Drive for Retro-Go's screens: gwenesis' machine run a frame at a time, as Retro-Go's
+ * gwenesis main does (its 68000 and Z80 line by line, the VDP's interrupts, a line drawn
+ * when the frame is), the picture handed line by line to rg_line.
+ *
+ * The calculator hasn't the RAM for gwenesis' frame buffer, nor in one piece for the 68000's
+ * 64 KB of RAM besides the 64 KB of video RAM: the video RAM is in Retro-Go's heap, the RAMs in
+ * pages of 4 KB (m68k.h, gwenesis_bus.c), and the picture goes out a line at a time.
+ *
+ * Based on gwenesis by bzhxx (GPL-3.0-or-later, see LICENSE) and Retro-Go's main for it. */
+#include <string.h>
+#include "md.h"
+#include "m68k.h"
+#include "gwenesis_bus.h"
+#include "gwenesis_io.h"
+#include "gwenesis_vdp.h"
+#include "gwenesis_savestate.h"
+#include "z80inst.h"
+
+unsigned char *VRAM; /* (gwenesis_vdp_mem.c's) */
+unsigned char *md_ram[16], *md_zram[2];
+extern unsigned char gwenesis_vdp_regs[];
+extern unsigned short gwenesis_vdp_status;
+extern int screen_width, screen_height, hint_pending;
+extern unsigned short CRAM565[];
+void gwenesis_m68k_save_state(void), gwenesis_m68k_load_state(void);
+void gwenesis_io_save_state(void), gwenesis_io_load_state(void);
+void gwenesis_bus_save_state(void), gwenesis_bus_load_state(void);
+void gwenesis_vdp_mem_save_state(void), gwenesis_vdp_mem_load_state(void);
+void power_on(void), reset_emulation(void);
+
+int system_clock, scan_line; /* (the frame's master clock and line, as gwenesis' main keeps them) */
+static bool z80_on = true;
+
+/* ---- the state: the parts gwenesis saves by name, here one after another in a block */
+#define MISC_SIZE 3072
+static uint8_t *misc;
+static uint32_t misc_at, misc_size;
+struct SaveState { int unused; };
+static SaveState the_state;
+SaveState *saveGwenesisStateOpenForRead(const char *name) { (void)name; return &the_state; }
+SaveState *saveGwenesisStateOpenForWrite(const char *name) { (void)name; return &the_state; }
+static void misc_put(const void *p, uint32_t n) {
+ if (misc_at + n <= MISC_SIZE) memcpy(misc + misc_at, p, n);
+ misc_at += n;
+}
+static void misc_get(void *p, uint32_t n) {
+ if (misc_at + n <= MISC_SIZE) memcpy(p, misc + misc_at, n);
+ else memset(p, 0, n);
+ misc_at += n;
+}
+void saveGwenesisStateSet(SaveState *s, const char *tag, int v) { (void)s, (void)tag; misc_put(&v, 4); }
+int saveGwenesisStateGet(SaveState *s, const char *tag) {
+ int v;
+ (void)s, (void)tag;
+ misc_get(&v, 4);
+ return v;
+}
+void saveGwenesisStateSetBuffer(SaveState *s, const char *tag, void *p, int n) { (void)s, (void)tag; misc_put(p, (uint32_t)n); }
+void saveGwenesisStateGetBuffer(SaveState *s, const char *tag, void *p, int n) { (void)s, (void)tag; misc_get(p, (uint32_t)n); }
+
+static void save_misc(void) {
+ misc_at = 0;
+ gwenesis_m68k_save_state();
+ gwenesis_io_save_state();
+ gwenesis_bus_save_state();
+ gwenesis_vdp_mem_save_state();
+ gwenesis_z80inst_save_state();
+ misc_size = misc_at;
+}
+
+static void clear_rams(void) {
+ for (int i = 0; i < 16; i++) memset(md_ram[i], 0, MD_PAGE);
+ for (int i = 0; i < 2; i++) memset(md_zram[i], 0, MD_PAGE);
+}
+
+int md_load(const uint8_t *data, uint32_t size) {
+ if (size < 0x200 || size > 0x400000) return RG_ERR_ROM;
+ rg_alloc_reset();
+ VRAM = rg_alloc(0x10000);
+ misc = rg_alloc(MISC_SIZE);
+ if (!VRAM || !misc) return RG_ERR_MEMORY;
+ for (int i = 0; i < 16; i++)
+ if (!(md_ram[i] = rg_alloc_page())) return RG_ERR_MEMORY;
+ for (int i = 0; i < 2; i++)
+ if (!(md_zram[i] = rg_alloc_page())) return RG_ERR_MEMORY;
+ clear_rams();
+ load_cartridge((unsigned char *)(uintptr_t)data, size);
+ power_on();
+ reset_emulation();
+ save_misc();
+ return RG_OK;
+}
+
+void md_reset(bool hard) {
+ if (hard) {
+ clear_rams();
+ memset(VRAM, 0, 0x10000);
+ power_on();
+ reset_emulation();
+ } else {
+ m68k_pulse_reset();
+ z80_pulse_reset();
+ }
+}
+
+void md_set_z80(bool on) { z80_on = on; }
+
+void gwenesis_io_get_buttons(void) {} /* (the pad is set before each frame, md_set_pad) */
+
+void md_set_pad(int pad) {
+ /* (gwenesis' buttons: up, down, left, right, C, B, A, Start; Retro-Go's A is C, its Select A) */
+ static const uint8_t bits[8] = {RG_PAD_UP, RG_PAD_DOWN, RG_PAD_LEFT, RG_PAD_RIGHT,
+ RG_PAD_A, RG_PAD_B, RG_PAD_SELECT, RG_PAD_START};
+ for (int i = 0; i < 8; i++) {
+ if (pad & bits[i]) gwenesis_io_pad_press_button(0, (unsigned char)i);
+ else gwenesis_io_pad_release_button(0, (unsigned char)i);
+ }
+}
+
+void md_view(int *x, int *y, int *w, int *h) {
+ *x = 0, *y = 0;
+ *w = REG12_MODE_H40 ? 320 : 256;
+ *h = REG1_PAL ? 240 : 224;
+}
+
+uint32_t md_frame_us(void) { return REG1_PAL ? 20000 : 16667; }
+
+void md_run_frame(bool draw) {
+ int lines_per_frame = REG1_PAL ? LINES_PER_FRAME_PAL : LINES_PER_FRAME_NTSC;
+ int hint_counter = gwenesis_vdp_regs[10];
+ screen_width = REG12_MODE_H40 ? 320 : 256;
+ screen_height = REG1_PAL ? 240 : 224;
+ gwenesis_vdp_render_config();
+ system_clock = 0;
+ zclk = z80_on ? 0 : 0x1000000;
+ scan_line = 0;
+ while (scan_line < lines_per_frame) {
+ m68k_run(system_clock + VDP_CYCLES_PER_LINE);
+ z80_run(system_clock + VDP_CYCLES_PER_LINE);
+ if (draw && scan_line < screen_height) gwenesis_vdp_render_line(scan_line);
+ /* (on these lines the line counter is reloaded) */
+ if (scan_line == 0 || scan_line > screen_height) hint_counter = REG10_LINE_COUNTER;
+ if (--hint_counter < 0) {
+ if (REG0_LINE_INTERRUPT != 0 && scan_line <= screen_height) {
+ hint_pending = 1;
+ if ((gwenesis_vdp_status & STATUS_VIRQPENDING) == 0) m68k_update_irq(4);
+ }
+ hint_counter = REG10_LINE_COUNTER;
+ }
+ scan_line++;
+ /* the vertical blank from the end of the last line drawn */
+ if (scan_line == screen_height) {
+ if (REG1_VBLANK_INTERRUPT != 0) {
+ gwenesis_vdp_status |= STATUS_VIRQPENDING;
+ m68k_set_irq(6);
+ }
+ z80_irq_line(1);
+ }
+ if (scan_line == screen_height + 1) z80_irq_line(0);
+ system_clock += VDP_CYCLES_PER_LINE;
+ }
+ m68k.cycles -= system_clock;
+}
+
+/* the picture again from the video RAM as it is now (under the menus) */
+void md_redraw(void) {
+ screen_width = REG12_MODE_H40 ? 320 : 256;
+ screen_height = REG1_PAL ? 240 : 224;
+ gwenesis_vdp_render_config();
+ for (int y = 0; y < screen_height; y++) gwenesis_vdp_render_line(y);
+}
+
+int md_state_chunks(rg_chunk_t *out) {
+ save_misc();
+ int n = 0;
+ out[n++] = (rg_chunk_t){misc, misc_size};
+ out[n++] = (rg_chunk_t){VRAM, 0x8000};
+ out[n++] = (rg_chunk_t){VRAM + 0x8000, 0x8000};
+ for (int i = 0; i < 16; i++) out[n++] = (rg_chunk_t){md_ram[i], MD_PAGE};
+ for (int i = 0; i < 2; i++) out[n++] = (rg_chunk_t){md_zram[i], MD_PAGE};
+ return n;
+}
+
+void md_state_loaded(void) {
+ misc_at = 0;
+ gwenesis_m68k_load_state();
+ gwenesis_io_load_state();
+ gwenesis_bus_load_state();
+ gwenesis_vdp_mem_load_state();
+ gwenesis_z80inst_load_state();
+ /* (whatever the state held: an interrupt level the 68000 has, clocks inside a frame) */
+ m68k.int_level &= 0x700, m68k.int_mask &= 0x700, m68k.stopped &= 3;
+ if (m68k.cycles > 0x100000) m68k.cycles = 0;
+ if (m68k.cycle_end > 0x100000) m68k.cycle_end = 0;
+ if (zclk < 0 || zclk > 0x1000000) zclk = 0;
+}
diff --git a/games/retrogo/src/md/md.h b/games/retrogo/src/md/md.h
new file mode 100644
index 00000000..7c63ef17
--- /dev/null
+++ b/games/retrogo/src/md/md.h
@@ -0,0 +1,32 @@
+/* The Sega Mega Drive (Genesis), as gwenesis runs it (its 68000, Musashi, its VDP and its
+ * ports), with NumPlay's Z80, for Retro-Go's screens. No sound: the calculator has no speaker. */
+#ifndef MD_H
+#define MD_H
+#include "../rg.h"
+
+#define MD_WIDTH 320
+#define MD_HEIGHT 240
+
+/* the RAMs (64 KB for the 68000, 8 KB for the Z80) in pages of MD_PAGE bytes, from rg_alloc_page
+ (main.c: the heap, then the RAM after the app's own, then a buffer on main's stack) */
+#define MD_PAGE 4096
+void *rg_alloc_page(void);
+
+/* a game read in place, plain and its bytes swapped in pairs (tools/romtable.py). RG_OK or an
+ RG_ERR_ code. */
+int md_load(const uint8_t *data, uint32_t size);
+/* hard: switched off and on; soft: the console's reset button */
+void md_reset(bool hard);
+void md_run_frame(bool draw);
+void md_set_pad(int rg_pad);
+/* whether the Z80 runs (Retro-Go's "Z80 emulation": it only plays the sound, most games run
+ without it) */
+void md_set_z80(bool on);
+/* the picture: 256 or 320 wide, 224 or 240 high */
+void md_view(int *x, int *y, int *w, int *h);
+/* a frame's length in microseconds: 60 a second, 50 for a game in its PAL mode */
+uint32_t md_frame_us(void);
+void md_redraw(void);
+int md_state_chunks(rg_chunk_t *out);
+void md_state_loaded(void);
+#endif
diff --git a/games/retrogo/src/md/md_z80.c b/games/retrogo/src/md/md_z80.c
new file mode 100644
index 00000000..51f9be97
--- /dev/null
+++ b/games/retrogo/src/md/md_z80.c
@@ -0,0 +1,125 @@
+/* The Mega Drive's Z80: NumPlay's (superzazu's z80, ../sms/z80.c, MIT License), built a second
+ * time with the Mega Drive's memory, behind the calls gwenesis makes to its own Z80 (z80inst.h).
+ * Its 8 KB of RAM (twice, 0000-3FFF), the sound chips (read as ready: no sound here), the bank
+ * register (6000) and a 32 KB window into the 68000's memory (8000-FFFF).
+ *
+ * The control of the Z80 (bus request, reset) and the timing are gwenesis' z80inst.c's
+ * (GPL-3.0-or-later, see LICENSE). */
+#include <stdint.h>
+#include <string.h>
+
+/* ---- the Z80 itself, under other names */
+uint8_t md_z80_read(uint16_t addr);
+#define Z80_READ(a) md_z80_read(a)
+#define z80_rmap md_z80_rmap
+#define z80_bus_write md_z80_bus_write
+#define z80_bus_in md_z80_bus_in
+#define z80_bus_out md_z80_bus_out
+#define z80_init md_z80_init
+#define z80_run md_z80_exec
+#define z80_gen_nmi md_z80_gen_nmi
+#define z80_fix md_z80_fix
+#define exec_opcode md_exec_opcode
+#define exec_opcode_ddfd md_exec_opcode_ddfd
+#define exec_opcode_cb md_exec_opcode_cb
+#define exec_opcode_dcb md_exec_opcode_dcb
+#define exec_opcode_ed md_exec_opcode_ed
+#include "../sms/z80.c"
+#undef z80_run
+#undef z80_init
+#undef z80_fix
+
+#include "m68k.h"
+#include "z80inst.h"
+#include "gwenesis_bus.h"
+#include "gwenesis_savestate.h"
+
+extern unsigned char *md_zram[2];
+#define ZRAM_AT(a) (md_zram[((a) >> 12) & 1][(a) & 0xFFF])
+
+/* the machine around it, saved with it */
+static struct {
+ z80 cpu;
+ int32_t bus_ack, reset, reset_once, bank;
+} zs;
+int zclk;
+
+uint8_t md_z80_read(uint16_t a) {
+ if (a < 0x4000) return ZRAM_AT(a);
+ if (a < 0x6000) return 0; /* (the YM2612's status: ready) */
+ if (a < 0x8000) return 0xFF;
+ return (uint8_t)m68k_read_memory_8(((uint32_t)zs.bank << 15) | (a & 0x7FFF));
+}
+void md_z80_bus_write(uint16_t a, uint8_t v) {
+ if (a < 0x4000) ZRAM_AT(a) = v;
+ else if (a == 0x6000) zs.bank = ((zs.bank >> 1) | (v & 1) << 8) & 0x1FF;
+ else if (a >= 0x8000) m68k_write_memory_8(((uint32_t)zs.bank << 15) | (a & 0x7FFF), v);
+ /* (the YM2612 at 4000-5FFF and the PSG at 7F11: no sound) */
+}
+uint8_t md_z80_bus_in(uint8_t port) { (void)port; return 0xFF; }
+void md_z80_bus_out(uint8_t port, uint8_t val) { (void)port, (void)val; }
+
+void z80_start(void) {
+ md_z80_init(&zs.cpu);
+ zs.reset = 1, zs.reset_once = 0, zs.bus_ack = 0, zclk = 0;
+}
+void z80_pulse_reset(void) {
+ uint8_t line = zs.cpu.irq_line;
+ md_z80_init(&zs.cpu);
+ zs.cpu.irq_line = line;
+}
+void z80_set_memory(unsigned char *buffer) { (void)buffer; }
+
+/* runs the Z80 up to the master clock `target` (it runs at a 14th of it) */
+void z80_run(int target) {
+ if (zclk >= target) return;
+ int slice = target - zclk;
+ if (zs.reset_once == 1 && zs.bus_ack == 0 && zs.reset == 0) {
+ uint32_t n = (uint32_t)(slice / Z80_FREQ_DIVISOR);
+ zs.cpu.cyc = 0;
+ md_z80_exec(&zs.cpu, n);
+ zclk = target + (int)(zs.cpu.cyc - n) * Z80_FREQ_DIVISOR;
+ } else {
+ zclk = target;
+ }
+}
+static void z80_sync(void) { z80_run(m68k_cycles_master()); }
+
+void z80_write_ctrl(unsigned int address, unsigned int value) {
+ z80_sync();
+ if (address == 0x1100) { /* BUSREQ */
+ zs.bus_ack = value ? 1 : 0;
+ } else if (address == 0x1200) { /* RESET */
+ if (value == 0) {
+ zs.reset = 1;
+ } else {
+ z80_pulse_reset();
+ zs.reset = 0, zs.reset_once = 1;
+ }
+ }
+}
+unsigned int z80_read_ctrl(unsigned int address) {
+ z80_sync();
+ if (address == 0x1100) return zs.bus_ack == 1 ? 0 : 1;
+ if (address == 0x1200) return (unsigned)zs.reset;
+ if (address == 0x1101 || address == 0x1201) return 0;
+ return 0xFF;
+}
+void z80_irq_line(unsigned int value) {
+ if (zs.reset_once == 0) return;
+ zs.cpu.irq_line = value ? 1 : 0;
+}
+
+void gwenesis_z80inst_save_state(void) {
+ SaveState *s = saveGwenesisStateOpenForWrite("z80");
+ saveGwenesisStateSetBuffer(s, "z80", &zs, sizeof zs);
+ saveGwenesisStateSet(s, "zclk", zclk);
+}
+void gwenesis_z80inst_load_state(void) {
+ SaveState *s = saveGwenesisStateOpenForRead("z80");
+ saveGwenesisStateGetBuffer(s, "z80", &zs, sizeof zs);
+ zclk = saveGwenesisStateGet(s, "zclk");
+ md_z80_fix(&zs.cpu);
+ zs.bank &= 0x1FF;
+ zs.bus_ack = zs.bus_ack != 0, zs.reset = zs.reset != 0, zs.reset_once = zs.reset_once != 0;
+}
diff --git a/games/retrogo/src/md/z80inst.h b/games/retrogo/src/md/z80inst.h
new file mode 100644
index 00000000..9e7a09b2
--- /dev/null
+++ b/games/retrogo/src/md/z80inst.h
@@ -0,0 +1,47 @@
+/*
+Gwenesis : Genesis & megadrive Emulator.
+
+This program is free software: you can redistribute it and/or modify it under
+the terms of the GNU General Public License as published by the Free Software
+Foundation, either version 3 of the License, or (at your option) any later
+version.
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+You should have received a copy of the GNU General Public License along with
+this program. If not, see <http://www.gnu.org/licenses/>.
+
+__author__ = "bzhxx"
+__contact__ = "https://github.com/bzhxx"
+__license__ = "GPLv3"
+
+*/
+#ifndef _Z80_INTERFACE_H_
+#define _Z80_INTERFACE_H_
+
+/* (NumPlay: md_z80.c; its own name, as the Master System's Z80 has a z80_run) */
+#define z80_run md_z80_run
+
+void z80_write_ctrl(unsigned int address, unsigned int value);
+unsigned int z80_read_ctrl(unsigned int address);
+void z80_start();
+void z80_pulse_reset();
+void z80_execute(unsigned int target);
+void z80_run(int target);
+extern int zclk;
+
+void gwenesis_z80inst_save_state();
+void gwenesis_z80inst_load_state();
+
+void z80_set_memory(unsigned char *buffer);
+
+void z80_write_memory_8(unsigned int address, unsigned int value);
+void z80_write_memory_16(unsigned int address, unsigned int value);
+unsigned int z80_read_memory_16(unsigned int address);
+unsigned int z80_read_memory_8(unsigned int address);
+void z80_irq_line(unsigned int value);
+
+void gwenesis_z80inst_save_state();
+void gwenesis_z80inst_load_state();
+
+#endif
\ No newline at end of file
diff --git a/games/retrogo/src/rg.h b/games/retrogo/src/rg.h
index 8b61d190..270b6dfe 100644
--- a/games/retrogo/src/rg.h
+++ b/games/retrogo/src/rg.h
@@ -23,7 +23,7 @@ typedef struct {
void *at;
uint32_t size;
} rg_chunk_t;
-#define RG_MAX_CHUNKS 16
+#define RG_MAX_CHUNKS 24 /* (the Mega Drive: 21) */
/* The cores' failures when loading a game, shown by the screens. */
enum {
diff --git a/games/retrogo/src/sms/z80.c b/games/retrogo/src/sms/z80.c
index e426ce8d..67f8b5c6 100644
--- a/games/retrogo/src/sms/z80.c
+++ b/games/retrogo/src/sms/z80.c
@@ -77,10 +77,17 @@ static const uint8_t cyc_ddfd[256] = {4, 4, 4, 4, 4, 4, 4, 4, 4, 15, 4, 4, 4, 4,
// get bit "n" of number "val"
#define GET_BIT(n, val) (((val) >> (n)) & 1)
+#ifndef Z80_READ
static inline uint8_t rb(z80* const z, uint16_t addr) {
(void)z;
return z80_rmap[addr >> 10][addr & 0x3FF];
}
+#else /* (the Mega Drive's Z80, md/md_z80.c: its own reads) */
+static inline uint8_t rb(z80* const z, uint16_t addr) {
+ (void)z;
+ return Z80_READ(addr);
+}
+#endif
static inline void wb(z80* const z, uint16_t addr, uint8_t val) {
(void)z;
diff --git a/games/retrogo/tests/host_core.c b/games/retrogo/tests/host_core.c
index b9192807..c6a8655e 100644
--- a/games/retrogo/tests/host_core.c
+++ b/games/retrogo/tests/host_core.c
@@ -1,7 +1,8 @@
/* Retro-Go's emulators on a computer: runs a ROM for some frames, with random keys if asked,
* and writes the last frame as a PPM picture.
* host_core ROM FRAMES OUT.ppm [SEED] [SCRIPT] (SEED: random pad presses; 0 for none)
- * The system comes from the file's extension (.gb .gbc .nes .sms .gg .sg .col .gw). */
+ * The system comes from the file's extension (.gb .gbc .nes .sms .gg .sg .col .gw, .md .gen .bin:
+ * a Mega Drive game, plain, its bytes swapped here as tools/romtable.py does). */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
@@ -11,15 +12,17 @@
#include "../src/nes/nes_core.h"
#include "../src/sms/sms.h"
#include "../src/gw/gw.h"
+#include "../src/md/md.h"
static uint8_t heap[RG_HEAP_SIZE] __attribute__((aligned(8)));
static uint32_t used;
+static int pages_used;
bool rg_drawing = true;
#define FW 320 /* (the widest picture: the Game & Watch's) */
static uint16_t frame[FW * 240];
static int lines_seen;
/* the three emulators behind the same few calls */
-static enum { GB, NES, SMS, GW } kind;
+static enum { GB, NES, SMS, GW, MD } kind;
void *rg_alloc(uint32_t size) {
size = (size + 7) & ~7u;
@@ -29,29 +32,46 @@ void *rg_alloc(uint32_t size) {
memset(p, 0, size);
return p;
}
-void rg_alloc_reset(void) { used = 0; }
+void rg_alloc_reset(void) { used = 0, pages_used = 0; }
+/* (the Mega Drive's RAM pages: on the calculator from three places, here from a block of their own) */
+static uint8_t pages[18 * 4096] __attribute__((aligned(8)));
+void *rg_alloc_page(void) {
+ if (used + 4096 <= sizeof heap) return rg_alloc(4096);
+ if (pages_used >= 18) return NULL;
+ memset(pages + pages_used * 4096, 0, 4096);
+ return pages + 4096 * pages_used++;
+}
void rg_line(int y, const uint16_t *px) {
if (y < 0 || y >= 240) {
fprintf(stderr, "line %d out of the picture\n", y);
abort();
}
- memcpy(frame + y * FW, px, (size_t)(kind == GB ? 160 : kind == GW ? 320 : 256) * 2);
+ int vx, vy, vw, vh;
+ if (kind == MD) md_view(&vx, &vy, &vw, &vh);
+ memcpy(frame + y * FW, px, (size_t)(kind == GB ? 160 : kind == GW ? 320 : kind == MD ? vw : 256) * 2);
lines_seen++;
}
/* the ROM, read only as the calculator's flash is: a write into it stops the test (and a read
past its end too: the page after it isn't there) */
-static uint8_t *load(const char *path, uint32_t *size) {
+static uint8_t *load(const char *path, uint32_t *size, bool md) {
FILE *f = fopen(path, "rb");
if (!f) return NULL;
fseek(f, 0, SEEK_END);
long n = ftell(f);
fseek(f, 0, SEEK_SET);
size_t pages = ((size_t)n + 4095) / 4096 * 4096 + 4096;
+ if (md) { /* (the Mega Drive core reads up to the size rounded up to a power of two) */
+ size_t p2 = 4096;
+ while (p2 < (size_t)n) p2 <<= 1;
+ pages = p2 + 4096;
+ }
uint8_t *d = mmap(NULL, pages, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (d == MAP_FAILED || fread(d, 1, (size_t)n, f) != (size_t)n) return NULL;
fclose(f);
+ if (md)
+ for (long i = 0; i + 1 < n; i += 2) { uint8_t t = d[i]; d[i] = d[i + 1], d[i + 1] = t; }
mprotect(d, pages - 4096, PROT_READ);
mprotect(d + pages - 4096, 4096, PROT_NONE);
*size = (uint32_t)n;
@@ -69,36 +89,49 @@ static uint32_t crc32(const uint8_t *p, uint32_t n) {
/* (the Game & Watch: the pad in the low byte, its console's buttons, GW_KEY_*, in the next) */
static void set_pad(int p) {
- kind == NES ? nes_set_pad(p) : kind == SMS ? sms_set_pad(p) : kind == GW ? gw_set_pad(p & 0xFF, p >> 8) : gb_set_pad(p);
+ kind == NES ? nes_set_pad(p) : kind == SMS ? sms_set_pad(p) : kind == GW ? gw_set_pad(p & 0xFF, p >> 8)
+ : kind == MD ? md_set_pad(p) : gb_set_pad(p);
}
+static int draw_every = 1, frame_no; /* (DRAW=n: one frame drawn in n, as the frame skipping does) */
static void run_frame(void) {
- kind == NES ? nes_run_frame(true) : kind == SMS ? sms_run_frame(true) : kind == GW ? gw_run_frame(true) : gb_run_frame(true);
+ bool d = ++frame_no % draw_every == 0;
+ kind == NES ? nes_run_frame(d) : kind == SMS ? sms_run_frame(d) : kind == GW ? gw_run_frame(d)
+ : kind == MD ? md_run_frame(d) : gb_run_frame(d);
}
static int chunks(rg_chunk_t *c) {
- return kind == NES ? nes_state_chunks(c) : kind == SMS ? sms_state_chunks(c) : kind == GW ? gw_state_chunks(c) : gb_state_chunks(c);
+ return kind == NES ? nes_state_chunks(c) : kind == SMS ? sms_state_chunks(c) : kind == GW ? gw_state_chunks(c)
+ : kind == MD ? md_state_chunks(c) : gb_state_chunks(c);
}
static void loaded(void) {
- kind == NES ? nes_state_loaded() : kind == SMS ? sms_state_loaded() : kind == GW ? gw_state_loaded() : gb_state_loaded();
+ kind == NES ? nes_state_loaded() : kind == SMS ? sms_state_loaded() : kind == GW ? gw_state_loaded()
+ : kind == MD ? md_state_loaded() : gb_state_loaded();
+}
+static void redraw(void) {
+ kind == NES ? nes_redraw() : kind == SMS ? sms_redraw() : kind == GW ? gw_redraw() : kind == MD ? md_redraw() : gb_redraw();
}
-static void redraw(void) { kind == NES ? nes_redraw() : kind == SMS ? sms_redraw() : kind == GW ? gw_redraw() : gb_redraw(); }
static void view(int *x, int *y, int *w, int *h) {
if (kind == SMS) sms_view(x, y, w, h);
+ else if (kind == MD) md_view(x, y, w, h);
else *x = 0, *y = 0, *w = kind == NES ? 256 : kind == GW ? 320 : 160, *h = kind == GB ? 144 : 240;
}
int main(int argc, char **argv) {
if (argc < 4) return fprintf(stderr, "usage: host_core ROM FRAMES OUT.ppm [SEED] [SCRIPT]\n"), 2;
uint32_t size;
- uint8_t *rom = load(argv[1], &size);
+ const char *ext0 = strrchr(argv[1], '.');
+ bool md = ext0 && (!strcmp(ext0, ".md") || !strcmp(ext0, ".gen") || !strcmp(ext0, ".bin"));
+ uint8_t *rom = load(argv[1], &size, md);
+ if (getenv("DRAW")) draw_every = atoi(getenv("DRAW")) > 0 ? atoi(getenv("DRAW")) : 1;
if (!rom) return fprintf(stderr, "can't read %s\n", argv[1]), 1;
int frames = atoi(argv[2]);
unsigned seed = argc > 4 ? (unsigned)atoi(argv[4]) : 0;
const char *ext = strrchr(argv[1], '.');
bool col = ext && !strcmp(ext, ".col");
kind = ext && !strcmp(ext, ".nes") ? NES : ext && (!strcmp(ext, ".sms") || !strcmp(ext, ".gg") || !strcmp(ext, ".sg") || col) ? SMS
- : ext && !strcmp(ext, ".gw") ? GW : GB;
+ : ext && !strcmp(ext, ".gw") ? GW : md ? MD : GB;
int r = kind == NES ? nes_load(rom, size)
: kind == GW ? gw_load(rom, size)
+ : kind == MD ? md_load(rom, size)
: kind == SMS ? sms_load(rom, size, crc32(rom, size),
!strcmp(ext, ".gg") ? SMS_GG : !strcmp(ext, ".sg") ? SMS_SG : col ? SMS_CV : SMS_SMS)
: gb_load(rom, size);
@@ -128,7 +161,7 @@ int main(int argc, char **argv) {
if (getenv("STATE")) {
rg_chunk_t parts[RG_MAX_CHUNKS];
int n = chunks(parts);
- static uint8_t copy[RG_HEAP_SIZE + 65536];
+ static uint8_t copy[RG_HEAP_SIZE + 18 * 4096 + 65536];
uint32_t at = 0;
for (int i = 0; i < n; i++) memcpy(copy + at, parts[i].at, parts[i].size), at += parts[i].size;
static uint16_t first[FW * 240];
diff --git a/games/retrogo/tools/m68ktab.py b/games/retrogo/tools/m68ktab.py
new file mode 100644
index 00000000..18a33019
--- /dev/null
+++ b/games/retrogo/tools/m68ktab.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""The 68000's opcode table for gwenesis' Musashi (src/md/m68kops.h), small.
+
+Musashi builds a table of 65536 handlers (a function pointer each, 256 KB on the calculator) and
+65536 cycle counts from its list of opcode patterns (m68k_opcode_handler_table, the builder
+m68ki_build_opcode_table under BUILD_TABLES). This does the same here, at build time, and writes
+each opcode as a 16-bit number of one of the (handler, cycles) pairs instead: 128 KB of table and
+a short list of pairs.
+
+ m68ktab.py src/md/m68kops.h OUT.h"""
+import re
+import sys
+
+MUL = 7 # (m68kcpu.c: the cycles in the master clock's)
+
+
+def patterns(src):
+ body = src[src.index("m68k_opcode_handler_table[] =") :]
+ body = body[: body.index("{0, 0, 0, 0}")]
+ return [(m.group(1), int(m.group(2), 16), int(m.group(3), 16), int(m.group(4)))
+ for m in re.finditer(r"\{(m68k_op_\w+)\s*,\s*0x([0-9a-fA-F]+),\s*0x([0-9a-fA-F]+),\s*(\d+)\}", body)]
+
+
+def build(pats):
+ """m68ki_build_opcode_table, as it is: the general patterns first, then the special masks"""
+ handler, cycles = ["m68k_op_illegal"] * 0x10000, [0] * 0x10000 # (illegal: 0, as gwenesis' own table has it)
+ k = 0
+
+ def put(i, p):
+ handler[i], cycles[i] = p[0], p[3] * MUL
+
+ while k < len(pats) and pats[k][1] != 0xFF00:
+ p = pats[k]
+ for i in range(0x10000):
+ if i & p[1] == p[2]:
+ put(i, p)
+ k += 1
+ while k < len(pats) and pats[k][1] == 0xFF00:
+ for i in range(0x100):
+ put(pats[k][2] | i, pats[k])
+ k += 1
+ while k < len(pats) and pats[k][1] == 0xF1F8:
+ for i in range(8):
+ for j in range(8):
+ put(pats[k][2] | i << 9 | j, pats[k])
+ k += 1
+ while k < len(pats) and pats[k][1] == 0xFFF0:
+ for i in range(0x10):
+ put(pats[k][2] | i, pats[k])
+ k += 1
+ while k < len(pats) and pats[k][1] == 0xF1FF:
+ for i in range(8):
+ put(pats[k][2] | i << 9, pats[k])
+ k += 1
+ while k < len(pats) and pats[k][1] == 0xFFF8:
+ for i in range(8):
+ put(pats[k][2] | i, pats[k])
+ k += 1
+ while k < len(pats) and pats[k][1] == 0xFFFF:
+ put(pats[k][2], pats[k])
+ k += 1
+ if k != len(pats):
+ sys.exit(f"m68ktab: pattern {pats[k]} not taken")
+ return handler, cycles
+
+
+def main():
+ src = open(sys.argv[1], encoding="latin-1").read()
+ handler, cycles = build(patterns(src))
+ pairs, index = {}, []
+ for h, c in zip(handler, cycles):
+ index.append(pairs.setdefault((h, c), len(pairs)))
+ names = sorted(pairs, key=pairs.get)
+ out = ["/* Made by tools/m68ktab.py from src/md/m68kops.h: the 68000's opcodes, each the number of",
+ " * its (handler, cycles) pair. */",
+ "".join(f"static void {h}(void);\n" for h in sorted({h for h, _ in names})),
+ f"static void (*const m68ki_pair_handler[{len(names)}])(void) = {{",
+ ",".join(h for h, _ in names), "};",
+ f"static const unsigned char m68ki_pair_cycles[{len(names)}] = {{",
+ ",".join(str(c) for _, c in names), "};",
+ "static const unsigned short m68ki_opcode_pair[0x10000] = {"]
+ out += [",".join(str(v) for v in index[k:k + 64]) + "," for k in range(0, 0x10000, 64)]
+ out.append("};")
+ open(sys.argv[2], "w").write("\n".join(out) + "\n")
+ print(f"M68K {sys.argv[2]}: {len(names)} handler and cycle pairs")
+
+
+if __name__ == "__main__":
+ main()