1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/COPYING	Sun Apr 21 14:54:35 2013 +0100
     1.3 @@ -0,0 +1,339 @@
     1.4 +		    GNU GENERAL PUBLIC LICENSE
     1.5 +		       Version 2, June 1991
     1.6 +
     1.7 + Copyright (C) 1989, 1991 Free Software Foundation, Inc.
     1.8 +                          675 Mass Ave, Cambridge, MA 02139, USA
     1.9 + Everyone is permitted to copy and distribute verbatim copies
    1.10 + of this license document, but changing it is not allowed.
    1.11 +
    1.12 +			    Preamble
    1.13 +
    1.14 +  The licenses for most software are designed to take away your
    1.15 +freedom to share and change it.  By contrast, the GNU General Public
    1.16 +License is intended to guarantee your freedom to share and change free
    1.17 +software--to make sure the software is free for all its users.  This
    1.18 +General Public License applies to most of the Free Software
    1.19 +Foundation's software and to any other program whose authors commit to
    1.20 +using it.  (Some other Free Software Foundation software is covered by
    1.21 +the GNU Library General Public License instead.)  You can apply it to
    1.22 +your programs, too.
    1.23 +
    1.24 +  When we speak of free software, we are referring to freedom, not
    1.25 +price.  Our General Public Licenses are designed to make sure that you
    1.26 +have the freedom to distribute copies of free software (and charge for
    1.27 +this service if you wish), that you receive source code or can get it
    1.28 +if you want it, that you can change the software or use pieces of it
    1.29 +in new free programs; and that you know you can do these things.
    1.30 +
    1.31 +  To protect your rights, we need to make restrictions that forbid
    1.32 +anyone to deny you these rights or to ask you to surrender the rights.
    1.33 +These restrictions translate to certain responsibilities for you if you
    1.34 +distribute copies of the software, or if you modify it.
    1.35 +
    1.36 +  For example, if you distribute copies of such a program, whether
    1.37 +gratis or for a fee, you must give the recipients all the rights that
    1.38 +you have.  You must make sure that they, too, receive or can get the
    1.39 +source code.  And you must show them these terms so they know their
    1.40 +rights.
    1.41 +
    1.42 +  We protect your rights with two steps: (1) copyright the software, and
    1.43 +(2) offer you this license which gives you legal permission to copy,
    1.44 +distribute and/or modify the software.
    1.45 +
    1.46 +  Also, for each author's protection and ours, we want to make certain
    1.47 +that everyone understands that there is no warranty for this free
    1.48 +software.  If the software is modified by someone else and passed on, we
    1.49 +want its recipients to know that what they have is not the original, so
    1.50 +that any problems introduced by others will not reflect on the original
    1.51 +authors' reputations.
    1.52 +
    1.53 +  Finally, any free program is threatened constantly by software
    1.54 +patents.  We wish to avoid the danger that redistributors of a free
    1.55 +program will individually obtain patent licenses, in effect making the
    1.56 +program proprietary.  To prevent this, we have made it clear that any
    1.57 +patent must be licensed for everyone's free use or not licensed at all.
    1.58 +
    1.59 +  The precise terms and conditions for copying, distribution and
    1.60 +modification follow.
    1.61 +
    1.62 +		    GNU GENERAL PUBLIC LICENSE
    1.63 +   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
    1.64 +
    1.65 +  0. This License applies to any program or other work which contains
    1.66 +a notice placed by the copyright holder saying it may be distributed
    1.67 +under the terms of this General Public License.  The "Program", below,
    1.68 +refers to any such program or work, and a "work based on the Program"
    1.69 +means either the Program or any derivative work under copyright law:
    1.70 +that is to say, a work containing the Program or a portion of it,
    1.71 +either verbatim or with modifications and/or translated into another
    1.72 +language.  (Hereinafter, translation is included without limitation in
    1.73 +the term "modification".)  Each licensee is addressed as "you".
    1.74 +
    1.75 +Activities other than copying, distribution and modification are not
    1.76 +covered by this License; they are outside its scope.  The act of
    1.77 +running the Program is not restricted, and the output from the Program
    1.78 +is covered only if its contents constitute a work based on the
    1.79 +Program (independent of having been made by running the Program).
    1.80 +Whether that is true depends on what the Program does.
    1.81 +
    1.82 +  1. You may copy and distribute verbatim copies of the Program's
    1.83 +source code as you receive it, in any medium, provided that you
    1.84 +conspicuously and appropriately publish on each copy an appropriate
    1.85 +copyright notice and disclaimer of warranty; keep intact all the
    1.86 +notices that refer to this License and to the absence of any warranty;
    1.87 +and give any other recipients of the Program a copy of this License
    1.88 +along with the Program.
    1.89 +
    1.90 +You may charge a fee for the physical act of transferring a copy, and
    1.91 +you may at your option offer warranty protection in exchange for a fee.
    1.92 +
    1.93 +  2. You may modify your copy or copies of the Program or any portion
    1.94 +of it, thus forming a work based on the Program, and copy and
    1.95 +distribute such modifications or work under the terms of Section 1
    1.96 +above, provided that you also meet all of these conditions:
    1.97 +
    1.98 +    a) You must cause the modified files to carry prominent notices
    1.99 +    stating that you changed the files and the date of any change.
   1.100 +
   1.101 +    b) You must cause any work that you distribute or publish, that in
   1.102 +    whole or in part contains or is derived from the Program or any
   1.103 +    part thereof, to be licensed as a whole at no charge to all third
   1.104 +    parties under the terms of this License.
   1.105 +
   1.106 +    c) If the modified program normally reads commands interactively
   1.107 +    when run, you must cause it, when started running for such
   1.108 +    interactive use in the most ordinary way, to print or display an
   1.109 +    announcement including an appropriate copyright notice and a
   1.110 +    notice that there is no warranty (or else, saying that you provide
   1.111 +    a warranty) and that users may redistribute the program under
   1.112 +    these conditions, and telling the user how to view a copy of this
   1.113 +    License.  (Exception: if the Program itself is interactive but
   1.114 +    does not normally print such an announcement, your work based on
   1.115 +    the Program is not required to print an announcement.)
   1.116 +
   1.117 +These requirements apply to the modified work as a whole.  If
   1.118 +identifiable sections of that work are not derived from the Program,
   1.119 +and can be reasonably considered independent and separate works in
   1.120 +themselves, then this License, and its terms, do not apply to those
   1.121 +sections when you distribute them as separate works.  But when you
   1.122 +distribute the same sections as part of a whole which is a work based
   1.123 +on the Program, the distribution of the whole must be on the terms of
   1.124 +this License, whose permissions for other licensees extend to the
   1.125 +entire whole, and thus to each and every part regardless of who wrote it.
   1.126 +
   1.127 +Thus, it is not the intent of this section to claim rights or contest
   1.128 +your rights to work written entirely by you; rather, the intent is to
   1.129 +exercise the right to control the distribution of derivative or
   1.130 +collective works based on the Program.
   1.131 +
   1.132 +In addition, mere aggregation of another work not based on the Program
   1.133 +with the Program (or with a work based on the Program) on a volume of
   1.134 +a storage or distribution medium does not bring the other work under
   1.135 +the scope of this License.
   1.136 +
   1.137 +  3. You may copy and distribute the Program (or a work based on it,
   1.138 +under Section 2) in object code or executable form under the terms of
   1.139 +Sections 1 and 2 above provided that you also do one of the following:
   1.140 +
   1.141 +    a) Accompany it with the complete corresponding machine-readable
   1.142 +    source code, which must be distributed under the terms of Sections
   1.143 +    1 and 2 above on a medium customarily used for software interchange; or,
   1.144 +
   1.145 +    b) Accompany it with a written offer, valid for at least three
   1.146 +    years, to give any third party, for a charge no more than your
   1.147 +    cost of physically performing source distribution, a complete
   1.148 +    machine-readable copy of the corresponding source code, to be
   1.149 +    distributed under the terms of Sections 1 and 2 above on a medium
   1.150 +    customarily used for software interchange; or,
   1.151 +
   1.152 +    c) Accompany it with the information you received as to the offer
   1.153 +    to distribute corresponding source code.  (This alternative is
   1.154 +    allowed only for noncommercial distribution and only if you
   1.155 +    received the program in object code or executable form with such
   1.156 +    an offer, in accord with Subsection b above.)
   1.157 +
   1.158 +The source code for a work means the preferred form of the work for
   1.159 +making modifications to it.  For an executable work, complete source
   1.160 +code means all the source code for all modules it contains, plus any
   1.161 +associated interface definition files, plus the scripts used to
   1.162 +control compilation and installation of the executable.  However, as a
   1.163 +special exception, the source code distributed need not include
   1.164 +anything that is normally distributed (in either source or binary
   1.165 +form) with the major components (compiler, kernel, and so on) of the
   1.166 +operating system on which the executable runs, unless that component
   1.167 +itself accompanies the executable.
   1.168 +
   1.169 +If distribution of executable or object code is made by offering
   1.170 +access to copy from a designated place, then offering equivalent
   1.171 +access to copy the source code from the same place counts as
   1.172 +distribution of the source code, even though third parties are not
   1.173 +compelled to copy the source along with the object code.
   1.174 +
   1.175 +  4. You may not copy, modify, sublicense, or distribute the Program
   1.176 +except as expressly provided under this License.  Any attempt
   1.177 +otherwise to copy, modify, sublicense or distribute the Program is
   1.178 +void, and will automatically terminate your rights under this License.
   1.179 +However, parties who have received copies, or rights, from you under
   1.180 +this License will not have their licenses terminated so long as such
   1.181 +parties remain in full compliance.
   1.182 +
   1.183 +  5. You are not required to accept this License, since you have not
   1.184 +signed it.  However, nothing else grants you permission to modify or
   1.185 +distribute the Program or its derivative works.  These actions are
   1.186 +prohibited by law if you do not accept this License.  Therefore, by
   1.187 +modifying or distributing the Program (or any work based on the
   1.188 +Program), you indicate your acceptance of this License to do so, and
   1.189 +all its terms and conditions for copying, distributing or modifying
   1.190 +the Program or works based on it.
   1.191 +
   1.192 +  6. Each time you redistribute the Program (or any work based on the
   1.193 +Program), the recipient automatically receives a license from the
   1.194 +original licensor to copy, distribute or modify the Program subject to
   1.195 +these terms and conditions.  You may not impose any further
   1.196 +restrictions on the recipients' exercise of the rights granted herein.
   1.197 +You are not responsible for enforcing compliance by third parties to
   1.198 +this License.
   1.199 +
   1.200 +  7. If, as a consequence of a court judgment or allegation of patent
   1.201 +infringement or for any other reason (not limited to patent issues),
   1.202 +conditions are imposed on you (whether by court order, agreement or
   1.203 +otherwise) that contradict the conditions of this License, they do not
   1.204 +excuse you from the conditions of this License.  If you cannot
   1.205 +distribute so as to satisfy simultaneously your obligations under this
   1.206 +License and any other pertinent obligations, then as a consequence you
   1.207 +may not distribute the Program at all.  For example, if a patent
   1.208 +license would not permit royalty-free redistribution of the Program by
   1.209 +all those who receive copies directly or indirectly through you, then
   1.210 +the only way you could satisfy both it and this License would be to
   1.211 +refrain entirely from distribution of the Program.
   1.212 +
   1.213 +If any portion of this section is held invalid or unenforceable under
   1.214 +any particular circumstance, the balance of the section is intended to
   1.215 +apply and the section as a whole is intended to apply in other
   1.216 +circumstances.
   1.217 +
   1.218 +It is not the purpose of this section to induce you to infringe any
   1.219 +patents or other property right claims or to contest validity of any
   1.220 +such claims; this section has the sole purpose of protecting the
   1.221 +integrity of the free software distribution system, which is
   1.222 +implemented by public license practices.  Many people have made
   1.223 +generous contributions to the wide range of software distributed
   1.224 +through that system in reliance on consistent application of that
   1.225 +system; it is up to the author/donor to decide if he or she is willing
   1.226 +to distribute software through any other system and a licensee cannot
   1.227 +impose that choice.
   1.228 +
   1.229 +This section is intended to make thoroughly clear what is believed to
   1.230 +be a consequence of the rest of this License.
   1.231 +
   1.232 +  8. If the distribution and/or use of the Program is restricted in
   1.233 +certain countries either by patents or by copyrighted interfaces, the
   1.234 +original copyright holder who places the Program under this License
   1.235 +may add an explicit geographical distribution limitation excluding
   1.236 +those countries, so that distribution is permitted only in or among
   1.237 +countries not thus excluded.  In such case, this License incorporates
   1.238 +the limitation as if written in the body of this License.
   1.239 +
   1.240 +  9. The Free Software Foundation may publish revised and/or new versions
   1.241 +of the General Public License from time to time.  Such new versions will
   1.242 +be similar in spirit to the present version, but may differ in detail to
   1.243 +address new problems or concerns.
   1.244 +
   1.245 +Each version is given a distinguishing version number.  If the Program
   1.246 +specifies a version number of this License which applies to it and "any
   1.247 +later version", you have the option of following the terms and conditions
   1.248 +either of that version or of any later version published by the Free
   1.249 +Software Foundation.  If the Program does not specify a version number of
   1.250 +this License, you may choose any version ever published by the Free Software
   1.251 +Foundation.
   1.252 +
   1.253 +  10. If you wish to incorporate parts of the Program into other free
   1.254 +programs whose distribution conditions are different, write to the author
   1.255 +to ask for permission.  For software which is copyrighted by the Free
   1.256 +Software Foundation, write to the Free Software Foundation; we sometimes
   1.257 +make exceptions for this.  Our decision will be guided by the two goals
   1.258 +of preserving the free status of all derivatives of our free software and
   1.259 +of promoting the sharing and reuse of software generally.
   1.260 +
   1.261 +			    NO WARRANTY
   1.262 +
   1.263 +  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
   1.264 +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
   1.265 +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
   1.266 +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
   1.267 +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
   1.268 +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
   1.269 +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
   1.270 +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
   1.271 +REPAIR OR CORRECTION.
   1.272 +
   1.273 +  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
   1.274 +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
   1.275 +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
   1.276 +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
   1.277 +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
   1.278 +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
   1.279 +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
   1.280 +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
   1.281 +POSSIBILITY OF SUCH DAMAGES.
   1.282 +
   1.283 +		     END OF TERMS AND CONDITIONS
   1.284 +
   1.285 +	Appendix: How to Apply These Terms to Your New Programs
   1.286 +
   1.287 +  If you develop a new program, and you want it to be of the greatest
   1.288 +possible use to the public, the best way to achieve this is to make it
   1.289 +free software which everyone can redistribute and change under these terms.
   1.290 +
   1.291 +  To do so, attach the following notices to the program.  It is safest
   1.292 +to attach them to the start of each source file to most effectively
   1.293 +convey the exclusion of warranty; and each file should have at least
   1.294 +the "copyright" line and a pointer to where the full notice is found.
   1.295 +
   1.296 +    <one line to give the program's name and a brief idea of what it does.>
   1.297 +    Copyright (C) 19yy  <name of author>
   1.298 +
   1.299 +    This program is free software; you can redistribute it and/or modify
   1.300 +    it under the terms of the GNU General Public License as published by
   1.301 +    the Free Software Foundation; either version 2 of the License, or
   1.302 +    (at your option) any later version.
   1.303 +
   1.304 +    This program is distributed in the hope that it will be useful,
   1.305 +    but WITHOUT ANY WARRANTY; without even the implied warranty of
   1.306 +    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   1.307 +    GNU General Public License for more details.
   1.308 +
   1.309 +    You should have received a copy of the GNU General Public License
   1.310 +    along with this program; if not, write to the Free Software
   1.311 +    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   1.312 +
   1.313 +Also add information on how to contact you by electronic and paper mail.
   1.314 +
   1.315 +If the program is interactive, make it output a short notice like this
   1.316 +when it starts in an interactive mode:
   1.317 +
   1.318 +    Gnomovision version 69, Copyright (C) 19yy name of author
   1.319 +    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
   1.320 +    This is free software, and you are welcome to redistribute it
   1.321 +    under certain conditions; type `show c' for details.
   1.322 +
   1.323 +The hypothetical commands `show w' and `show c' should show the appropriate
   1.324 +parts of the General Public License.  Of course, the commands you use may
   1.325 +be called something other than `show w' and `show c'; they could even be
   1.326 +mouse-clicks or menu items--whatever suits your program.
   1.327 +
   1.328 +You should also get your employer (if you work as a programmer) or your
   1.329 +school, if any, to sign a "copyright disclaimer" for the program, if
   1.330 +necessary.  Here is a sample; alter the names:
   1.331 +
   1.332 +  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
   1.333 +  `Gnomovision' (which makes passes at compilers) written by James Hacker.
   1.334 +
   1.335 +  <signature of Ty Coon>, 1 April 1989
   1.336 +  Ty Coon, President of Vice
   1.337 +
   1.338 +This General Public License does not permit incorporating your program into
   1.339 +proprietary programs.  If your program is a subroutine library, you may
   1.340 +consider it more useful to permit linking proprietary applications with the
   1.341 +library.  If this is what you want to do, use the GNU Library General
   1.342 +Public License instead of this License.

     2.1 Binary file acer386.nvr has changed

     3.1 Binary file ami286.nvr has changed

     4.1 Binary file ami386.nvr has changed

     5.1 Binary file ami486.nvr has changed

     6.1 Binary file at.nvr has changed

     7.1 Binary file cmdpc30.nvr has changed

     8.1 Binary file dell200.nvr has changed

     9.1 Binary file europc.nvr has changed

    10.1 Binary file hot-433.nvr has changed

    11.1 Binary file mda.rom has changed

    12.1 Binary file megapc.nvr has changed

    13.1 Binary file pc1512.nvr has changed

    14.1 Binary file pc1640.nvr has changed

    15.1 Binary file pc2086.nvr has changed

    16.1 Binary file pc3086.nvr has changed

    17.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    17.2 +++ b/readme.txt	Sun Apr 21 14:54:35 2013 +0100
    17.3 @@ -0,0 +1,483 @@
    17.4 +PCem v0.7
    17.5 +
    17.6 +Changes since v0.6:
    17.7 +
    17.8 +- New machines - DTK XT clone, Amstrad PC2086, Amstrad PC3086, Olivetti M24, Commodore PC 30 III, 
    17.9 +  PCI 486 clone
   17.10 +- New graphics cards - IBM EGA, Diamond Stealth 32 (ET4000/W32p), Paradise Bahamas 64 (S3 Vision864)
   17.11 +- IDE hard disc emulation. This replaces the old INT 13 trapping emulation on all models. For machines
   17.12 +  which don't natively have IDE support, the XTIDE board is emulated. See the readme file for details.
   17.13 +- Fixed wrong code segment on page fault - eliminates some Win95 crashes
   17.14 +- Fixed trap flag on POPF/IRET - improves DOS box on Win95
   17.15 +- Fixed various pmode stuff, OS/2 v1.3 works
   17.16 +- Fixed MMU caching bug, Win95 more stable, IE4 now works, Win98 now works, Linux now appears to work
   17.17 +- Major improvements to floppy disc emulation - fixed occasional disc corruption, works with OS/2 and Linux
   17.18 +- ATAPI identify command now returns an ATAPI version, Win95 native CD-ROM drivers now work.
   17.19 +- CD-ROM emulation now uses raw read for audio - works on Windows 7
   17.20 +- Major internal changes to graphics emulation
   17.21 +- Major internal changes to memory and IO emulation
   17.22 +- Many other changes
   17.23 +
   17.24 +
   17.25 +PCem emulates the following machines:
   17.26 +
   17.27 +IBM 5150 PC (1981) 
   17.28 +The original PC. This shipped in 1981 with a 4.77mhz 8088, 64k of RAM, and a cassette port.
   17.29 +Disc drives quickly became standard, along with more memory.
   17.30 +
   17.31 +ROM files needed:
   17.32 +
   17.33 +pc102782.bin
   17.34 +basicc11.f6
   17.35 +basicc11.f8
   17.36 +basicc11.fa
   17.37 +basicc11.fc
   17.38 +
   17.39 +
   17.40 +IBM 5160 XT (1983)
   17.41 +From a hardware perspective, this is a minor tweak of the original PC. It originally shipped
   17.42 +with 128k of RAM and a 10mb hard disc, both of which could be easily fitted to the 1981 machine.
   17.43 +However, this was targetted as businesses and was more successful than the original.
   17.44 +
   17.45 +ROM files needed:
   17.46 +
   17.47 +xt050986.0
   17.48 +xt050986.1
   17.49 +
   17.50 +
   17.51 +IBM AT (1984)
   17.52 +This was the 'next generation' PC, fully 16-bit with an 80286. The original model came with a 6mhz
   17.53 +286, which ran three times as fast as the XT. This model also introduced EGA.
   17.54 +
   17.55 +ROM files needed:
   17.56 +
   17.57 +at111585.0
   17.58 +at111585.1
   17.59 +
   17.60 +
   17.61 +Olivetti M24 (1984)
   17.62 +An enhanced XT clone, also known as the AT&T PC 6300. Has an 8086 CPU, and an unusual 'double-res'
   17.63 +CGA display.
   17.64 +
   17.65 +ROM files needed:
   17.66 +
   17.67 +olivetti_m24_version_1.43_low.bin
   17.68 +olivetti_m24_version_1.43_high.bin
   17.69 +
   17.70 +
   17.71 +Tandy 1000 (1985)
   17.72 +This is a clone of the unsuccessful IBM PCjr, which added better graphics and sound to the XT,
   17.73 +but removed much expandability plus some other hardware (such as the DMA controller). The Tandy
   17.74 +puts back the DMA controller and ISA slots, making it a much more useful machine. Many games
   17.75 +from the late 80s support the Tandy.
   17.76 +
   17.77 +ROM files needed:
   17.78 +
   17.79 +tandy1t1.020
   17.80 +
   17.81 +
   17.82 +DTK Clone XT (1986)
   17.83 +A generic clone XT board.
   17.84 +
   17.85 +ROM files needed:
   17.86 +
   17.87 +DTK_ERSO_2.42_2764.bin
   17.88 +
   17.89 +
   17.90 +Amstrad PC1512 (1986)
   17.91 +This was Amstrad's first entry into the PC clone market (after the CPC and PCW machines), and
   17.92 +was the first cheap PC available in the UK, selling for only £500. It was a 'turbo' clone, 
   17.93 +having an 8mhz 8086, as opposed to an 8088, and had 512k RAM as standard. It also had a 
   17.94 +perculiar modification to its onboard CGA controller - the 640x200 mode had 16 colours instead
   17.95 +of the usual 2. This was put to good use by GEM, which shipped with the machine.
   17.96 +
   17.97 +Amstrad's CGA implementation has a few oddities, these are emulated as best as possible. This
   17.98 +mainly affects games defining unusual video modes, though 160x100x16 still works (as on the real
   17.99 +machine).
  17.100 +
  17.101 +ROM files needed:
  17.102 +
  17.103 +40043.v1
  17.104 +40044.v2
  17.105 +40078.ic127
  17.106 +
  17.107 +
  17.108 +Amstrad PC1640 (1987)
  17.109 +Amstrad's followup to the PC1512, the PC1640 had 640k of RAM and onboard EGA, but was otherwise
  17.110 +mostly the same.
  17.111 +
  17.112 +ROM files needed:
  17.113 +
  17.114 +40043.v3
  17.115 +40044.v3
  17.116 +40100
  17.117 +
  17.118 +
  17.119 +Sinclair PC200/Amstrad PC20 (1988)
  17.120 +This was Amstrad's entry to the 16-bit home computer market, intended to compete with the Atari
  17.121 +ST and Commodore Amiga. It's similar to the PC1512, but is based on Amstrad's portable PPC512
  17.122 +system. With stock CGA and PC speaker, it couldn't compare with the ST or Amiga.
  17.123 +
  17.124 +ROM files needed:
  17.125 +
  17.126 +pc20v2.0
  17.127 +pc20v2.1
  17.128 +40109.bin
  17.129 +
  17.130 +
  17.131 +Schneider Euro PC (1988)
  17.132 +A German XT clone. An 'all-in-one' system like the Sinclair PC200. I don't know much about this
  17.133 +machine to be honest! This doesn't appear to work with the XTIDE BIOS, so therefore this is the
  17.134 +only model that does not support hard discs.
  17.135 +
  17.136 +ROM files needed:
  17.137 +
  17.138 +50145
  17.139 +50146
  17.140 +
  17.141 +
  17.142 +(c)Anonymous Generic Turbo XT BIOS (1988?)
  17.143 +This is a BIOS whose source code was made available on Usenet in 1988. It appears to be an 
  17.144 +anonymous BIOS from an XT clone board. It was then heavily modified to fix bugs. The history of
  17.145 +this BIOS (and the source code) is at http://dizzie.narod.ru/bios.txt
  17.146 +
  17.147 +ROM files needed:
  17.148 +
  17.149 +pcxt.rom
  17.150 +
  17.151 +
  17.152 +Commodore PC30-III (1988)
  17.153 +A fairly generic 286 clone.
  17.154 +
  17.155 +ROM files needed:
  17.156 +
  17.157 +commodore pc 30 iii even.bin
  17.158 +commodore pc 30 iii odd.bin
  17.159 +
  17.160 +
  17.161 +Amstrad PC2086 (1989)
  17.162 +The PC2086 is essentially a PC1640 with VGA and 3.5" floppy drives.
  17.163 +
  17.164 +ROM files needed:
  17.165 +
  17.166 +40179.ic129
  17.167 +40180.ic132
  17.168 +40186.ic171
  17.169 +
  17.170 +
  17.171 +Amstrad PC3086 (1990)
  17.172 +The PC3086 is a version of the PC2086 with a more standard case.
  17.173 +
  17.174 +ROM files needed:
  17.175 +
  17.176 +fc00.bin
  17.177 +c000.bin
  17.178 +
  17.179 +
  17.180 +Dell System 200 (1990?)
  17.181 +This is a pretty generic 286 clone with a Phoenix BIOS.
  17.182 +
  17.183 +HIMEM.SYS doesn't appear to work on this one, for some reason.
  17.184 +
  17.185 +ROM files needed:
  17.186 +
  17.187 +dell0.bin
  17.188 +dell1.bin
  17.189 +
  17.190 +
  17.191 +AMI 286 clone (1990)
  17.192 +This is a generic 286 clone with an AMI BIOS.
  17.193 +
  17.194 +ROM files needed:
  17.195 +
  17.196 +amic206.bin
  17.197 +
  17.198 +
  17.199 +Acermate 386SX/25N (1992?)
  17.200 +An integrated 386SX clone, with onboard Oak SVGA and IO.
  17.201 +
  17.202 +ROM files needed:
  17.203 +acer386.bin
  17.204 +oti067.bin
  17.205 +
  17.206 +
  17.207 +Amstrad MegaPC (1992)
  17.208 +A 386SX clone (otherwise known as the PC7386SX) with a built-in Sega Megadrive. Only the PC section
  17.209 +is emulated, obv.
  17.210 +
  17.211 +ROM files needed:
  17.212 +41651-bios lo.u18
  17.213 +211253-bios hi.u19
  17.214 +
  17.215 +
  17.216 +AMI 386 clone (1994)
  17.217 +This is a generic 386 clone with an AMI BIOS. The BIOS came from my 386DX/40, the motherboard is
  17.218 +dated June 1994.
  17.219 +
  17.220 +ROM files needed:
  17.221 +
  17.222 +ami495.bin
  17.223 +
  17.224 +
  17.225 +AMI 486 clone (1993)
  17.226 +This is a generic 486 clone with an AMI BIOS. The BIOS came from my 486SX/25, bought in December
  17.227 +1993.
  17.228 +
  17.229 +ROM files needed:
  17.230 +
  17.231 +ami1429.bin
  17.232 +
  17.233 +
  17.234 +AMI WinBIOS 486 clone (1994)
  17.235 +A 486 clone with a newer AMI BIOS.
  17.236 +
  17.237 +ROM files needed:
  17.238 +
  17.239 +ali1429g.amw
  17.240 +
  17.241 +
  17.242 +PCI 486 clone (1994)
  17.243 +A 486 clone with a PCI bus - specifically, a Shuttle HOT-433 board. Due to lack of documentation
  17.244 +this machine has some issues - in particular, don't enable the PCI IDE emulation.
  17.245 +
  17.246 +ROM files needed:
  17.247 +
  17.248 +hot-433.ami
  17.249 +
  17.250 +
  17.251 +PCem emulates the following graphics adapters :
  17.252 +
  17.253 +MDA - The original PC adapter. This displays 80x25 text in monochrome.
  17.254 +
  17.255 +Hercules - A clone of MDA, with the addition of a high-resolution 720x348 graphics mode.
  17.256 +
  17.257 +CGA - The most common of the original adapters, supporting 40x25 and 80x25 text, and 
  17.258 +    320x200 in 4 colours, 640x200 in 2 colours, and a composite mode giving 160x200 in 16 colours.
  17.259 +
  17.260 +IBM EGA - The original 1984 IBM EGA card, with 256k VRAM.
  17.261 +
  17.262 +Trident 8900D SVGA - A low cost SVGA board circa 1992/1993. Not the greatest board in it's day, but
  17.263 +    it has a reasonable VESA driver and (buggy) 15/16/24-bit colour modes.
  17.264 +
  17.265 +Tseng ET4000AX SVGA - A somewhat better SVGA board than the Trident, here you get better compatibility
  17.266 +    and speed (on the real card, not the emulator) in exchange for being limited to 8-bit colour.
  17.267 +
  17.268 +Diamond Stealth 32 SVGA - An ET4000/W32p based board, has 15/16/24-bit colour modes, plus acceleration.
  17.269 +    There is an odd bug with this one, where Windows 9x DOS boxes won't open with modes beyond 8-bit 
  17.270 +    colour. Supports PCI.
  17.271 +
  17.272 +Paradise Bahamas 64 - An S3 Vision864 based board. This has the best Windows drivers, but the default
  17.273 +    VESA driver is poor. Supports PCI.
  17.274 +
  17.275 +
  17.276 +Some models have fixed graphics adapters :
  17.277 +
  17.278 +Olivetti M24 - CGA with double-res text modes and a 640x400 mode. I haven't seen a dump of the font
  17.279 +    ROM for this yet, so if one is not provided the MDA font will be used - which looks slightly odd
  17.280 +    as it is 14-line instead of 16-line.
  17.281 +
  17.282 +Tandy 1000 - CGA with various new modes - 160x200x16, 320x200x16, 640x200x4. Widely supported in 80s 
  17.283 +    games.
  17.284 +
  17.285 +Amstrad PC1512 - CGA with a new mode (640x200x16). Only supported in GEM to my knowledge.
  17.286 +
  17.287 +Amstrad PC1640 - Paradise EGA.
  17.288 +
  17.289 +Amstrad PC2086/PC3086 - Paradise PVGA1. An early SVGA clone with 256kb VRAM.
  17.290 +
  17.291 +Amstrad MegaPC - Paradise 90C11. A development of the PVGA1, with 512kb VRAM.
  17.292 +
  17.293 +Acer 386SX/25N - Oak OTI-067. Another 512kb SVGA clone.
  17.294 +
  17.295 +
  17.296 +Pcem emulates the following sound devices :
  17.297 +
  17.298 +PC speaker - The standard beeper on all PCs. Supports samples/RealSound.
  17.299 +
  17.300 +Tandy PSG - The Texas Instruments chip in the PCjr and Tandy 1000. Supports 3 voices plus
  17.301 +    noise. I reused the emulator in B-em for this (slightly modified).
  17.302 +
  17.303 +Gameblaster - The Creative Labs Gameblaster/Creative Music System, Creative's first sound card
  17.304 +    introduced in 1987. Has two Philips SAA1099, giving 12 voices of square waves plus 4 noise
  17.305 +    voices. In stereo!
  17.306 +
  17.307 +Adlib - Has a Yamaha YM3812, giving 9 voices of 2 op FM, or 6 voices plus a useless drum section. 
  17.308 +    PCem uses Jarek Burczynski's emulator for this.
  17.309 +
  17.310 +Sound Blaster - Several Sound Blasters are emulated :
  17.311 +    SB v1.0 - The original. Limited to 22khz, and no auto-init DMA (can cause crackles sometimes).
  17.312 +    SB v1.5 - Adds auto-init DMA
  17.313 +    SB v2.0 - Upped to 41khz
  17.314 +    SB Pro v1.0 - Stereo, with twin OPL2 chips.
  17.315 +    SB Pro v2.0 - Stereo, with OPL 3 chip
  17.316 +    SB 16 - 16 bit stereo
  17.317 +    All are set to Address 220, IRQ 7 and DMA 1 (and High DMA 5). IRQ and DMA can be changed for the 
  17.318 +    SB16.
  17.319 +    The relevant SET line for autoexec.bat is
  17.320 +	SET BLASTER = A220 I7 D1 Tx    - where Tx is T1 for SB v1.0, T3 for SB v2.0, T4 for SB Pro,
  17.321 +					 and T6 for SB16.
  17.322 +    The SB16 software seems to work (including Windows drivers), but you must stick to these settings.
  17.323 +
  17.324 +Gravis Ultrasound - 32 voice sample playback. PCem's emulation of this is a bit preliminary :
  17.325 +    - Only older ULTRASND setup programs work, ie text mode instead of graphics (3.xx?)
  17.326 +    - MIDI playback occasionally goes wrong
  17.327 +    - 16-bit playback only uses top 8 bits of samples
  17.328 +    - Some games, eg later versions of Epic Pinball, have no music
  17.329 +    - No stereo
  17.330 +    - Some clicking in sound output
  17.331 +    - Does work well in lots of stuff though, eg Worms, Pinball Fantasies, Zone 66 etc.
  17.332 +    - Settings are hardwired to Address 240, IRQ 5, DMA 3. The relevant SET line for autoexec.bat is
  17.333 +	SET ULTRASND=240,3,3,5,12
  17.334 +      This means unlike on a real board, you don't have to run a init program on bootup for sound 
  17.335 +      to work. You do need to install the ULTRAMID patches if you want MIDI.
  17.336 +
  17.337 +
  17.338 +Other stuff emulated :
  17.339 +
  17.340 +Serial mouse - A Microsoft compatible serial mouse on COM1. Compatible drivers are all over the 
  17.341 +    place for this.
  17.342 +
  17.343 +M24 mouse - I haven't seen a DOS mouse driver for this yet, but the regular scancode mode works, as
  17.344 +    does the Windows 1.x driver.
  17.345 +
  17.346 +PC1512 mouse - The PC1512's perculiar quadrature mouse. You need Amstrad's actual driver for this
  17.347 +    one.
  17.348 +
  17.349 +PS/2 mouse - A PS/2 mouse is emulated on the MegaPC and 386SX/25N model. As with serial, compatible
  17.350 +    drivers are common.
  17.351 +
  17.352 +ATAPI CD-ROM - Works with OAKCDROM.SYS and Windows 9x. It can only work with actual CD-ROM drives 
  17.353 +    at the minute, so to use ISO images you need a virtual CD drive.
  17.354 +
  17.355 +
  17.356 +XTIDE :
  17.357 +
  17.358 +The XTIDE board is emulated for machines that don't natively support IDE hard discs.
  17.359 +
  17.360 +You will need to download the XTIDE BIOS seperately. Of the various versions, ide_at.bin and ide_xt.bin
  17.361 +should be placed in the ROMS directory. ide_xt is used on all XT models, and ide_at is used on the IBM AT
  17.362 +and Commodore PC30-III machines.
  17.363 +
  17.364 +The BIOS is available at :
  17.365 +
  17.366 +http://code.google.com/p/xtideuniversalbios/
  17.367 +
  17.368 +v2.0.0 beta 1 is the only version that has been tested.
  17.369 +
  17.370 +
  17.371 +Notes :
  17.372 +
  17.373 +- The AT and AMI 286 both fail part of their self test. This doesn't really affect anything, 
  17.374 +  just puts an irritating message on the screen.
  17.375 +
  17.376 +- The time on the PC1512 clock is wrong. The date is correct, though since the PC1512's bios isn't
  17.377 +  Y2k compliant, it thinks it's 1988.
  17.378 +
  17.379 +- The envelope system on the Gameblaster isn't emulated. The noise may not be right either.
  17.380 +
  17.381 +- Some of the more unusual VGA features are not emulated. I haven't found anything that uses them yet.
  17.382 +
  17.383 +- Windows 3.x should work okay in all modes now.
  17.384 +
  17.385 +- Windows 95/98 run, with the following caveats :
  17.386 +  - Mouse is not detected. Strangely, it still works - except during setup, when it stops working at one point.
  17.387 +    Sometimes running the 'Add New Hardware' wizard a couple of times will find it.
  17.388 +  - The default Trident driver only allows 16 and 256 colour modes. There is an alternative driver which enables
  17.389 +    high and true colour modes, but it doesn't work with DirectX.
  17.390 +  - Setup sometimes crashes in the first stage (during file copying). This appears to be a side effect of the 
  17.391 +    bugs fixed making OS/2 work. Unfortunately I haven't been able to eliminate this issue.
  17.392 +
  17.393 +- OS/2 1.3 seems to work okay, but I haven't tested it very thoroughly.
  17.394 +
  17.395 +- Linux appears to work. fdlinux runs okay, but is relatively useless. SuSE 6.3 seemed mostly okay, but I only
  17.396 +  had the first disc of 6 when testing, so I didn't get very far.
  17.397 +
  17.398 +- Windows NT does not work at all.
  17.399 +
  17.400 +
  17.401 +Software tested:
  17.402 +
  17.403 +I removed most of this, and only put the stuff I actually tested on this release.
  17.404 +
  17.405 +Booter games :
  17.406 +
  17.407 +King's Quest (Tandy)
  17.408 +King's Quest (CGA)
  17.409 +
  17.410 +
  17.411 +DOS stuff :
  17.412 +
  17.413 +MS-DOS 3.30
  17.414 +PC-DOS 3.30
  17.415 +PC-DOS 5.02
  17.416 +MS-DOS 6.22
  17.417 + - Most of the supplied software seems to work, eg Drivespace, Defrag, Scandisk, QBASIC
  17.418 +   etc
  17.419 +
  17.420 +OS/2 v1.3
  17.421 +
  17.422 +Windows 3.0 (CGA, Hercules, EGA, VGA) (real and standard modes only)
  17.423 +Windows 3.1 (VGA, SVGA) (standard & enhanced modes)
  17.424 +Windows 95
  17.425 +Windows 98
  17.426 +
  17.427 +Works for Windows 3.0
  17.428 +Microsoft Arcade
  17.429 +Internet Explorer 4
  17.430 +
  17.431 +Jill of the Jungle (CGA,EGA,VGA)
  17.432 +Tetris
  17.433 +Zak McKraken (CGA, Tandy)
  17.434 +
  17.435 +Brix (VGA)
  17.436 +Commander Keen 4 (EGA)
  17.437 +Duke Nukem 2 (VGA)
  17.438 +Heartlight (VGA)
  17.439 +Jetpack (VGA)
  17.440 +
  17.441 +Cascada - Cronologia (VGA)
  17.442 +EMF - Verses
  17.443 +Renaissance - Amnesia
  17.444 +Future Crew - Second Reality
  17.445 +
  17.446 +386/486 stuff :
  17.447 +
  17.448 +Jungle Strike (EMM386)
  17.449 +Dawn Patrol (EMM386) (use ET4000 driver)
  17.450 +
  17.451 +Doom
  17.452 +Doom 2
  17.453 +Duke Nukem 3D
  17.454 +Heretic
  17.455 +Hexen
  17.456 +Jazz Jackrabbit
  17.457 +Rise of the Triad
  17.458 +Simcity 2000
  17.459 +Terminal Velocity
  17.460 +Tyrian
  17.461 +Trasnport Tycoon
  17.462 +Transport Tycoon Deluxe
  17.463 +X-Com : Terror From The Deep
  17.464 +Theme Hospital - DOS and Windows versions
  17.465 +Zone 66 (don't use DOS 6.22)
  17.466 +Pro Pinball : Timeshock
  17.467 +
  17.468 +Actua Soccer
  17.469 +Grand Theft Auto
  17.470 +Jazz Jackrabbit 2
  17.471 +Magic Carpet
  17.472 +Network Q RAC Rally
  17.473 +Quake
  17.474 +WinQuake
  17.475 +Quake 2 (SLOW - unsurprisingly)
  17.476 +Tomb Raider
  17.477 +Screamer
  17.478 +Screamer Rally
  17.479 +Virtual Pool (accelerated drivers work with both S3 and ET4000/W32)
  17.480 +Jedi Knight
  17.481 +Command & Conquer : Red Alert
  17.482 +Simcity 2000
  17.483 +
  17.484 +ZSNES
  17.485 +Genecyst
  17.486 +Kgen98

    18.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    18.2 +++ b/roms/acer386/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    18.3 @@ -0,0 +1,1 @@
    18.4 +This directory needs to contain some ROM files.
    18.5 \ No newline at end of file

    19.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    19.2 +++ b/roms/ami286/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    19.3 @@ -0,0 +1,1 @@
    19.4 +This directory needs to contain some ROM files.
    19.5 \ No newline at end of file

    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/roms/ami386/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    20.3 @@ -0,0 +1,1 @@
    20.4 +This directory needs to contain some ROM files.
    20.5 \ No newline at end of file

    21.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    21.2 +++ b/roms/ami486/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    21.3 @@ -0,0 +1,1 @@
    21.4 +This directory needs to contain some ROM files.
    21.5 \ No newline at end of file

    22.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    22.2 +++ b/roms/cmdpc30/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    22.3 @@ -0,0 +1,1 @@
    22.4 +This directory needs to contain some ROM files.
    22.5 \ No newline at end of file

    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/roms/dells200/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    23.3 @@ -0,0 +1,1 @@
    23.4 +This directory needs to contain some ROM files.
    23.5 \ No newline at end of file

    24.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    24.2 +++ b/roms/dtk/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    24.3 @@ -0,0 +1,1 @@
    24.4 +This directory needs to contain some ROM files.
    24.5 \ No newline at end of file

    25.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    25.2 +++ b/roms/europc/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    25.3 @@ -0,0 +1,1 @@
    25.4 +This directory needs to contain some ROM files.
    25.5 \ No newline at end of file

    26.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    26.2 +++ b/roms/genxt/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    26.3 @@ -0,0 +1,1 @@
    26.4 +This directory needs to contain some ROM files.
    26.5 \ No newline at end of file

    27.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    27.2 +++ b/roms/hot-433/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    27.3 @@ -0,0 +1,1 @@
    27.4 +This directory needs to contain some ROM files.
    27.5 \ No newline at end of file

    28.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    28.2 +++ b/roms/ibmat/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    28.3 @@ -0,0 +1,1 @@
    28.4 +This directory needs to contain some ROM files.
    28.5 \ No newline at end of file

    29.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    29.2 +++ b/roms/ibmpc/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    29.3 @@ -0,0 +1,1 @@
    29.4 +This directory needs to contain some ROM files.
    29.5 \ No newline at end of file

    30.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    30.2 +++ b/roms/ibmxt/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    30.3 @@ -0,0 +1,1 @@
    30.4 +This directory needs to contain some ROM files.
    30.5 \ No newline at end of file

    31.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    31.2 +++ b/roms/megapc/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    31.3 @@ -0,0 +1,1 @@
    31.4 +This directory needs to contain some ROM files.
    31.5 \ No newline at end of file

    32.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    32.2 +++ b/roms/olivetti_m24/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    32.3 @@ -0,0 +1,1 @@
    32.4 +This directory needs to contain some ROM files.
    32.5 \ No newline at end of file

    33.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    33.2 +++ b/roms/pc1512/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    33.3 @@ -0,0 +1,1 @@
    33.4 +This directory needs to contain some ROM files.
    33.5 \ No newline at end of file

    34.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    34.2 +++ b/roms/pc1640/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    34.3 @@ -0,0 +1,1 @@
    34.4 +This directory needs to contain some ROM files.
    34.5 \ No newline at end of file

    35.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    35.2 +++ b/roms/pc200/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    35.3 @@ -0,0 +1,1 @@
    35.4 +This directory needs to contain some ROM files.
    35.5 \ No newline at end of file

    36.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    36.2 +++ b/roms/pc2086/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    36.3 @@ -0,0 +1,1 @@
    36.4 +This directory needs to contain some ROM files.
    36.5 \ No newline at end of file

    37.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    37.2 +++ b/roms/pc3086/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    37.3 @@ -0,0 +1,1 @@
    37.4 +This directory needs to contain some ROM files.
    37.5 \ No newline at end of file

    38.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    38.2 +++ b/roms/tandy/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    38.3 @@ -0,0 +1,1 @@
    38.4 +This directory needs to contain some ROM files.
    38.5 \ No newline at end of file

    39.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    39.2 +++ b/roms/win486/roms.txt	Sun Apr 21 14:54:35 2013 +0100
    39.3 @@ -0,0 +1,1 @@
    39.4 +This directory needs to contain some ROM files.
    39.5 \ No newline at end of file

    40.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    40.2 +++ b/src/286.c	Sun Apr 21 14:54:35 2013 +0100
    40.3 @@ -0,0 +1,3787 @@
    40.4 +#include "ibm.h"
    40.5 +#include "x86.h"
    40.6 +#include "x86_flags.h"
    40.7 +#include "cpu.h"
    40.8 +#include "pit.h"
    40.9 +#include "keyboard.h"
   40.10 +
   40.11 +#define getword getword286
   40.12 +
   40.13 +#define checkio_perm(port) if (!IOPLp) \
   40.14 +                        { \
   40.15 +                                x86gpf(NULL,0); \
   40.16 +                                break; \
   40.17 +                        }
   40.18 +
   40.19 +#undef readmemb
   40.20 +#undef writememb
   40.21 +
   40.22 +#define readmemb(s,a) ((readlookup2[((s)+(a))>>12]==0xFFFFFFFF || (s)==0xFFFFFFFF)?readmemb386l(s,a):ram[readlookup2[((s)+(a))>>12]+(((s)+(a))&0xFFF)])
   40.23 +#define writememb(s,a,v) if (writelookup2[((s)+(a))>>12]==0xFFFFFFFF || (s)==0xFFFFFFFF) writememb386l(s,a,v); else ram[writelookup2[((s)+(a))>>12]+(((s)+(a))&0xFFF)]=v
   40.24 +#define writememw(s,a,v) if (writelookup2[((s)+(a))>>12]==0xFFFFFFFF || (s)==0xFFFFFFFF || (((s)+(a))&0xFFF)>0xFFE) writememwl(s,a,v); else *((uint16_t *)(&ram[writelookup2[((s)+(a))>>12]+(((s)+(a))&0xFFF)]))=v
   40.25 +
   40.26 +extern int keywaiting;
   40.27 +
   40.28 +#define checklimit(a)
   40.29 +
   40.30 +/*#define checklimit(a)   if (msw&1 && (a)) \
   40.31 +                        { \
   40.32 +                                pclog("Seg limit GPF at %04X:%04X\n",CS,pc); \
   40.33 +                                pclog("%04X %04X %04X %i %04X %04X\n", ealimitw, ealimit, eaaddr, mod, _ds.limit, _ss.limit); \
   40.34 +                                x86gpf(NULL,0); \
   40.35 +                                break; \
   40.36 +                        }*/
   40.37 +
   40.38 +#define NOTRM   if (!(msw & 1))\
   40.39 +                { \
   40.40 +                        x86_int(6); \
   40.41 +                        break; \
   40.42 +                }
   40.43 +
   40.44 +
   40.45 +static inline uint8_t geteab()
   40.46 +{
   40.47 +        if (mod==3)
   40.48 +           return (rm&4)?regs[rm&3].b.h:regs[rm&3].b.l;
   40.49 +//        cycles-=3;
   40.50 +        return readmemb(easeg, eaaddr);
   40.51 +}
   40.52 +
   40.53 +static inline uint16_t geteaw()
   40.54 +{
   40.55 +        if (mod==3)
   40.56 +           return regs[rm].w;
   40.57 +//        cycles-=3;
   40.58 +//        if (output==3) printf("GETEAW %04X:%08X\n",easeg,eaaddr);
   40.59 +        return readmemw(easeg, eaaddr);
   40.60 +}
   40.61 +
   40.62 +static inline uint16_t geteaw2()
   40.63 +{
   40.64 +        if (mod==3)
   40.65 +           return regs[rm].w;
   40.66 +//        cycles-=2;
   40.67 +//        printf("Getting addr from %04X:%04X %05X\n",easeg,eaaddr+2,easeg+eaaddr+2);
   40.68 +        return readmemw(easeg,(eaaddr+2)&0xFFFF);
   40.69 +}
   40.70 +
   40.71 +static inline void seteab(uint8_t val)
   40.72 +{
   40.73 +        if (mod==3)
   40.74 +        {
   40.75 +                if (rm&4) regs[rm&3].b.h=val;
   40.76 +                else      regs[rm&3].b.l=val;
   40.77 +        }
   40.78 +        else
   40.79 +        {
   40.80 +//                cycles-=2;
   40.81 +                writememb(easeg, eaaddr, val);
   40.82 +        }
   40.83 +}
   40.84 +
   40.85 +static inline void seteaw(uint16_t val)
   40.86 +{
   40.87 +        if (mod==3)
   40.88 +           regs[rm].w=val;
   40.89 +        else
   40.90 +        {
   40.91 +//                cycles-=2;
   40.92 +                writememw(easeg, eaaddr, val);
   40.93 +//                writememb(easeg+eaaddr+1,val>>8);
   40.94 +        }
   40.95 +}
   40.96 +
   40.97 +#undef fetchea
   40.98 +
   40.99 +#define fetchea()   { rmdat=readmemb(cs, pc); pc++;     \
  40.100 +                    reg=(rmdat>>3)&7;                  \
  40.101 +                    mod=(rmdat>>6)&3;                  \
  40.102 +                    rm=rmdat&7;                        \
  40.103 +                    if (mod!=3) fetcheal286(); }
  40.104 +
  40.105 +void fetcheal286()
  40.106 +{
  40.107 +        if (!mod && rm==6) { eaaddr=getword(); easeg=ds; ealimit=_ds.limit; ealimitw=_ds.limitw; }
  40.108 +        else
  40.109 +        {
  40.110 +                switch (mod)
  40.111 +                {
  40.112 +                        case 0:
  40.113 +                        eaaddr=0;
  40.114 +                        break;
  40.115 +                        case 1:
  40.116 +                        eaaddr=(uint16_t)(int8_t)readmemb(cs, pc); pc++;
  40.117 +                        break;
  40.118 +                        case 2:
  40.119 +                        eaaddr=getword();
  40.120 +                        break;
  40.121 +                }
  40.122 +                eaaddr+=(*mod1add[0][rm])+(*mod1add[1][rm]);
  40.123 +                easeg=*mod1seg[rm];
  40.124 +                if (mod1seg[rm] == &ss) { ealimit=_ss.limit; ealimitw=_ss.limitw; }
  40.125 +                else                    { ealimit=_ds.limit; ealimitw=_ds.limitw; }
  40.126 +//                if (output) pclog("Limit %08X %08X %08X %08X\n",ealimit,_ds.limit,mod1seg[rm],&ss);
  40.127 +        }
  40.128 +        eaaddr&=0xFFFF;        
  40.129 +}
  40.130 +
  40.131 +void rep286(int fv)
  40.132 +{
  40.133 +        uint8_t temp;
  40.134 +        uint32_t c;//=CX;
  40.135 +        uint8_t temp2;
  40.136 +        uint16_t tempw,tempw2,tempw3,of=flags;
  40.137 +        uint32_t ipc=oldpc;//pc-1;
  40.138 +        int changeds=0;
  40.139 +        uint32_t oldds;
  40.140 +        uint32_t templ,templ2;
  40.141 +        int tempz;
  40.142 +        int tempi;
  40.143 +//        if (output) pclog("REP32 %04X %04X  ",use32,rep32);
  40.144 +        startrep:
  40.145 +        temp=opcode2=readmemb(cs,pc); pc++;
  40.146 +//        if (firstrepcycle && temp==0xA5) pclog("REP MOVSW %06X:%04X %06X:%04X\n",ds,SI,es,DI);
  40.147 +//        if (output) pclog("REP %02X %04X\n",temp,ipc);
  40.148 +        c = CX;
  40.149 +/*        if (rep32 && (msw&1))
  40.150 +        {
  40.151 +                if (temp!=0x67 && temp!=0x66 && (rep32|temp)!=0x1AB && (rep32|temp)!=0x3AB) pclog("32-bit REP %03X %08X %04X:%06X\n",temp|rep32,c,CS,pc);
  40.152 +        }*/
  40.153 +        switch (temp)
  40.154 +        {
  40.155 +                case 0x26: /*ES:*/
  40.156 +                oldds=ds;
  40.157 +                ds=es;
  40.158 +                rds=ES;
  40.159 +                changeds=1;
  40.160 +                goto startrep;
  40.161 +                break;
  40.162 +                case 0x2E: /*CS:*/
  40.163 +                oldds=ds;
  40.164 +                ds=cs;
  40.165 +                rds=CS;
  40.166 +                changeds=1;
  40.167 +                goto startrep;
  40.168 +                break;
  40.169 +                case 0x36: /*SS:*/
  40.170 +                oldds=ds;
  40.171 +                ds=ss;
  40.172 +                rds=SS;
  40.173 +                changeds=1;
  40.174 +                goto startrep;
  40.175 +                break;
  40.176 +                case 0x3E: /*DS:*/
  40.177 +                oldds=ds;
  40.178 +                ds=ds;
  40.179 +                changeds=1;
  40.180 +                goto startrep;
  40.181 +                break;
  40.182 +                case 0x6C: /*REP INSB*/
  40.183 +                if (c>0)
  40.184 +                {
  40.185 +                        checkio_perm(DX);
  40.186 +                        temp2=inb(DX);
  40.187 +                        writememb(es,DI,temp2);
  40.188 +                        if (abrt) break;
  40.189 +                        if (flags&D_FLAG) DI--;
  40.190 +                        else              DI++;
  40.191 +                        c--;
  40.192 +                        cycles-=15;
  40.193 +                }
  40.194 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.195 +                else firstrepcycle=1;
  40.196 +                break;
  40.197 +                case 0x6D: /*REP INSW*/
  40.198 +                if (c>0)
  40.199 +                {
  40.200 +                        tempw=inw(DX);
  40.201 +                        writememw(es,DI,tempw);
  40.202 +                        if (abrt) break;
  40.203 +                        if (flags&D_FLAG) DI-=2;
  40.204 +                        else              DI+=2;
  40.205 +                        c--;
  40.206 +                        cycles-=15;
  40.207 +                }
  40.208 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.209 +                else firstrepcycle=1;
  40.210 +                break;
  40.211 +                case 0x6E: /*REP OUTSB*/
  40.212 +                if (c>0)
  40.213 +                {
  40.214 +                        temp2=readmemb(ds,SI);
  40.215 +                        if (abrt) break;
  40.216 +                        checkio_perm(DX);
  40.217 +                        outb(DX,temp2);
  40.218 +                        if (flags&D_FLAG) SI--;
  40.219 +                        else              SI++;
  40.220 +                        c--;
  40.221 +                        cycles-=14;
  40.222 +                }
  40.223 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.224 +                else firstrepcycle=1;
  40.225 +                break;
  40.226 +                case 0x6F: /*REP OUTSW*/
  40.227 +                if (c>0)
  40.228 +                {
  40.229 +                        tempw=readmemw(ds,SI);
  40.230 +                        if (abrt) break;
  40.231 +//                        pclog("OUTSW %04X -> %04X\n",SI,tempw);
  40.232 +                        outw(DX,tempw);
  40.233 +                        if (flags&D_FLAG) SI-=2;
  40.234 +                        else              SI+=2;
  40.235 +                        c--;
  40.236 +                        cycles-=14;
  40.237 +                }
  40.238 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.239 +                else firstrepcycle=1;
  40.240 +                break;
  40.241 +                case 0xA4: /*REP MOVSB*/
  40.242 +                if (c>0)
  40.243 +                {
  40.244 +                        temp2=readmemb(ds,SI);  if (abrt) break;
  40.245 +                        writememb(es,DI,temp2); if (abrt) break;
  40.246 +//                        if (output==3) pclog("MOVSB %08X:%04X -> %08X:%04X %02X\n",ds,SI,es,DI,temp2);
  40.247 +                        if (flags&D_FLAG) { DI--; SI--; }
  40.248 +                        else              { DI++; SI++; }
  40.249 +                        c--;
  40.250 +                        cycles-=(is486)?3:4;
  40.251 +                }
  40.252 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.253 +                else firstrepcycle=1;
  40.254 +                break;
  40.255 +                case 0xA5: /*REP MOVSW*/
  40.256 +                if (c>0)
  40.257 +                {
  40.258 +                        tempw=readmemw(ds,SI);  if (abrt) break;
  40.259 +                        writememw(es,DI,tempw); if (abrt) break;
  40.260 +                        if (flags&D_FLAG) { DI-=2; SI-=2; }
  40.261 +                        else              { DI+=2; SI+=2; }
  40.262 +                        c--;
  40.263 +                        cycles-=(is486)?3:4;
  40.264 +                }
  40.265 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.266 +                else firstrepcycle=1;
  40.267 +                break;
  40.268 +                case 0xA6: /*REP CMPSB*/
  40.269 +                if (fv) flags|=Z_FLAG;
  40.270 +                else    flags&=~Z_FLAG;
  40.271 +                if ((c>0) && (fv==((flags&Z_FLAG)?1:0)))
  40.272 +                {
  40.273 +                        temp=readmemb(ds,SI);
  40.274 +                        temp2=readmemb(es,DI);
  40.275 +                        if (abrt) { flags=of; break; }
  40.276 +                        if (flags&D_FLAG) { DI--; SI--; }
  40.277 +                        else              { DI++; SI++; }
  40.278 +                        c--;
  40.279 +                        cycles-=(is486)?7:9;
  40.280 +                        setsub8(temp,temp2);
  40.281 +                }
  40.282 +                if ((c>0) && (fv==((flags&Z_FLAG)?1:0))) { pc=ipc; firstrepcycle=0; if (ssegs) ssegs++; }
  40.283 +                else firstrepcycle=1;
  40.284 +                break;
  40.285 +                case 0xA7: /*REP CMPSW*/
  40.286 +                if (fv) flags|=Z_FLAG;
  40.287 +                else    flags&=~Z_FLAG;
  40.288 +                if ((c>0) && (fv==((flags&Z_FLAG)?1:0)))
  40.289 +                {
  40.290 +                        tempw=readmemw(ds,SI);
  40.291 +                        tempw2=readmemw(es,DI);
  40.292 +                        if (abrt) { flags=of; break; }
  40.293 +                        if (flags&D_FLAG) { DI-=2; SI-=2; }
  40.294 +                        else              { DI+=2; SI+=2; }
  40.295 +                        c--;
  40.296 +                        cycles-=(is486)?7:9;
  40.297 +                        setsub16(tempw,tempw2);
  40.298 +                }
  40.299 +                if ((c>0) && (fv==((flags&Z_FLAG)?1:0))) { pc=ipc; firstrepcycle=0; if (ssegs) ssegs++; }
  40.300 +                else firstrepcycle=1;
  40.301 +                break;
  40.302 +
  40.303 +                case 0xAA: /*REP STOSB*/
  40.304 +                if (c>0)
  40.305 +                {
  40.306 +                        writememb(es,DI,AL);
  40.307 +                        if (abrt) break;
  40.308 +                        if (flags&D_FLAG) DI--;
  40.309 +                        else              DI++;
  40.310 +                        c--;
  40.311 +                        cycles-=(is486)?4:5;
  40.312 +                }
  40.313 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.314 +                else firstrepcycle=1;
  40.315 +                break;
  40.316 +                case 0xAB: /*REP STOSW*/
  40.317 +                if (c>0)
  40.318 +                {
  40.319 +                        writememw(es,DI,AX);
  40.320 +                        if (abrt) break;
  40.321 +                        if (flags&D_FLAG) DI-=2;
  40.322 +                        else              DI+=2;
  40.323 +                        c--;
  40.324 +                        cycles-=(is486)?4:5;
  40.325 +                }
  40.326 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.327 +                else firstrepcycle=1;
  40.328 +                break;
  40.329 +                case 0xAC: /*REP LODSB*/
  40.330 +//                if (ds==0xFFFFFFFF) pclog("Null selector REP LODSB %04X(%06X):%06X\n",CS,cs,pc);
  40.331 +                if (c>0)
  40.332 +                {
  40.333 +                        AL=readmemb(ds,SI);
  40.334 +                        if (abrt) break;
  40.335 +                        if (flags&D_FLAG) SI--;
  40.336 +                        else              SI++;
  40.337 +                        c--;
  40.338 +                        cycles-=5;
  40.339 +                }
  40.340 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.341 +                else firstrepcycle=1;
  40.342 +                break;
  40.343 +                case 0xAD: /*REP LODSW*/
  40.344 +//                if (ds==0xFFFFFFFF) pclog("Null selector REP LODSW %04X(%06X):%06X\n",CS,cs,pc);
  40.345 +                if (c>0)
  40.346 +                {
  40.347 +                        AX=readmemw(ds,SI);
  40.348 +                        if (abrt) break;
  40.349 +                        if (flags&D_FLAG) SI-=2;
  40.350 +                        else              SI+=2;
  40.351 +                        c--;
  40.352 +                        cycles-=5;
  40.353 +                }
  40.354 +                if (c>0) { firstrepcycle=0; pc=ipc; if (ssegs) ssegs++; }
  40.355 +                else firstrepcycle=1;
  40.356 +                break;
  40.357 +                case 0xAE: /*REP SCASB*/
  40.358 +//                if (es==0xFFFFFFFF) pclog("Null selector REP SCASB %04X(%06X):%06X\n",CS,cs,pc);
  40.359 +//                tempz=(fv)?1:0;
  40.360 +                if (fv) flags|=Z_FLAG;
  40.361 +                else    flags&=~Z_FLAG;
  40.362 +                if ((c>0) && (fv==((flags&Z_FLAG)?1:0)))
  40.363 +                {
  40.364 +                        temp2=readmemb(es,DI);
  40.365 +                        if (abrt) { flags=of; break; }
  40.366 +                        setsub8(AL,temp2);
  40.367 +                        if (flags&D_FLAG) DI--;
  40.368 +                        else              DI++;
  40.369 +                        c--;
  40.370 +                        cycles-=(is486)?5:8;
  40.371 +                }
  40.372 +                if ((c>0) && (fv==((flags&Z_FLAG)?1:0)))  { pc=ipc; firstrepcycle=0; if (ssegs) ssegs++; }
  40.373 +                else firstrepcycle=1;
  40.374 +                break;
  40.375 +                case 0xAF: /*REP SCASW*/
  40.376 +//                if (es==0xFFFFFFFF) pclog("Null selector REP SCASW %04X(%06X):%06X\n",CS,cs,pc);
  40.377 +                if (fv) flags|=Z_FLAG;
  40.378 +                else    flags&=~Z_FLAG;
  40.379 +                if ((c>0) && (fv==((flags&Z_FLAG)?1:0)))
  40.380 +                {
  40.381 +                        tempw=readmemw(es,DI);
  40.382 +                        if (abrt) { flags=of; break; }
  40.383 +                        setsub16(AX,tempw);
  40.384 +                        if (flags&D_FLAG) DI-=2;
  40.385 +                        else              DI+=2;
  40.386 +                        c--;
  40.387 +                        cycles-=(is486)?5:8;
  40.388 +                }
  40.389 +                if ((c>0) && (fv==((flags&Z_FLAG)?1:0)))  { pc=ipc; firstrepcycle=0; if (ssegs) ssegs++; }
  40.390 +                else firstrepcycle=1;
  40.391 +                break;
  40.392 +
  40.393 +                default:
  40.394 +                        pc=ipc;
  40.395 +                        cycles-=20;
  40.396 +                x86illegal();
  40.397 +                pclog("Bad REP %02X\n", temp);
  40.398 +                //dumpregs();
  40.399 +                //exit(-1);
  40.400 +        }
  40.401 +        CX=c;
  40.402 +        if (changeds) ds=oldds;
  40.403 +//        if (output) pclog("%03X %03X\n",rep32,use32);
  40.404 +}
  40.405 +
  40.406 +void x86illegal()
  40.407 +{
  40.408 +        uint16_t addr;
  40.409 +        pclog("x86 illegal %04X %08X %04X:%08X %02X\n",msw,cr0,CS,pc,opcode);
  40.410 +//        if (output)
  40.411 +//        {
  40.412 +//                dumpregs();
  40.413 +//                exit(-1);
  40.414 +//        }
  40.415 +        if (msw&1)
  40.416 +        {
  40.417 +                pmodeint(6,0);
  40.418 +        }
  40.419 +        else
  40.420 +        {
  40.421 +                if (ssegs) { ss=oldss; _ss.limit=oldsslimit; _ss.limitw=oldsslimitw; }
  40.422 +                writememw(ss,((SP-2)&0xFFFF),flags);
  40.423 +                writememw(ss,((SP-4)&0xFFFF),CS);
  40.424 +                writememw(ss,((SP-6)&0xFFFF),pc);
  40.425 +                SP-=6;
  40.426 +                flags&=~I_FLAG;
  40.427 +                flags&=~T_FLAG;
  40.428 +                addr=6<<2;
  40.429 +                pc=readmemw(0,addr);
  40.430 +                loadcs(readmemw(0,addr+2));
  40.431 +        }
  40.432 +        cycles-=70;
  40.433 +}
  40.434 +//#endif
  40.435 +//#if 0
  40.436 +
  40.437 +static inline uint8_t getbytef()
  40.438 +{
  40.439 +        uint8_t temp = readmemb(cs, pc); pc++;
  40.440 +        return temp;
  40.441 +}
  40.442 +static inline uint16_t getwordf()
  40.443 +{
  40.444 +        uint16_t tempw = readmemw(cs, pc); pc+=2;
  40.445 +        return tempw;
  40.446 +}
  40.447 +
  40.448 +/*Conditional jump timing is WRONG*/
  40.449 +void exec286(int cycs)
  40.450 +{
  40.451 +        uint8_t temp,temp2;
  40.452 +        uint16_t addr,tempw,tempw2,tempw3,tempw4;
  40.453 +        int8_t offset;
  40.454 +        volatile int tempws, tempws2;
  40.455 +        uint32_t templ, templ2, templ3;
  40.456 +        int8_t temps;
  40.457 +        int16_t temps16;
  40.458 +        int c;//,cycdiff;
  40.459 +        int tempi;
  40.460 +        FILE *f;
  40.461 +        int trap;
  40.462 +        int cyclast;
  40.463 +//        printf("Run 286! %i %i\n",cycles,cycs);
  40.464 +        cycles+=cycs;
  40.465 +//        i86_Execute(cycs);
  40.466 +//        return;
  40.467 +        while (cycles>0)
  40.468 +        {
  40.469 +                cyclast = cycdiff;
  40.470 +                cycdiff=cycles;
  40.471 +                oldcs=CS;
  40.472 +                oldpc=pc;
  40.473 +                oldcpl=CPL;
  40.474 +                
  40.475 +                opcodestart:
  40.476 +                opcode = readmemb(cs, pc);
  40.477 +                if (abrt) goto opcodeend;
  40.478 +                tempc=flags&C_FLAG;
  40.479 +                trap=flags&T_FLAG;
  40.480 +                
  40.481 +                if (output && /*cs<0xF0000 && */!ssegs)//opcode!=0x26 && opcode!=0x36 && opcode!=0x2E && opcode!=0x3E)
  40.482 +                {
  40.483 +                        if ((opcode!=0xF2 && opcode!=0xF3) || firstrepcycle)
  40.484 +                        {
  40.485 +                                if (!skipnextprint) printf("%04X(%06X):%04X : %04X %04X %04X %04X %04X(%06X) %04X(%06X) %04X(%06X) %04X(%06X) %04X %04X %04X %04X %02X %04X  %04X  %04X %04X %04X  %08X %i %i  %i %08X  %i %f %f\n",CS,cs,pc,AX,BX,CX,DX,CS,cs,DS,ds,ES,es,SS,ss,DI,SI,BP,SP,opcode,flags,msw,ram[0x7c3e],ram[(0x7c3e)+3],ram[0x7c40],_ds.limitw,keybsenddelay,keywaiting,ins, _ss.limit, cyclast, pit.c[1], PITCONST);
  40.486 +                                skipnextprint=0;
  40.487 +//                                ins++;
  40.488 +/*                                if (ins==50000)
  40.489 +                                {
  40.490 +                                        dumpregs();
  40.491 +                                        exit(-1);
  40.492 +                                }*/
  40.493 +/*                                if (ins==500000)
  40.494 +                                {
  40.495 +                                        dumpregs();
  40.496 +                                        exit(-1);
  40.497 +                                }*/
  40.498 +                        }
  40.499 +                }
  40.500 +//#endif
  40.501 +                pc++;
  40.502 +                inhlt=0;
  40.503 +//                if (ins==500000) { dumpregs(); exit(0); }*/
  40.504 +                switch (opcode)
  40.505 +                {
  40.506 +                        case 0x00: /*ADD 8,reg*/
  40.507 +                        fetchea();
  40.508 +                        //if (!rmdat && output) pc--;
  40.509 +/*                        if (!rmdat && output)
  40.510 +                        {
  40.511 +                                pclog("Crashed\n");
  40.512 +//                                clear_keybuf();
  40.513 +//                                readkey();
  40.514 +                                dumpregs();
  40.515 +                                exit(-1);
  40.516 +                        }*/
  40.517 +                        if (mod == 3)
  40.518 +                        {
  40.519 +                                temp  = getr8(rm);
  40.520 +                                temp2 = getr8(reg);
  40.521 +                                setadd8(temp, temp2);
  40.522 +                                setr8(rm, temp + temp2);
  40.523 +                                cycles -= 2;
  40.524 +                        }
  40.525 +                        else
  40.526 +                        {
  40.527 +                                temp  = geteab();     if (abrt) break;
  40.528 +                                temp2 = getr8(reg);
  40.529 +                                seteab(temp + temp2); if (abrt) break;
  40.530 +                                setadd8(temp, temp2);
  40.531 +                                cycles -= 7;
  40.532 +                        }
  40.533 +                        break;
  40.534 +                        case 0x01: /*ADD 16,reg*/
  40.535 +                        fetchea();
  40.536 +                        if (mod == 3)
  40.537 +                        {
  40.538 +                                setadd16(regs[rm].w, regs[reg].w);
  40.539 +                                regs[rm].w += regs[reg].w;
  40.540 +                                cycles -= 2;
  40.541 +                        }
  40.542 +                        else
  40.543 +                        {
  40.544 +                                tempw = geteaw();             if (abrt) break;
  40.545 +                                seteaw(tempw + regs[reg].w);  if (abrt) break;
  40.546 +                                setadd16(tempw, regs[reg].w);
  40.547 +                                cycles -= 7;
  40.548 +                        }
  40.549 +                        break;
  40.550 +                        case 0x02: /*ADD reg,8*/
  40.551 +                        fetchea();
  40.552 +                        temp=geteab();        if (abrt) break;
  40.553 +                        setadd8(getr8(reg),temp);
  40.554 +                        setr8(reg,getr8(reg)+temp);
  40.555 +                        cycles -= (mod == 3) ? 2 : 7;
  40.556 +                        break;
  40.557 +                        case 0x03: /*ADD reg,16*/
  40.558 +                        fetchea();
  40.559 +                        tempw=geteaw();       if (abrt) break;
  40.560 +                        setadd16(regs[reg].w,tempw);
  40.561 +                        regs[reg].w+=tempw;
  40.562 +                        cycles -= (mod == 3) ? 2 : 7;
  40.563 +                        break;
  40.564 +                        case 0x04: /*ADD AL,#8*/
  40.565 +                        temp=getbytef();
  40.566 +                        setadd8(AL,temp);
  40.567 +                        AL+=temp;
  40.568 +                        cycles -= 3;
  40.569 +                        break;
  40.570 +                        case 0x05: /*ADD AX,#16*/
  40.571 +                        tempw=getwordf();
  40.572 +                        setadd16(AX,tempw);
  40.573 +                        AX+=tempw;
  40.574 +                        cycles -= 3;
  40.575 +                        break;
  40.576 +
  40.577 +                        case 0x06: /*PUSH ES*/
  40.578 +                        if (ssegs) ss=oldss;
  40.579 +                        writememw(ss,((SP-2)&0xFFFF),ES); if (abrt) break;
  40.580 +                        SP-=2;
  40.581 +                        cycles-=3;
  40.582 +                        break;
  40.583 +                        case 0x07: 
  40.584 +                        if (ssegs) ss=oldss;
  40.585 +                        tempw=readmemw(ss,SP);          if (abrt) break;
  40.586 +                        loadseg(tempw,&_es);            if (abrt) break;
  40.587 +                        SP+=2;
  40.588 +                        cycles -= (msw & 1) ? 20 : 5;
  40.589 +                        break;
  40.590 +
  40.591 +                        case 0x08: /*OR 8,reg*/
  40.592 +                        fetchea();
  40.593 +                        if (mod == 3)
  40.594 +                        {
  40.595 +                                temp  = getr8(rm) | getr8(reg);
  40.596 +                                setr8(rm, temp);
  40.597 +                                setznp8(temp);
  40.598 +                                cycles -= 2;
  40.599 +                        }
  40.600 +                        else
  40.601 +                        {
  40.602 +                                temp  = geteab();          if (abrt) break;
  40.603 +                                temp2 = getr8(reg);
  40.604 +                                seteab(temp | temp2);     if (abrt) break;
  40.605 +                                setznp8(temp | temp2);
  40.606 +                                cycles -= 7;
  40.607 +                        }
  40.608 +                        break;
  40.609 +                        case 0x09: /*OR 16,reg*/
  40.610 +                        fetchea();
  40.611 +                        if (mod == 3)
  40.612 +                        {
  40.613 +                                regs[rm].w |= regs[reg].w;
  40.614 +                                setznp16(regs[rm].w);
  40.615 +                                cycles -= 2;
  40.616 +                        }
  40.617 +                        else
  40.618 +                        {
  40.619 +                                tempw = geteaw() | regs[reg].w; if (abrt) break;
  40.620 +                                seteaw(tempw);                  if (abrt) break;
  40.621 +                                setznp16(tempw);
  40.622 +                                cycles -= 7;
  40.623 +                        }
  40.624 +                        break;
  40.625 +                        case 0x0A: /*OR reg,8*/
  40.626 +                        fetchea();
  40.627 +                        temp=geteab();          if (abrt) break;
  40.628 +                        temp|=getr8(reg);
  40.629 +                        setznp8(temp);
  40.630 +                        setr8(reg,temp);
  40.631 +                        cycles -= (mod == 3) ? 2 : 7;
  40.632 +                        break;
  40.633 +                        case 0x0B: /*OR reg,16*/
  40.634 +                        fetchea();
  40.635 +                        tempw=geteaw();         if (abrt) break;
  40.636 +                        tempw|=regs[reg].w;
  40.637 +                        setznp16(tempw);
  40.638 +                        regs[reg].w=tempw;
  40.639 +                        cycles -= (mod == 3) ? 2 : 7;
  40.640 +                        break;
  40.641 +                        case 0x0C: /*OR AL,#8*/
  40.642 +                        AL|=getbytef();
  40.643 +                        setznp8(AL);
  40.644 +                        cycles -= 2;
  40.645 +                        break;
  40.646 +                        case 0x0D: /*OR AX,#16*/
  40.647 +                        AX|=getwordf();
  40.648 +                        setznp16(AX);
  40.649 +                        cycles -= 2;
  40.650 +                        break;
  40.651 +
  40.652 +                        case 0x0E: /*PUSH CS*/
  40.653 +                        if (ssegs) ss=oldss;
  40.654 +                        writememw(ss,((SP-2)&0xFFFF),CS);       if (abrt) break;
  40.655 +                        SP-=2;
  40.656 +                        cycles-=3;
  40.657 +                        break;
  40.658 +
  40.659 +                        case 0x0F:
  40.660 +                        temp = readmemb(cs, pc); pc++;
  40.661 +                        opcode2 = temp;
  40.662 +//                        if (temp>5 && temp!=0x82 && temp!=0x85 && temp!=0x84 && temp!=0x87 && temp!=0x8D && temp!=0x8F && temp!=0x8C && temp!=0x20 && temp!=0x22) pclog("Using magic 386 0F instruction %02X!\n",temp);
  40.663 +                        switch (temp)
  40.664 +                        {
  40.665 +                                case 0:
  40.666 +                                fetchea(); if (abrt) break;
  40.667 +                                switch (rmdat&0x38)
  40.668 +                                {
  40.669 +                                        case 0x00: /*SLDT*/
  40.670 +                                        NOTRM
  40.671 +                                        seteaw(ldt.seg);
  40.672 +                                        cycles -= (mod == 3) ? 3 : 2;
  40.673 +                                        break;
  40.674 +                                        case 0x08: /*STR*/
  40.675 +                                        NOTRM
  40.676 +                                        seteaw(tr.seg);
  40.677 +                                        cycles -= (mod == 3) ? 3 : 2;
  40.678 +                                        break;
  40.679 +                                        case 0x10: /*LLDT*/
  40.680 +                                        if (CPL && (msw & 1))
  40.681 +                                        {
  40.682 +                                                pclog("Invalid LLDT!\n");
  40.683 +                                                x86gpf(NULL,0);
  40.684 +                                                break;
  40.685 +                                        }
  40.686 +                                        NOTRM
  40.687 +                                        ldt.seg=geteaw();
  40.688 +//                                        pclog("Load LDT %04X ",ldt.seg);
  40.689 +                                        templ=(ldt.seg&~7)+gdt.base;
  40.690 +//                                        pclog("%06X ",gdt.base);
  40.691 +                                        templ3=readmemw(0,templ)+((readmemb(0,templ+6)&0xF)<<16);
  40.692 +                                        templ2=(readmemw(0,templ+2))|(readmemb(0,templ+4)<<16)|(readmemb(0,templ+7)<<24);
  40.693 +                                        if (abrt) break;
  40.694 +                                        ldt.limit=templ3;
  40.695 +                                        ldt.access=readmemb(0,templ+6);
  40.696 +                                        if (readmemb(0,templ+6)&0x80)
  40.697 +                                        {
  40.698 +                                                ldt.limit<<=12;
  40.699 +                                                ldt.limit|=0xFFF;
  40.700 +                                        }
  40.701 +                                        ldt.base=templ2;
  40.702 +//                                        /*if (output==3) */pclog("LLDT %04X %08X %04X  %08X %08X\n",ldt.seg,ldt.base,ldt.limit,readmeml(0,templ),readmeml(0,templ+4));
  40.703 +
  40.704 +                                        cycles -= (mod == 3) ? 17 : 19;
  40.705 +                                        break;
  40.706 +                                        case 0x18: /*LTR*/
  40.707 +                                        if (CPL && (msw & 1))
  40.708 +                                        {
  40.709 +                                                pclog("Invalid LTR!\n");
  40.710 +                                                x86gpf(NULL,0);
  40.711 +                                                break;
  40.712 +                                        }
  40.713 +                                        NOTRM
  40.714 +                                        tr.seg=geteaw();
  40.715 +                                        templ=(tr.seg&~7)+gdt.base;
  40.716 +                                        templ3=readmemw(0,templ)+((readmemb(0,templ+6)&0xF)<<16);
  40.717 +                                        templ2=(readmemw(0,templ+2))|(readmemb(0,templ+4)<<16)|(readmemb(0,templ+7)<<24);
  40.718 +                                        temp=readmemb(0,templ+5);
  40.719 +                                        if (abrt) break;
  40.720 +                                        tr.limit=templ3;
  40.721 +                                        tr.access=readmemb(0,templ+6);
  40.722 +                                        if (readmemb(0,templ+6)&0x80)
  40.723 +                                        {
  40.724 +                                                tr.limit<<=12;
  40.725 +                                                tr.limit|=0xFFF;
  40.726 +                                        }
  40.727 +                                        tr.base=templ2;
  40.728 +//                                        pclog("TR base = %08X\n",templ2);
  40.729 +                                        tr.access=temp;
  40.730 +                                        cycles -= (mod == 3) ? 17 : 19;
  40.731 +                                        break;
  40.732 +                                        case 0x20: /*VERR*/
  40.733 +                                        NOTRM
  40.734 +                                        tempw=geteaw(); if (abrt) break;
  40.735 +                                        flags&=~Z_FLAG;
  40.736 +                                        if (!(tempw&0xFFFC)) break; /*Null selector*/
  40.737 +                                        cpl_override=1;
  40.738 +                                        tempi=(tempw&~7)<((tempw&4)?ldt.limit:gdt.limit);
  40.739 +                                        tempw2=readmemw(0,((tempw&4)?ldt.base:gdt.base)+(tempw&~7)+4);
  40.740 +                                        cpl_override=0;
  40.741 +                                        if (abrt) break;
  40.742 +                                        if (!(tempw2&0x1000)) tempi=0;
  40.743 +                                        if ((tempw2&0xC00)!=0xC00) /*Exclude conforming code segments*/
  40.744 +                                        {
  40.745 +                                                tempw3=(tempw2>>13)&3; /*Check permissions*/
  40.746 +                                                if (tempw3<CPL || tempw3<(tempw&3)) tempi=0;
  40.747 +                                        }
  40.748 +                                        if ((tempw2&0x0800) && !(tempw2&0x0200)) tempi=0; /*Non-readable code*/
  40.749 +                                        if (tempi) flags|=Z_FLAG;
  40.750 +                                        cycles -= (mod == 3) ? 14 : 16;
  40.751 +                                        break;
  40.752 +                                        case 0x28: /*VERW*/
  40.753 +                                        NOTRM
  40.754 +                                        tempw=geteaw(); if (abrt) break;
  40.755 +                                        flags&=~Z_FLAG;
  40.756 +                                        if (!(tempw&0xFFFC)) break; /*Null selector*/
  40.757 +                                        cpl_override=1;
  40.758 +                                        tempi=(tempw&~7)<((tempw&4)?ldt.limit:gdt.limit);
  40.759 +                                        tempw2=readmemw(0,((tempw&4)?ldt.base:gdt.base)+(tempw&~7)+4);
  40.760 +                                        cpl_override=0;
  40.761 +                                        if (abrt) break;
  40.762 +                                        if (!(tempw2&0x1000)) tempi=0;
  40.763 +                                        tempw3=(tempw2>>13)&3; /*Check permissions*/
  40.764 +                                        if (tempw3<CPL || tempw3<(tempw&3)) tempi=0;
  40.765 +                                        if (tempw2&0x0800) tempi=0; /*Code*/
  40.766 +                                        else if (!(tempw2&0x0200)) tempi=0; /*Read-only data*/
  40.767 +                                        if (tempi) flags|=Z_FLAG;
  40.768 +                                        cycles -= (mod == 3) ? 14 : 16;
  40.769 +                                        break;
  40.770 +
  40.771 +
  40.772 +                                        default:
  40.773 +                                        pclog("Bad 0F 00 opcode %02X\n",rmdat&0x38);
  40.774 +                                        pc-=3;
  40.775 +                                        x86illegal();
  40.776 +                                        break;
  40.777 +//                                        dumpregs();
  40.778 +//                                        exit(-1);
  40.779 +                                }
  40.780 +                                break;
  40.781 +                                case 1:
  40.782 +                                fetchea(); if (abrt) break;
  40.783 +                                switch (rmdat&0x38)
  40.784 +                                {
  40.785 +                                        case 0x00: /*SGDT*/
  40.786 +                                        seteaw(gdt.limit);
  40.787 +                                        writememw(easeg, eaaddr + 2, gdt.base);
  40.788 +                                        writememw(easeg, eaaddr + 4, (gdt.base >> 16) | 0xFF00);
  40.789 +                                        cycles -= 11;
  40.790 +                                        break;
  40.791 +                                        case 0x08: /*SIDT*/
  40.792 +                                        seteaw(idt.limit);
  40.793 +                                        writememw(easeg, eaaddr + 2, idt.base);
  40.794 +                                        writememw(easeg, eaaddr + 4, (idt.base >> 16) | 0xFF00);
  40.795 +                                        cycles -= 12;
  40.796 +                                        break;
  40.797 +                                        case 0x10: /*LGDT*/
  40.798 +                                        if (CPL && (msw & 1))
  40.799 +                                        {
  40.800 +                                                pclog("Invalid LGDT!\n");
  40.801 +                                                x86gpf(NULL,0);
  40.802 +                                                break;
  40.803 +                                        }
  40.804 +                                        tempw=geteaw();
  40.805 +                                        templ=readmeml(0,easeg+eaaddr+2)&0xFFFFFF;
  40.806 +                                        if (abrt) break;
  40.807 +                                        gdt.limit=tempw;
  40.808 +                                        gdt.base=templ;
  40.809 +                                        cycles-=11;
  40.810 +                                        break;
  40.811 +                                        case 0x18: /*LIDT*/
  40.812 +                                        if (CPL && (msw & 1))
  40.813 +                                        {
  40.814 +                                                pclog("Invalid LIDT!\n");
  40.815 +                                                x86gpf(NULL,0);
  40.816 +                                                break;
  40.817 +                                        }
  40.818 +                                        tempw=geteaw();
  40.819 +                                        templ=readmeml(0,easeg+eaaddr+2)&0xFFFFFF;
  40.820 +                                        if (abrt) break;
  40.821 +                                        idt.limit=tempw;
  40.822 +                                        idt.base=templ;
  40.823 +                                        cycles-=12;
  40.824 +                                        break;
  40.825 +
  40.826 +                                        case 0x20: /*SMSW*/
  40.827 +                                        if (is486) seteaw(msw);
  40.828 +                                        else       seteaw(msw|0xFF00);
  40.829 +//                                        pclog("SMSW %04X:%04X  %04X %i\n",CS,pc,msw,is486);
  40.830 +                                        cycles -= (mod == 3) ? 2 : 3;
  40.831 +                                        break;
  40.832 +                                        case 0x30: /*LMSW*/
  40.833 +                                        if (CPL && (msw&1))
  40.834 +                                        {
  40.835 +                                                pclog("LMSW - ring not zero!\n");
  40.836 +                                                x86gpf(NULL,0);
  40.837 +                                                break;
  40.838 +                                        }
  40.839 +                                        tempw=geteaw(); if (abrt) break;
  40.840 +                                        if (msw&1) tempw|=1;
  40.841 +                                        msw=tempw;
  40.842 +                                        cycles -= (mod == 3) ? 3 : 6;
  40.843 +                                        pclog("LMSW %04X %08X %04X:%04X\n", msw, cs, CS, pc);
  40.844 +                                        break;
  40.845 +
  40.846 +                                        default:
  40.847 +                                        pclog("Bad 0F 01 opcode %02X\n",rmdat&0x38);
  40.848 +                                        pc-=3;
  40.849 +                                        x86illegal();
  40.850 +                                        break;
  40.851 +//                                        dumpregs();
  40.852 +//                                        exit(-1);
  40.853 +                                }
  40.854 +                                break;
  40.855 +
  40.856 +                                case 2: /*LAR*/
  40.857 +                                NOTRM
  40.858 +                                fetchea();
  40.859 +                                tempw=geteaw(); if (abrt) break;
  40.860 +//                                pclog("LAR seg %04X\n",tempw);
  40.861 +                                
  40.862 +                                if (!(tempw&0xFFFC)) { flags&=~Z_FLAG; break; } /*Null selector*/
  40.863 +                                tempi=(tempw&~7)<((tempw&4)?ldt.limit:gdt.limit);
  40.864 +                                if (tempi)
  40.865 +                                {
  40.866 +                                        cpl_override=1;
  40.867 +                                        tempw2=readmemw(0,((tempw&4)?ldt.base:gdt.base)+(tempw&~7)+4);
  40.868 +                                        cpl_override=0;
  40.869 +                                        if (abrt) break;
  40.870 +                                }
  40.871 +                                flags&=~Z_FLAG;
  40.872 +//                                pclog("tempw2 %04X  %i  %04X %04X\n",tempw2,tempi,ldt.limit,gdt.limit);
  40.873 +                                if ((tempw2&0x1F00)==0x000) tempi=0;
  40.874 +                                if ((tempw2&0x1F00)==0x800) tempi=0;
  40.875 +                                if ((tempw2&0x1F00)==0xA00) tempi=0;
  40.876 +                                if ((tempw2&0x1F00)==0xD00) tempi=0;
  40.877 +                                if ((tempw2&0x1C00)<0x1C00) /*Exclude conforming code segments*/
  40.878 +                                {
  40.879 +                                        tempw3=(tempw2>>13)&3;
  40.880 +                                        if (tempw3<CPL || tempw3<(tempw&3)) tempi=0;
  40.881 +                                }
  40.882 +                                if (tempi)
  40.883 +                                {
  40.884 +                                        flags|=Z_FLAG;
  40.885 +                                        cpl_override=1;
  40.886 +                                        regs[reg].w=readmemb(0,((tempw&4)?ldt.base:gdt.base)+(tempw&~7)+5)<<8;
  40.887 +                                        cpl_override=0;
  40.888 +                                }
  40.889 +                                cycles -= (mod == 3) ? 14 : 16;
  40.890 +                                break;
  40.891 +
  40.892 +                                case 3: /*LSL*/
  40.893 +                                NOTRM
  40.894 +                                fetchea();
  40.895 +                                tempw=geteaw(); if (abrt) break;
  40.896 +                                flags&=~Z_FLAG;
  40.897 +                                if (!(tempw&0xFFFC)) break; /*Null selector*/
  40.898 +                                tempi=(tempw&~7)<((tempw&4)?ldt.limit:gdt.limit);
  40.899 +                                cpl_override=1;
  40.900 +                                if (tempi)
  40.901 +                                {
  40.902 +                                        tempw2=readmemw(0,((tempw&4)?ldt.base:gdt.base)+(tempw&~7)+4);
  40.903 +                                }
  40.904 +                                cpl_override=0;
  40.905 +                                if (abrt) break;
  40.906 +                                if ((tempw2&0x1400)==0x400) tempi=0; /*Interrupt or trap or call gate*/
  40.907 +                                if ((tempw2&0x1F00)==0x000) tempi=0; /*Invalid*/
  40.908 +                                if ((tempw2&0x1F00)==0xA00) tempi=0; /*Invalid*/
  40.909 +                                if ((tempw2&0x1C00)!=0x1C00) /*Exclude conforming code segments*/
  40.910 +                                {
  40.911 +                                        tempw3=(tempw2>>13)&3;
  40.912 +                                        if (tempw3<CPL || tempw3<(tempw&3)) tempi=0;
  40.913 +                                }
  40.914 +                                if (tempi)
  40.915 +                                {
  40.916 +                                        flags|=Z_FLAG;
  40.917 +                                        cpl_override=1;
  40.918 +                                        regs[reg].w=readmemw(0,((tempw&4)?ldt.base:gdt.base)+(tempw&~7));
  40.919 +                                        cpl_override=0;
  40.920 +                                }
  40.921 +                                cycles -= (mod == 3) ? 14 : 16;
  40.922 +                                break;
  40.923 +
  40.924 +                                case 5: /*LOADALL*/
  40.925 +//                                pclog("At %04X:%04X  ",CS,pc);
  40.926 +                                flags=(readmemw(0,0x818)&0xFFD5)|2;
  40.927 +                                pc=readmemw(0,0x81A);
  40.928 +                                DS=readmemw(0,0x81E);
  40.929 +                                SS=readmemw(0,0x820);
  40.930 +                                CS=readmemw(0,0x822);
  40.931 +                                ES=readmemw(0,0x824);
  40.932 +                                DI=readmemw(0,0x826);
  40.933 +                                SI=readmemw(0,0x828);
  40.934 +                                BP=readmemw(0,0x82A);
  40.935 +                                SP=readmemw(0,0x82C);
  40.936 +                                BX=readmemw(0,0x82E);
  40.937 +                                DX=readmemw(0,0x830);
  40.938 +                                CX=readmemw(0,0x832);
  40.939 +                                AX=readmemw(0,0x834);
  40.940 +                                /*if (readmemw(0,0x806))
  40.941 +                                {
  40.942 +                                        pclog("Something in LOADALL!\n");
  40.943 +                                        dumpregs();
  40.944 +                                        exit(-1);
  40.945 +                                }*/
  40.946 +                                es=readmemw(0,0x836)|(readmemb(0,0x838)<<16);
  40.947 +                                cs=readmemw(0,0x83C)|(readmemb(0,0x83E)<<16);
  40.948 +                                ss=readmemw(0,0x842)|(readmemb(0,0x844)<<16);
  40.949 +                                ds=readmemw(0,0x848)|(readmemb(0,0x84A)<<16);
  40.950 +                                cycles-=195;
  40.951 +//                                pclog("LOADALL - %06X:%04X %06X:%04X %04X\n",ds,SI,es,DI,DX);
  40.952 +                                break;
  40.953 +                                
  40.954 +                                case 6: /*CLTS*/
  40.955 +                                if (CPL && (msw & 1))
  40.956 +                                {
  40.957 +                                        pclog("Can't CLTS\n");
  40.958 +                                        x86gpf(NULL,0);
  40.959 +                                        break;
  40.960 +                                }
  40.961 +                                msw &= ~8;
  40.962 +                                cycles-=2;
  40.963 +                                break;
  40.964 +                                
  40.965 +                                case 0xFF: /*Invalid - Windows 3.1 syscall trap?*/
  40.966 +                                inv16:
  40.967 +                                pc-=2;
  40.968 +                                if (msw&1)
  40.969 +                                {
  40.970 +                                        pmodeint(6,0);
  40.971 +                                }
  40.972 +                                else
  40.973 +                                {
  40.974 +                                        if (ssegs) ss=oldss;
  40.975 +                                        writememw(ss,((SP-2)&0xFFFF),flags);
  40.976 +                                        writememw(ss,((SP-4)&0xFFFF),CS);
  40.977 +                                        writememw(ss,((SP-6)&0xFFFF),pc);
  40.978 +                                        SP-=6;
  40.979 +                                        addr=6<<2;
  40.980 +                                        flags&=~I_FLAG;
  40.981 +                                        flags&=~T_FLAG;
  40.982 +                                        oxpc=pc;
  40.983 +                                        pc=readmemw(0,addr);
  40.984 +                                        loadcs(readmemw(0,addr+2));
  40.985 +/*                                        if (!pc && !cs)
  40.986 +                                        {
  40.987 +                                                pclog("Bad int %02X %04X:%04X\n",temp,oldcs,oldpc);
  40.988 +                                                dumpregs();
  40.989 +                                                exit(-1);
  40.990 +                                        }*/
  40.991 +                                }
  40.992 +                                cycles-=23;
  40.993 +                                break;
  40.994 +
  40.995 +                                default:
  40.996 +                                pclog("Bad 16-bit 0F opcode %02X 386 %i\n",temp,ins);
  40.997 +                                pc=oldpc;
  40.998 +//                                output=3;
  40.999 +//                                timetolive=100000;
 40.1000 +//                                dumpregs();
 40.1001 +//                                exit(-1);
 40.1002 +                                x86illegal();
 40.1003 +                                break;
 40.1004 +                        }
 40.1005 +                        break;
 40.1006 +
 40.1007 +                        case 0x10: /*ADC 8,reg*/
 40.1008 +                        fetchea();
 40.1009 +                        if (mod == 3)
 40.1010 +                        {
 40.1011 +                                temp  = getr8(rm);
 40.1012 +                                temp2 = getr8(reg);
 40.1013 +                                setadc8(temp, temp2);
 40.1014 +                                setr8(rm, temp + temp2 + tempc);
 40.1015 +                                cycles -= 2;
 40.1016 +                        }
 40.1017 +                        else
 40.1018 +                        {
 40.1019 +                                temp  = geteab();               if (abrt) break;
 40.1020 +                                temp2 = getr8(reg);
 40.1021 +                                seteab(temp + temp2 + tempc);   if (abrt) break;
 40.1022 +                                setadc8(temp, temp2);
 40.1023 +                                cycles -= 7;
 40.1024 +                        }
 40.1025 +                        break;
 40.1026 +                        case 0x11: /*ADC 16,reg*/
 40.1027 +                        fetchea();
 40.1028 +                        if (mod == 3)
 40.1029 +                        {
 40.1030 +                                setadc16(regs[rm].w, regs[reg].w);
 40.1031 +                                regs[rm].w += regs[reg].w + tempc;
 40.1032 +                                cycles -= 2;
 40.1033 +                        }
 40.1034 +                        else
 40.1035 +                        {
 40.1036 +                                tempw  = geteaw();              if (abrt) break;
 40.1037 +                                tempw2 = regs[reg].w;
 40.1038 +                                seteaw(tempw + tempw2 + tempc); if (abrt) break;
 40.1039 +                                setadc16(tempw, tempw2);
 40.1040 +                                cycles -= 7;
 40.1041 +                        }
 40.1042 +                        break;
 40.1043 +                        case 0x12: /*ADC reg,8*/
 40.1044 +                        fetchea();
 40.1045 +                        temp=geteab();                  if (abrt) break;
 40.1046 +                        setadc8(getr8(reg),temp);
 40.1047 +                        setr8(reg,getr8(reg)+temp+tempc);
 40.1048 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1049 +                        break;
 40.1050 +                        case 0x13: /*ADC reg,16*/
 40.1051 +                        fetchea();
 40.1052 +                        tempw=geteaw();                 if (abrt) break;
 40.1053 +                        setadc16(regs[reg].w,tempw);
 40.1054 +                        regs[reg].w+=tempw+tempc;
 40.1055 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1056 +                        break;
 40.1057 +                        case 0x14: /*ADC AL,#8*/
 40.1058 +                        tempw=getbytef();
 40.1059 +                        setadc8(AL,tempw);
 40.1060 +                        AL+=tempw+tempc;
 40.1061 +                        cycles -= 3;
 40.1062 +                        break;
 40.1063 +                        case 0x15: /*ADC AX,#16*/
 40.1064 +                        tempw=getwordf();
 40.1065 +                        setadc16(AX,tempw);
 40.1066 +                        AX+=tempw+tempc;
 40.1067 +                        cycles -= 3;
 40.1068 +                        break;
 40.1069 +
 40.1070 +                        case 0x16: /*PUSH SS*/
 40.1071 +                        if (ssegs) ss=oldss;
 40.1072 +                        writememw(ss,((SP-2)&0xFFFF),SS); if (abrt) break;
 40.1073 +                        SP-=2;
 40.1074 +                        cycles-=3;
 40.1075 +                        break;
 40.1076 +                        case 0x17: /*POP SS*/
 40.1077 +                        if (ssegs) ss=oldss;
 40.1078 +                        tempw=readmemw(ss,SP);  if (abrt) break;
 40.1079 +                        loadseg(tempw,&_ss); if (abrt) break;
 40.1080 +                        SP += 2;
 40.1081 +                        cycles -= (msw & 1) ? 20 : 5;
 40.1082 +                        break;
 40.1083 +
 40.1084 +                        case 0x18: /*SBB 8,reg*/
 40.1085 +                        fetchea();
 40.1086 +                        if (mod == 3)
 40.1087 +                        {
 40.1088 +                                temp  = getr8(rm);
 40.1089 +                                temp2 = getr8(reg);
 40.1090 +                                setsbc8(temp, temp2);
 40.1091 +                                setr8(rm, temp - (temp2 + tempc));
 40.1092 +                                cycles -= 2;
 40.1093 +                        }
 40.1094 +                        else
 40.1095 +                        {
 40.1096 +                                temp  = geteab();                  if (abrt) break;
 40.1097 +                                temp2 = getr8(reg);
 40.1098 +                                seteab(temp - (temp2 + tempc));    if (abrt) break;
 40.1099 +                                setsbc8(temp, temp2);
 40.1100 +                                cycles -= 7;
 40.1101 +                        }
 40.1102 +                        break;
 40.1103 +                        case 0x19: /*SBB 16,reg*/
 40.1104 +                        fetchea();
 40.1105 +                        if (mod == 3)
 40.1106 +                        {
 40.1107 +                                setsbc16(regs[rm].w, regs[reg].w);
 40.1108 +                                regs[rm].w -= (regs[reg].w + tempc);
 40.1109 +                                cycles -= 2;
 40.1110 +                        }
 40.1111 +                        else
 40.1112 +                        {
 40.1113 +                                tempw  = geteaw();                 if (abrt) break;
 40.1114 +                                tempw2 = regs[reg].w;
 40.1115 +                                seteaw(tempw - (tempw2 + tempc));  if (abrt) break;
 40.1116 +                                setsbc16(tempw, tempw2);
 40.1117 +                                cycles -= 7;
 40.1118 +                        }
 40.1119 +                        break;
 40.1120 +                        case 0x1A: /*SBB reg,8*/
 40.1121 +                        fetchea();
 40.1122 +                        temp=geteab();                  if (abrt) break;
 40.1123 +                        setsbc8(getr8(reg),temp);
 40.1124 +                        setr8(reg,getr8(reg)-(temp+tempc));
 40.1125 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1126 +                        break;
 40.1127 +                        case 0x1B: /*SBB reg,16*/
 40.1128 +                        fetchea();
 40.1129 +                        tempw=geteaw();                 if (abrt) break;
 40.1130 +                        tempw2=regs[reg].w;
 40.1131 +                        setsbc16(tempw2,tempw);
 40.1132 +                        tempw2-=(tempw+tempc);
 40.1133 +                        regs[reg].w=tempw2;
 40.1134 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1135 +                        break;
 40.1136 +                        case 0x1C: /*SBB AL,#8*/
 40.1137 +                        temp=getbytef();
 40.1138 +                        setsbc8(AL,temp);
 40.1139 +                        AL-=(temp+tempc);
 40.1140 +                        cycles -= 3;
 40.1141 +                        break;
 40.1142 +                        case 0x1D: /*SBB AX,#16*/
 40.1143 +                        tempw=getwordf();
 40.1144 +                        setsbc16(AX,tempw);
 40.1145 +                        AX-=(tempw+tempc);
 40.1146 +                        cycles -= 3;
 40.1147 +                        break;
 40.1148 +
 40.1149 +                        case 0x1E: /*PUSH DS*/
 40.1150 +                        if (ssegs) ss=oldss;
 40.1151 +                        writememw(ss,((SP-2)&0xFFFF),DS);       if (abrt) break;
 40.1152 +                        SP-=2;
 40.1153 +                        cycles-=3;
 40.1154 +                        break;
 40.1155 +                        case 0x1F: case 0x21F: /*POP DS*/
 40.1156 +                        if (ssegs) ss=oldss;
 40.1157 +                        tempw=readmemw(ss,SP);                  if (abrt) break;
 40.1158 +                        loadseg(tempw,&_ds); if (abrt) break;
 40.1159 +                        SP+=2;
 40.1160 +                        cycles -= (msw & 1) ? 20 : 5;
 40.1161 +                        break;
 40.1162 +
 40.1163 +                        case 0x20: /*AND 8,reg*/
 40.1164 +                        fetchea();
 40.1165 +                        if (mod == 3)
 40.1166 +                        {
 40.1167 +                                temp  = getr8(rm) & getr8(reg);
 40.1168 +                                setr8(rm, temp);
 40.1169 +                                setznp8(temp);
 40.1170 +                                cycles -= 2;
 40.1171 +                        }
 40.1172 +                        else
 40.1173 +                        {
 40.1174 +                                temp  = geteab();    if (abrt) break;
 40.1175 +                                temp &= getr8(reg);
 40.1176 +                                seteab(temp);        if (abrt) break;
 40.1177 +                                setznp8(temp);
 40.1178 +                                cycles -= 7;
 40.1179 +                        }
 40.1180 +                        break;
 40.1181 +                        case 0x21: /*AND 16,reg*/
 40.1182 +                        fetchea();
 40.1183 +                        if (mod == 3)
 40.1184 +                        {
 40.1185 +                                regs[rm].w &= regs[reg].w;
 40.1186 +                                setznp16(regs[rm].w);
 40.1187 +                                cycles -= 2;
 40.1188 +                        }
 40.1189 +                        else
 40.1190 +                        {
 40.1191 +                                tempw = geteaw() & regs[reg].w; if (abrt) break;
 40.1192 +                                seteaw(tempw);                  if (abrt) break;
 40.1193 +                                setznp16(tempw);
 40.1194 +                                cycles -= 7;
 40.1195 +                        }
 40.1196 +                        break;
 40.1197 +                        case 0x22: /*AND reg,8*/
 40.1198 +                        fetchea();
 40.1199 +                        temp=geteab();          if (abrt) break;
 40.1200 +                        temp&=getr8(reg);
 40.1201 +                        setznp8(temp);
 40.1202 +                        setr8(reg,temp);
 40.1203 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1204 +                        break;
 40.1205 +                        case 0x23: /*AND reg,16*/
 40.1206 +                        fetchea();
 40.1207 +                        tempw=geteaw();         if (abrt) break;
 40.1208 +                        tempw&=regs[reg].w;
 40.1209 +                        setznp16(tempw);
 40.1210 +                        regs[reg].w=tempw;
 40.1211 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1212 +                        break;
 40.1213 +                        case 0x24: /*AND AL,#8*/
 40.1214 +                        AL&=getbytef();
 40.1215 +                        setznp8(AL);
 40.1216 +                        cycles -= 3;
 40.1217 +                        break;
 40.1218 +                        case 0x25: /*AND AX,#16*/
 40.1219 +                        AX&=getwordf();
 40.1220 +                        setznp16(AX);
 40.1221 +                        cycles -= 3;
 40.1222 +                        break;
 40.1223 +
 40.1224 +                        case 0x26: /*ES:*/
 40.1225 +                        oldss=ss;
 40.1226 +                        oldds=ds;
 40.1227 +                        ds=ss=es;
 40.1228 +                        rds=ES;
 40.1229 +                        ssegs=2;
 40.1230 +                        cycles-=2;
 40.1231 +                        goto opcodestart;
 40.1232 +//                        break;
 40.1233 +
 40.1234 +                        case 0x27: /*DAA*/
 40.1235 +                        if ((flags & A_FLAG) || ((AL & 0xF) > 9))
 40.1236 +                        {
 40.1237 +                                tempi = ((uint16_t)AL) + 6;
 40.1238 +                                AL += 6;
 40.1239 +                                flags |= A_FLAG;
 40.1240 +                                if (tempi & 0x100) flags |= C_FLAG;
 40.1241 +                        }
 40.1242 +                        if ((flags&C_FLAG) || (AL>0x9F))
 40.1243 +                        {
 40.1244 +                                AL+=0x60;
 40.1245 +                                flags|=C_FLAG;
 40.1246 +                        }
 40.1247 +                        tempw = flags & (C_FLAG | A_FLAG);
 40.1248 +                        setznp8(AL);
 40.1249 +                        flags |= tempw;
 40.1250 +                        cycles -= 3;
 40.1251 +                        break;
 40.1252 +
 40.1253 +                        case 0x28: /*SUB 8,reg*/
 40.1254 +                        fetchea();
 40.1255 +                        if (mod == 3)
 40.1256 +                        {
 40.1257 +                                temp  = getr8(rm);
 40.1258 +                                temp2 = getr8(reg);
 40.1259 +                                setsub8(temp, temp2);
 40.1260 +                                setr8(rm, temp - temp2);
 40.1261 +                                cycles -= 2;
 40.1262 +                        }
 40.1263 +                        else
 40.1264 +                        {
 40.1265 +                                temp  = geteab();     if (abrt) break;
 40.1266 +                                temp2 = getr8(reg);
 40.1267 +                                seteab(temp - temp2); if (abrt) break;
 40.1268 +                                setsub8(temp, temp2);
 40.1269 +                                cycles -= 7;
 40.1270 +                        }
 40.1271 +                        break;
 40.1272 +                        case 0x29: /*SUB 16,reg*/
 40.1273 +                        fetchea();
 40.1274 +                        if (mod == 3)
 40.1275 +                        {
 40.1276 +                                setsub16(regs[rm].w, regs[reg].w);
 40.1277 +                                regs[rm].w -= regs[reg].w;
 40.1278 +                                cycles -= 2;
 40.1279 +                        }
 40.1280 +                        else
 40.1281 +                        {
 40.1282 +                                tempw = geteaw();             if (abrt) break;
 40.1283 +                                seteaw(tempw - regs[reg].w);  if (abrt) break;
 40.1284 +                                setsub16(tempw, regs[reg].w);
 40.1285 +                                cycles -= 7;
 40.1286 +                        }
 40.1287 +                        break;
 40.1288 +                        case 0x2A: /*SUB reg,8*/
 40.1289 +                        fetchea();
 40.1290 +                        temp=geteab();          if (abrt) break;
 40.1291 +                        setsub8(getr8(reg),temp);
 40.1292 +                        setr8(reg,getr8(reg)-temp);
 40.1293 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1294 +                        break;
 40.1295 +                        case 0x2B: /*SUB reg,16*/
 40.1296 +                        fetchea();
 40.1297 +                        tempw=geteaw();         if (abrt) break;
 40.1298 +                        setsub16(regs[reg].w,tempw);
 40.1299 +                        regs[reg].w-=tempw;
 40.1300 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1301 +                        break;
 40.1302 +                        case 0x2C: /*SUB AL,#8*/
 40.1303 +                        temp=getbytef();
 40.1304 +                        setsub8(AL,temp);
 40.1305 +                        AL-=temp;
 40.1306 +                        cycles -= 3;
 40.1307 +                        break;
 40.1308 +                        case 0x2D: /*SUB AX,#16*/
 40.1309 +                        tempw=getwordf();
 40.1310 +                        setsub16(AX,tempw);
 40.1311 +                        AX-=tempw;
 40.1312 +                        cycles -= 3;
 40.1313 +                        break;
 40.1314 +
 40.1315 +                        case 0x2E: /*CS:*/
 40.1316 +                        oldss=ss;
 40.1317 +                        oldds=ds;
 40.1318 +                        ds=ss=cs;
 40.1319 +                        rds=CS;
 40.1320 +                        ssegs=2;
 40.1321 +                        cycles-=2;
 40.1322 +                        goto opcodestart;
 40.1323 +                        
 40.1324 +                        case 0x2F: /*DAS*/
 40.1325 +                        if ((flags&A_FLAG)||((AL&0xF)>9))
 40.1326 +                        {
 40.1327 +                                tempi=((uint16_t)AL)-6;
 40.1328 +                                AL-=6;
 40.1329 +                                flags|=A_FLAG;
 40.1330 +                                if (tempi&0x100) flags|=C_FLAG;
 40.1331 +                        }
 40.1332 +//                        else
 40.1333 +//                           flags&=~A_FLAG;
 40.1334 +                        if ((flags&C_FLAG)||(AL>0x9F))
 40.1335 +                        {
 40.1336 +                                AL-=0x60;
 40.1337 +                                flags|=C_FLAG;
 40.1338 +                        }
 40.1339 +//                        else
 40.1340 +//                           flags&=~C_FLAG;
 40.1341 +                        tempw = flags & (C_FLAG | A_FLAG);
 40.1342 +                        setznp8(AL);
 40.1343 +                        flags |= tempw;
 40.1344 +                        cycles -= 3;
 40.1345 +                        break;
 40.1346 +
 40.1347 +                        case 0x30: /*XOR 8,reg*/
 40.1348 +                        fetchea();
 40.1349 +                        if (mod == 3)
 40.1350 +                        {
 40.1351 +                                temp = getr8(rm) ^ getr8(reg);
 40.1352 +                                setr8(rm, temp);
 40.1353 +                                setznp8(temp);
 40.1354 +                                cycles -= 2;
 40.1355 +                        }
 40.1356 +                        else
 40.1357 +                        {
 40.1358 +                                temp  = geteab();    if (abrt) break;
 40.1359 +                                temp ^= getr8(reg);
 40.1360 +                                seteab(temp);        if (abrt) break;
 40.1361 +                                setznp8(temp);
 40.1362 +                                cycles -= 7;
 40.1363 +                        }
 40.1364 +                        break;
 40.1365 +                        case 0x31: /*XOR 16,reg*/
 40.1366 +                        fetchea();
 40.1367 +                        if (mod == 3)
 40.1368 +                        {
 40.1369 +                                regs[rm].w ^= regs[reg].w;
 40.1370 +                                setznp16(regs[rm].w);
 40.1371 +                                cycles -= 2;
 40.1372 +                        }
 40.1373 +                        else
 40.1374 +                        {
 40.1375 +                                tempw = geteaw() ^ regs[reg].w; if (abrt) break;
 40.1376 +                                seteaw(tempw);                  if (abrt) break;
 40.1377 +                                setznp16(tempw);
 40.1378 +                                cycles -= 7;
 40.1379 +                        }
 40.1380 +                        break;
 40.1381 +                        case 0x32: /*XOR reg,8*/
 40.1382 +                        fetchea();
 40.1383 +                        temp=geteab();          if (abrt) break;
 40.1384 +                        temp^=getr8(reg);
 40.1385 +                        setznp8(temp);
 40.1386 +                        setr8(reg,temp);
 40.1387 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1388 +                        break;
 40.1389 +                        case 0x33: /*XOR reg,16*/
 40.1390 +                        fetchea();
 40.1391 +                        tempw=geteaw();         if (abrt) break;
 40.1392 +                        tempw^=regs[reg].w;
 40.1393 +                        setznp16(tempw);
 40.1394 +                        regs[reg].w=tempw;
 40.1395 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1396 +                        break;
 40.1397 +                        case 0x34: /*XOR AL,#8*/
 40.1398 +                        AL^=getbytef();
 40.1399 +                        setznp8(AL);
 40.1400 +                        cycles -= 3;
 40.1401 +                        break;
 40.1402 +                        case 0x35: /*XOR AX,#16*/
 40.1403 +                        AX^=getwordf();
 40.1404 +                        setznp16(AX);
 40.1405 +                        cycles -= 3;
 40.1406 +                        break;
 40.1407 +
 40.1408 +                        case 0x36: /*SS:*/
 40.1409 +                        oldss=ss;
 40.1410 +                        oldds=ds;
 40.1411 +                        ds=ss=ss;
 40.1412 +                        rds=SS;
 40.1413 +                        ssegs=2;
 40.1414 +                        cycles-=2;
 40.1415 +                        goto opcodestart;
 40.1416 +//                        break;
 40.1417 +
 40.1418 +                        case 0x37: /*AAA*/
 40.1419 +                        if ((flags&A_FLAG)||((AL&0xF)>9))
 40.1420 +                        {
 40.1421 +                                AL+=6;
 40.1422 +                                AH++;
 40.1423 +                                flags|=(A_FLAG|C_FLAG);
 40.1424 +                        }
 40.1425 +                        else
 40.1426 +                           flags&=~(A_FLAG|C_FLAG);
 40.1427 +                        AL&=0xF;
 40.1428 +                        cycles -= 3;
 40.1429 +                        break;
 40.1430 +
 40.1431 +                        case 0x38: /*CMP 8,reg*/
 40.1432 +                        fetchea();
 40.1433 +                        temp=geteab();          if (abrt) break;
 40.1434 +                        setsub8(temp,getr8(reg));
 40.1435 +                        cycles -= (mod == 3) ? 2 : 7;
 40.1436 +                        break;
 40.1437 +                        case 0x39: /*CMP 16,reg*/
 40.1438 +                        fetchea();
 40.1439 +                        tempw=geteaw();         if (abrt) break;
 40.1440 +//                        if (output) pclog("CMP %04X %04X\n",tempw,regs[reg].w);
 40.1441 +                        setsub16(tempw,regs[reg].w);
 40.1442 +                        cycles -= (mod == 3) ? 2 : 7;                        
 40.1443 +                        break;
 40.1444 +                        case 0x3A: /*CMP reg,8*/
 40.1445 +                        fetchea();
 40.1446 +                        temp=geteab();          if (abrt) break;
 40.1447 +//                        if (output) pclog("CMP %02X-%02X\n",getr8(reg),temp);
 40.1448 +                        setsub8(getr8(reg),temp);
 40.1449 +                        cycles -= (mod == 3) ? 2 : 6;
 40.1450 +                        break;
 40.1451 +                        case 0x3B: /*CMP reg,16*/
 40.1452 +                        fetchea();
 40.1453 +                        tempw=geteaw();         if (abrt) break;
 40.1454 +                        setsub16(regs[reg].w,tempw);
 40.1455 +                        cycles -= (mod == 3) ? 2 : 6;
 40.1456 +                        break;
 40.1457 +                        case 0x3C: /*CMP AL,#8*/
 40.1458 +                        temp=getbytef();
 40.1459 +                        setsub8(AL,temp);
 40.1460 +                        cycles -= 3;
 40.1461 +                        break;
 40.1462 +                        case 0x3D: /*CMP AX,#16*/
 40.1463 +                        tempw=getwordf();
 40.1464 +                        setsub16(AX,tempw);
 40.1465 +                        cycles -= 3;
 40.1466 +                        break;
 40.1467 +
 40.1468 +                        case 0x3E: /*DS:*/
 40.1469 +                        oldss=ss;
 40.1470 +                        oldds=ds;
 40.1471 +                        ds=ss=ds;
 40.1472 +                        ssegs=2;
 40.1473 +                        cycles-=2;
 40.1474 +                        goto opcodestart;
 40.1475 +//                        break;
 40.1476 +
 40.1477 +                        case 0x3F: /*AAS*/
 40.1478 +                        if ((flags&A_FLAG)||((AL&0xF)>9))
 40.1479 +                        {
 40.1480 +                                AL-=6;
 40.1481 +                                AH--;
 40.1482 +                                flags|=(A_FLAG|C_FLAG);
 40.1483 +                        }
 40.1484 +                        else
 40.1485 +                           flags&=~(A_FLAG|C_FLAG);
 40.1486 +                        AL&=0xF;
 40.1487 +                        cycles -= 3;
 40.1488 +                        break;
 40.1489 +
 40.1490 +                        case 0x40: case 0x41: case 0x42: case 0x43: /*INC r16*/
 40.1491 +                        case 0x44: case 0x45: case 0x46: case 0x47:
 40.1492 +                        setadd16nc(regs[opcode&7].w,1);
 40.1493 +                        regs[opcode&7].w++;
 40.1494 +                        cycles -= 2;
 40.1495 +                        break;
 40.1496 +                        case 0x48: case 0x49: case 0x4A: case 0x4B: /*DEC r16*/
 40.1497 +                        case 0x4C: case 0x4D: case 0x4E: case 0x4F:
 40.1498 +                        setsub16nc(regs[opcode&7].w,1);
 40.1499 +                        regs[opcode&7].w--;
 40.1500 +                        cycles -= 2;
 40.1501 +                        break;
 40.1502 +
 40.1503 +                        case 0x50: case 0x51: case 0x52: case 0x53: /*PUSH r16*/
 40.1504 +                        case 0x54: case 0x55: case 0x56: case 0x57:
 40.1505 +                        if (ssegs) ss=oldss;
 40.1506 +                        writememw(ss,(SP-2)&0xFFFF,regs[opcode&7].w);   if (abrt) break;
 40.1507 +                        SP-=2;
 40.1508 +                        cycles -= 3;
 40.1509 +                        break;
 40.1510 +                        case 0x58: case 0x59: case 0x5A: case 0x5B: /*POP r16*/
 40.1511 +                        case 0x5C: case 0x5D: case 0x5E: case 0x5F:
 40.1512 +                        if (ssegs) ss=oldss;
 40.1513 +                        SP+=2;
 40.1514 +                        tempw=readmemw(ss,(SP-2)&0xFFFF);    if (abrt) { SP-=2; break; }
 40.1515 +                        regs[opcode&7].w=tempw;
 40.1516 +                        cycles -= 5;
 40.1517 +                        break;
 40.1518 +
 40.1519 +                        case 0x60: /*PUSHA*/
 40.1520 +                        writememw(ss,((SP-2)&0xFFFF),AX);
 40.1521 +                        writememw(ss,((SP-4)&0xFFFF),CX);
 40.1522 +                        writememw(ss,((SP-6)&0xFFFF),DX);
 40.1523 +                        writememw(ss,((SP-8)&0xFFFF),BX);
 40.1524 +                        writememw(ss,((SP-10)&0xFFFF),SP);
 40.1525 +                        writememw(ss,((SP-12)&0xFFFF),BP);
 40.1526 +                        writememw(ss,((SP-14)&0xFFFF),SI);
 40.1527 +                        writememw(ss,((SP-16)&0xFFFF),DI);
 40.1528 +                        if (!abrt) SP-=16;
 40.1529 +                        cycles -= 17;
 40.1530 +                        break;
 40.1531 +                        case 0x61: /*POPA*/
 40.1532 +                        DI=readmemw(ss,((SP)&0xFFFF));          if (abrt) break;
 40.1533 +                        SI=readmemw(ss,((SP+2)&0xFFFF));        if (abrt) break;
 40.1534 +                        BP=readmemw(ss,((SP+4)&0xFFFF));        if (abrt) break;
 40.1535 +                        BX=readmemw(ss,((SP+8)&0xFFFF));        if (abrt) break;
 40.1536 +                        DX=readmemw(ss,((SP+10)&0xFFFF));       if (abrt) break;
 40.1537 +                        CX=readmemw(ss,((SP+12)&0xFFFF));       if (abrt) break;
 40.1538 +                        AX=readmemw(ss,((SP+14)&0xFFFF));       if (abrt) break;
 40.1539 +                        SP+=16;
 40.1540 +                        cycles -= 19;
 40.1541 +                        break;
 40.1542 +
 40.1543 +                        case 0x62: /*BOUND*/
 40.1544 +                        fetchea();
 40.1545 +                        tempw=geteaw();
 40.1546 +                        tempw2=readmemw(easeg,eaaddr+2); if (abrt) break;
 40.1547 +                        if (((int16_t)regs[reg].w<(int16_t)tempw) || ((int16_t)regs[reg].w>(int16_t)tempw2))
 40.1548 +                        {
 40.1549 +                                x86_int(5);
 40.1550 +                        }
 40.1551 +                        cycles -= 13;
 40.1552 +                        break;
 40.1553 +                        
 40.1554 +                        case 0x63: /*ARPL*/
 40.1555 +                        NOTRM
 40.1556 +                        fetchea();
 40.1557 +                        tempw=geteaw(); if (abrt) break;
 40.1558 +                        if ((tempw&3)<(regs[reg].w&3))
 40.1559 +                        {
 40.1560 +                                tempw=(tempw&0xFFFC)|(regs[reg].w&3);
 40.1561 +                                seteaw(tempw); if (abrt) break;
 40.1562 +                                flags|=Z_FLAG;
 40.1563 +                        }
 40.1564 +                        else
 40.1565 +                           flags&=~Z_FLAG;
 40.1566 +                        cycles -= (mod == 3) ? 10 : 11;
 40.1567 +                        break;
 40.1568 +
 40.1569 +                        case 0x68: /*PUSH #w*/
 40.1570 +                        tempw=getword();
 40.1571 +                        writememw(ss,((SP-2)&0xFFFF),tempw);    if (abrt) break;
 40.1572 +                        SP-=2;
 40.1573 +                        cycles -= 3;
 40.1574 +                        break;
 40.1575 +                        case 0x69: /*IMUL r16*/
 40.1576 +                        fetchea();
 40.1577 +                        tempw=geteaw();         if (abrt) break;
 40.1578 +                        tempw2=getword();       if (abrt) break;
 40.1579 +                        templ=((int)(int16_t)tempw)*((int)(int16_t)tempw2);
 40.1580 +                        if ((templ>>16)!=0 && (templ>>16)!=0xFFFF) flags|=C_FLAG|V_FLAG;
 40.1581 +                        else                                       flags&=~(C_FLAG|V_FLAG);
 40.1582 +                        regs[reg].w=templ&0xFFFF;
 40.1583 +                        cycles -= (mod == 3) ? 21 : 24;
 40.1584 +                        break;
 40.1585 +                        case 0x6A: /*PUSH #eb*/
 40.1586 +                        tempw=readmemb(cs,pc); pc++;
 40.1587 +                        if (tempw&0x80) tempw|=0xFF00;
 40.1588 +                        writememw(ss,((SP-2)&0xFFFF),tempw);    if (abrt) break;
 40.1589 +                        SP-=2;
 40.1590 +                        cycles -= 3;
 40.1591 +                        break;
 40.1592 +                        case 0x6B: /*IMUL r8*/
 40.1593 +                        fetchea();
 40.1594 +                        tempw=geteaw();                 if (abrt) break;
 40.1595 +                        tempw2=readmemb(cs,pc); pc++;   if (abrt) break;
 40.1596 +                        if (tempw2&0x80) tempw2|=0xFF00;
 40.1597 +                        templ=((int)(int16_t)tempw)*((int)(int16_t)tempw2);
 40.1598 +                        if ((templ>>16)!=0 && ((templ>>16)&0xFFFF)!=0xFFFF) flags|=C_FLAG|V_FLAG;
 40.1599 +                        else                                                flags&=~(C_FLAG|V_FLAG);
 40.1600 +                        regs[reg].w=templ&0xFFFF;
 40.1601 +                        cycles -= (mod == 3) ? 21 : 24;
 40.1602 +                        break;
 40.1603 +
 40.1604 +                        case 0x6C: /*INSB*/
 40.1605 +                        checkio_perm(DX);
 40.1606 +                        temp=inb(DX);
 40.1607 +                        writememb(es,DI,temp);          if (abrt) break;
 40.1608 +                        if (flags&D_FLAG) DI--;
 40.1609 +                        else              DI++;
 40.1610 +                        cycles -= 5;
 40.1611 +                        break;
 40.1612 +                        case 0x6D: /*INSW*/
 40.1613 +                        checkio_perm(DX);
 40.1614 +                        checkio_perm(DX+1);
 40.1615 +                        tempw=inw(DX);
 40.1616 +                        writememw(es,DI,tempw);         if (abrt) break;
 40.1617 +                        if (flags&D_FLAG) DI-=2;
 40.1618 +                        else              DI+=2;
 40.1619 +                        cycles -= 5;
 40.1620 +                        break;
 40.1621 +                        case 0x6E: /*OUTSB*/
 40.1622 +                        temp=readmemb(ds,SI);           if (abrt) break;
 40.1623 +                        checkio_perm(DX);
 40.1624 +                        if (flags&D_FLAG) SI--;
 40.1625 +                        else              SI++;
 40.1626 +                        outb(DX,temp);
 40.1627 +                        cycles -= 5;
 40.1628 +                        break;
 40.1629 +                        case 0x6F: /*OUTSW*/
 40.1630 +                        tempw=readmemw(ds,SI);          if (abrt) break;
 40.1631 +                        checkio_perm(DX);
 40.1632 +                        checkio_perm(DX+1);
 40.1633 +                        if (flags&D_FLAG) SI-=2;
 40.1634 +                        else              SI+=2;
 40.1635 +                        outw(DX,tempw);
 40.1636 +//                        outb(DX+1,tempw>>8);
 40.1637 +                        cycles -= 5;
 40.1638 +                        break;
 40.1639 +
 40.1640 +                        case 0x70: /*JO*/
 40.1641 +                        offset=(int8_t)getbytef();
 40.1642 +                        if (flags&V_FLAG) { pc += offset; cycles -= 4; cycles -= 2; }
 40.1643 +                        cycles -= 3;
 40.1644 +                        break;
 40.1645 +                        case 0x71: /*JNO*/
 40.1646 +                        offset=(int8_t)getbytef();
 40.1647 +                        if (!(flags&V_FLAG)) { pc += offset; cycles -= 4; cycles -= 2; }
 40.1648 +                        cycles -= 3;
 40.1649 +                        break;
 40.1650 +                        case 0x72: /*JB*/
 40.1651 +                        offset=(int8_t)getbytef();
 40.1652 +                        if (flags&C_FLAG) { pc += offset; cycles -= 4; cycles -= 2; }
 40.1653 +                        cycles -= 3;
 40.1654 +                        break;
 40.1655 +                        case 0x73: /*JNB*/
 40.1656 +                        offset=(int8_t)getbytef();
 40.1657 +                        if (!(flags&C_FLAG)) { pc += offset; cycles -= 4; cycles -= 2; }
 40.1658 +                        cycles -= 3;
 40.1659 +                        break;
 40.1660 +                        case 0x74: /*JZ*/
 40.1661 +                        offset=(int8_t)getbytef();
 40.1662 +                        if (flags&Z_FLAG) { pc += offset; cycles -= 4; cycles -= 2; }
 40.1663 +                        cycles -= 3;
 40.1664 +                        break;
 40.1665 +                        case 0x75: /*JNZ*/
 40.1666 +                        offset=(int8_t)getbytef();
 40.1667 +                        if (!(flags&Z_FLAG)) { pc += offset; cycles -= 4; cycles -= 2; }
 40.1668 +                        cycles -= 3;
 40.1669 +                        break;
 40.1670 +                        case 0x76: /*JBE*/
 40.1671 +                        offset=(int8_t)getbytef();
 40.1672 +                        if (flags&(C_FLAG|Z_FLAG)) { pc += offset; cycles -= 4; cycles -= 2; }
 40.1673 +                        cycles -= 3;
 40.1674 +                        break;
 40.1675 +                        case 0x77: /*JNBE*/
 40.1676 +                        offset=(int8_t)getbytef();
 40.1677 +                        if (!(flags&(C_FLAG|Z_FLAG))) { pc += offset; cycles -= 4; cycles -= 2; }
 40.1678 +                        cycles -= 3;
 40.1679 +                        break;
 40.1680 +                        case 0x78: /*JS*/
 40.1681 +                        offset=(int8_t)getbytef();
 40.1682 +                        if (flags&N_FLAG)  { pc += offset; cycles -= 4; cycles -= 2; }
 40.1683 +                        cycles -= 3;
 40.1684 +                        break;
 40.1685 +                        case 0x79: /*JNS*/
 40.1686 +                        offset=(int8_t)getbytef();
 40.1687 +                        if (!(flags&N_FLAG))  { pc += offset; cycles -= 4; cycles -= 2; }
 40.1688 +                        cycles -= 3;
 40.1689 +                        break;
 40.1690 +                        case 0x7A: /*JP*/
 40.1691 +                        offset=(int8_t)getbytef();
 40.1692 +                        if (flags&P_FLAG)  { pc += offset; cycles -= 4; cycles -= 2; }
 40.1693 +                        cycles -= 3;
 40.1694 +                        break;
 40.1695 +                        case 0x7B: /*JNP*/
 40.1696 +                        offset=(int8_t)getbytef();
 40.1697 +                        if (!(flags&P_FLAG))  { pc += offset; cycles -= 4; cycles -= 2; }
 40.1698 +                        cycles -= 3;
 40.1699 +                        break;
 40.1700 +                        case 0x7C: /*JL*/
 40.1701 +                        offset=(int8_t)getbytef();
 40.1702 +                        temp=(flags&N_FLAG)?1:0;
 40.1703 +                        temp2=(flags&V_FLAG)?1:0;
 40.1704 +                        if (temp!=temp2)  { pc += offset; cycles -= 4; cycles -= 2; }
 40.1705 +                        cycles -= 3;
 40.1706 +                        break;
 40.1707 +                        case 0x7D: /*JNL*/
 40.1708 +                        offset=(int8_t)getbytef();
 40.1709 +                        temp=(flags&N_FLAG)?1:0;
 40.1710 +                        temp2=(flags&V_FLAG)?1:0;
 40.1711 +                        if (temp==temp2)  { pc += offset; cycles -= 4; cycles -= 2; }
 40.1712 +                        cycles -= 3;
 40.1713 +                        break;
 40.1714 +                        case 0x7E: /*JLE*/
 40.1715 +                        offset=(int8_t)getbytef();
 40.1716 +                        temp=(flags&N_FLAG)?1:0;
 40.1717 +                        temp2=(flags&V_FLAG)?1:0;
 40.1718 +                        if ((flags&Z_FLAG) || (temp!=temp2))  { pc += offset; cycles -= 4; cycles -= 2; }
 40.1719 +                        cycles -= 3;
 40.1720 +                        break;
 40.1721 +                        case 0x7F: /*JNLE*/
 40.1722 +                        offset=(int8_t)getbytef();
 40.1723 +                        temp=(flags&N_FLAG)?1:0;
 40.1724 +                        temp2=(flags&V_FLAG)?1:0;
 40.1725 +                        if (!((flags&Z_FLAG) || (temp!=temp2)))  { pc += offset; cycles -= 4; cycles -= 2; }
 40.1726 +                        cycles -= 3;
 40.1727 +                        break;
 40.1728 +
 40.1729 +
 40.1730 +                        case 0x80: 
 40.1731 +                        case 0x82:
 40.1732 +                        fetchea();
 40.1733 +                        temp=geteab();                  if (abrt) break;
 40.1734 +                        temp2=readmemb(cs,pc); pc++;    if (abrt) break;
 40.1735 +                        switch (rmdat&0x38)
 40.1736 +                        {
 40.1737 +                                case 0x00: /*ADD b,#8*/
 40.1738 +                                seteab(temp+temp2);             if (abrt) break;
 40.1739 +                                setadd8(temp,temp2);
 40.1740 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1741 +                                break;
 40.1742 +                                case 0x08: /*OR b,#8*/
 40.1743 +                                temp|=temp2;
 40.1744 +                                seteab(temp);                   if (abrt) break;
 40.1745 +                                setznp8(temp);
 40.1746 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1747 +                                break;
 40.1748 +                                case 0x10: /*ADC b,#8*/
 40.1749 +                                seteab(temp+temp2+tempc);       if (abrt) break;
 40.1750 +                                setadc8(temp,temp2);
 40.1751 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1752 +                                break;
 40.1753 +                                case 0x18: /*SBB b,#8*/
 40.1754 +                                seteab(temp-(temp2+tempc));     if (abrt) break;
 40.1755 +                                setsbc8(temp,temp2);
 40.1756 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1757 +                                break;
 40.1758 +                                case 0x20: /*AND b,#8*/
 40.1759 +                                temp&=temp2;
 40.1760 +                                seteab(temp);                   if (abrt) break;
 40.1761 +                                setznp8(temp);
 40.1762 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1763 +                                break;
 40.1764 +                                case 0x28: /*SUB b,#8*/
 40.1765 +                                seteab(temp-temp2);             if (abrt) break;
 40.1766 +                                setsub8(temp,temp2);
 40.1767 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1768 +                                break;
 40.1769 +                                case 0x30: /*XOR b,#8*/
 40.1770 +                                temp^=temp2;
 40.1771 +                                seteab(temp);                   if (abrt) break;
 40.1772 +                                setznp8(temp);
 40.1773 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1774 +                                break;
 40.1775 +                                case 0x38: /*CMP b,#8*/
 40.1776 +                                setsub8(temp,temp2);
 40.1777 +                                cycles -= (mod == 3) ? 3 : 6;
 40.1778 +                                break;
 40.1779 +
 40.1780 +//                                default:
 40.1781 +//                                pclog("Bad 80 opcode %02X\n",rmdat&0x38);
 40.1782 +//                                dumpregs();
 40.1783 +//                                exit(-1);
 40.1784 +                        }
 40.1785 +                        break;
 40.1786 +
 40.1787 +                        case 0x81: 
 40.1788 +                        fetchea();
 40.1789 +                        tempw=geteaw();         if (abrt) break;
 40.1790 +                        tempw2=getword();       if (abrt) break;
 40.1791 +                        switch (rmdat&0x38)
 40.1792 +                        {
 40.1793 +                                case 0x00: /*ADD w,#16*/
 40.1794 +                                seteaw(tempw+tempw2);   if (abrt) break;
 40.1795 +                                setadd16(tempw,tempw2);
 40.1796 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1797 +                                break;
 40.1798 +                                case 0x08: /*OR w,#16*/
 40.1799 +                                tempw|=tempw2;
 40.1800 +                                seteaw(tempw);          if (abrt) break;
 40.1801 +                                setznp16(tempw);
 40.1802 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1803 +                                break;
 40.1804 +                                case 0x10: /*ADC w,#16*/
 40.1805 +                                seteaw(tempw+tempw2+tempc); if (abrt) break;
 40.1806 +                                setadc16(tempw,tempw2);
 40.1807 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1808 +                                break;
 40.1809 +                                case 0x20: /*AND w,#16*/
 40.1810 +                                tempw&=tempw2;
 40.1811 +                                seteaw(tempw);          if (abrt) break;
 40.1812 +                                setznp16(tempw);
 40.1813 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1814 +                                break;
 40.1815 +                                case 0x18: /*SBB w,#16*/
 40.1816 +                                seteaw(tempw-(tempw2+tempc));   if (abrt) break;
 40.1817 +                                setsbc16(tempw,tempw2);
 40.1818 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1819 +                                break;
 40.1820 +                                case 0x28: /*SUB w,#16*/
 40.1821 +                                seteaw(tempw-tempw2);           if (abrt) break;
 40.1822 +                                setsub16(tempw,tempw2);
 40.1823 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1824 +                                break;
 40.1825 +                                case 0x30: /*XOR w,#16*/
 40.1826 +                                tempw^=tempw2;
 40.1827 +                                seteaw(tempw);                  if (abrt) break;
 40.1828 +                                setznp16(tempw);
 40.1829 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1830 +                                break;
 40.1831 +                                case 0x38: /*CMP w,#16*/
 40.1832 +//                                pclog("CMP %04X %04X\n", tempw, tempw2);
 40.1833 +                                setsub16(tempw,tempw2);
 40.1834 +                                cycles -= (mod == 3) ? 3 : 6;
 40.1835 +                                break;
 40.1836 +                        }
 40.1837 +                        break;
 40.1838 +
 40.1839 +                        case 0x83:
 40.1840 +                        fetchea();
 40.1841 +                        tempw=geteaw();                 if (abrt) break;
 40.1842 +                        tempw2=readmemb(cs,pc); pc++;   if (abrt) break;
 40.1843 +                        if (tempw2&0x80) tempw2|=0xFF00;
 40.1844 +                        switch (rmdat&0x38)
 40.1845 +                        {
 40.1846 +                                case 0x00: /*ADD w,#8*/
 40.1847 +                                seteaw(tempw+tempw2);           if (abrt) break;
 40.1848 +                                setadd16(tempw,tempw2);
 40.1849 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1850 +                                break;
 40.1851 +                                case 0x08: /*OR w,#8*/
 40.1852 +                                tempw|=tempw2;
 40.1853 +                                seteaw(tempw);                  if (abrt) break;
 40.1854 +                                setznp16(tempw);
 40.1855 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1856 +                                break;
 40.1857 +                                case 0x10: /*ADC w,#8*/
 40.1858 +                                seteaw(tempw+tempw2+tempc);     if (abrt) break;
 40.1859 +                                setadc16(tempw,tempw2);
 40.1860 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1861 +                                break;
 40.1862 +                                case 0x18: /*SBB w,#8*/
 40.1863 +                                seteaw(tempw-(tempw2+tempc));   if (abrt) break;
 40.1864 +                                setsbc16(tempw,tempw2);
 40.1865 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1866 +                                break;
 40.1867 +                                case 0x20: /*AND w,#8*/
 40.1868 +                                tempw&=tempw2;
 40.1869 +                                seteaw(tempw);                  if (abrt) break;
 40.1870 +                                setznp16(tempw);
 40.1871 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1872 +                                break;
 40.1873 +                                case 0x28: /*SUB w,#8*/
 40.1874 +                                seteaw(tempw-tempw2);           if (abrt) break;
 40.1875 +                                setsub16(tempw,tempw2);
 40.1876 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1877 +                                break;
 40.1878 +                                case 0x30: /*XOR w,#8*/
 40.1879 +                                tempw^=tempw2;
 40.1880 +                                seteaw(tempw);                  if (abrt) break;
 40.1881 +                                setznp16(tempw);
 40.1882 +                                cycles -= (mod == 3) ? 3 : 7;
 40.1883 +                                break;
 40.1884 +                                case 0x38: /*CMP w,#8*/
 40.1885 +                                setsub16(tempw,tempw2);
 40.1886 +                                cycles -= (mod == 3) ? 3 : 6;
 40.1887 +                                break;
 40.1888 +
 40.1889 +//                                default:
 40.1890 +//                                pclog("Bad 83 opcode %02X\n",rmdat&0x38);
 40.1891 +//                                dumpregs();
 40.1892 +//                                exit(-1);
 40.1893 +                        }
 40.1894 +                        break;
 40.1895 +
 40.1896 +                        case 0x84: /*TEST b,reg*/
 40.1897 +                        fetchea();
 40.1898 +                        temp=geteab();          if (abrt) break;
 40.1899 +                        temp2=getr8(reg);
 40.1900 +                        setznp8(temp&temp2);
 40.1901 +                        cycles -= (mod == 3) ? 2 : 6;
 40.1902 +                        break;
 40.1903 +                        case 0x85: /*TEST w,reg*/
 40.1904 +                        fetchea();
 40.1905 +                        tempw=geteaw();         if (abrt) break;
 40.1906 +                        tempw2=regs[reg].w;
 40.1907 +                        setznp16(tempw&tempw2);
 40.1908 +                        cycles -= (mod == 3) ? 2 : 6;
 40.1909 +                        break;
 40.1910 +                        case 0x86: /*XCHG b,reg*/
 40.1911 +                        fetchea();
 40.1912 +                        temp=geteab();          if (abrt) break;
 40.1913 +                        seteab(getr8(reg));     if (abrt) break;
 40.1914 +                        setr8(reg,temp);
 40.1915 +                        cycles -= (mod == 3) ? 3 : 5;
 40.1916 +                        break;
 40.1917 +                        case 0x87: /*XCHG w,reg*/
 40.1918 +                        fetchea();
 40.1919 +                        tempw=geteaw();         if (abrt) break;
 40.1920 +                        seteaw(regs[reg].w);    if (abrt) break;
 40.1921 +                        regs[reg].w=tempw;
 40.1922 +                        cycles -= (mod == 3) ? 3 : 5;
 40.1923 +                        break;
 40.1924 +
 40.1925 +                        case 0x88: /*MOV b,reg*/
 40.1926 +                        fetchea();
 40.1927 +                        seteab(getr8(reg));
 40.1928 +                        cycles -= (mod == 3) ? 2 : 3;
 40.1929 +                        break;
 40.1930 +                        case 0x89: /*MOV w,reg*/
 40.1931 +                        fetchea();
 40.1932 +                        seteaw(regs[reg].w);
 40.1933 +                        cycles -= (mod == 3) ? 2 : 3;
 40.1934 +                        break;
 40.1935 +                        case 0x8A: /*MOV reg,b*/
 40.1936 +                        fetchea();
 40.1937 +                        temp=geteab();          if (abrt) break;
 40.1938 +                        setr8(reg,temp);
 40.1939 +                        cycles -= (mod == 3) ? 5 : 3;
 40.1940 +                        break;
 40.1941 +                        case 0x8B: /*MOV reg,w*/
 40.1942 +                        fetchea();
 40.1943 +                        tempw=geteaw();         if (abrt) break;
 40.1944 +                        regs[reg].w=tempw;
 40.1945 +                        cycles -= (mod == 3) ? 5 : 3;
 40.1946 +                        break;
 40.1947 +
 40.1948 +                        case 0x8C: /*MOV w,sreg*/
 40.1949 +                        fetchea();
 40.1950 +                        switch (rmdat&0x38)
 40.1951 +                        {
 40.1952 +                                case 0x00: /*ES*/
 40.1953 +                                seteaw(ES);
 40.1954 +                                break;
 40.1955 +                                case 0x08: /*CS*/
 40.1956 +                                seteaw(CS);
 40.1957 +                                break;
 40.1958 +                                case 0x18: /*DS*/
 40.1959 +                                if (ssegs) ds=oldds;
 40.1960 +                                seteaw(DS);
 40.1961 +                                break;
 40.1962 +                                case 0x10: /*SS*/
 40.1963 +                                if (ssegs) ss=oldss;
 40.1964 +                                seteaw(SS);
 40.1965 +                                break;
 40.1966 +                        }
 40.1967 +                        cycles -= (mod == 3) ? 2 : 3;
 40.1968 +                        break;
 40.1969 +
 40.1970 +                        case 0x8D: /*LEA*/
 40.1971 +                        fetchea();
 40.1972 +                        regs[reg].w=eaaddr;
 40.1973 +                        cycles -= 3;
 40.1974 +                        break;
 40.1975 +
 40.1976 +                        case 0x8E: /*MOV sreg,w*/
 40.1977 +                        fetchea();
 40.1978 +                        switch (rmdat&0x38)
 40.1979 +                        {
 40.1980 +                                case 0x00: /*ES*/
 40.1981 +                                tempw=geteaw();         if (abrt) break;
 40.1982 +                                loadseg(tempw,&_es);
 40.1983 +                                break;
 40.1984 +                                case 0x18: /*DS*/
 40.1985 +                                tempw=geteaw();         if (abrt) break;
 40.1986 +                                loadseg(tempw,&_ds);
 40.1987 +                                if (ssegs) oldds=ds;
 40.1988 +                                break;
 40.1989 +                                case 0x10: /*SS*/
 40.1990 +//                                if (output==3) pclog("geteaw\n");
 40.1991 +                                tempw=geteaw();         if (abrt) break;
 40.1992 +//                                if (output==3) pclog("loadseg\n");
 40.1993 +                                loadseg(tempw,&_ss);
 40.1994 +//                                if (output==3) pclog("done\n");
 40.1995 +                                if (ssegs) oldss=ss;
 40.1996 +                                skipnextprint=1;
 40.1997 +				noint=1;
 40.1998 +                                break;
 40.1999 +                        }
 40.2000 +                        if (msw & 1) cycles -= (mod == 3) ? 17 : 19;
 40.2001 +                        else         cycles -= (mod == 3) ?  2 :  5;
 40.2002 +                        break;
 40.2003 +
 40.2004 +                        case 0x8F: /*POPW*/
 40.2005 +                        if (ssegs) templ2=oldss;
 40.2006 +                        else       templ2=ss;
 40.2007 +                        tempw=readmemw(templ2,SP);      if (abrt) break;
 40.2008 +                        SP+=2;
 40.2009 +                        fetchea();
 40.2010 +                        if (ssegs) ss=oldss;
 40.2011 +                        seteaw(tempw);
 40.2012 +                        if (abrt) SP-=2;
 40.2013 +                        cycles -= 5;
 40.2014 +                        break;
 40.2015 +
 40.2016 +                        case 0x90: /*NOP*/
 40.2017 +                        cycles -= 3;
 40.2018 +                        break;
 40.2019 +
 40.2020 +                        case 0x91: case 0x92: case 0x93: /*XCHG AX*/
 40.2021 +                        case 0x94: case 0x95: case 0x96: case 0x97:
 40.2022 +                        tempw=AX;
 40.2023 +                        AX=regs[opcode&7].w;
 40.2024 +                        regs[opcode&7].w=tempw;
 40.2025 +                        cycles -= 3;
 40.2026 +                        break;
 40.2027 +
 40.2028 +                        case 0x98: /*CBW*/
 40.2029 +                        AH=(AL&0x80)?0xFF:0;
 40.2030 +                        cycles -= 2;
 40.2031 +                        break;
 40.2032 +                        case 0x99: /*CWD*/
 40.2033 +                        DX=(AX&0x8000)?0xFFFF:0;
 40.2034 +                        cycles -= 2;
 40.2035 +                        break;
 40.2036 +                        case 0x9A: /*CALL FAR*/
 40.2037 +                        tempw=getword();
 40.2038 +                        tempw2=getword();       if (abrt) break;
 40.2039 +                        tempw3 = CS;
 40.2040 +                        templ2 = pc;
 40.2041 +                        if (ssegs) ss=oldss;
 40.2042 +                        oxpc=pc;
 40.2043 +                        pc=tempw;
 40.2044 +                        optype=CALL;
 40.2045 +                        if (msw&1) loadcscall(tempw2);
 40.2046 +                        else       loadcs(tempw2);
 40.2047 +                        optype=0;
 40.2048 +                        if (abrt) break;
 40.2049 +                        oldss=ss;
 40.2050 +                        writememw(ss,(SP-2)&0xFFFF,tempw3);
 40.2051 +                        writememw(ss,(SP-4)&0xFFFF,templ2);     if (abrt) break;
 40.2052 +                        SP-=4;
 40.2053 +                        cycles -= (msw & 1) ? 26 : 13;
 40.2054 +                        break;
 40.2055 +                        case 0x9B: /*WAIT*/
 40.2056 +                        cycles -= 3;
 40.2057 +                        break;
 40.2058 +                        case 0x9C: /*PUSHF*/
 40.2059 +                        if (ssegs) ss=oldss;
 40.2060 +                        if (msw & 1) { writememw(ss, ((SP-2)&0xFFFF), flags & 0x7fff); }
 40.2061 +                        else         { writememw(ss, ((SP-2)&0xFFFF), flags & 0x0fff); }   
 40.2062 +                        if (abrt) break;
 40.2063 +                        SP-=2;
 40.2064 +                        cycles -= 3;
 40.2065 +                        break;
 40.2066 +                        case 0x9D: /*POPF*/
 40.2067 +                        if (ssegs) ss=oldss;
 40.2068 +                        tempw=readmemw(ss,SP);                  if (abrt) break;
 40.2069 +                        SP+=2;
 40.2070 +                        if (!(CPL) || !(msw&1)) flags=(tempw&0xFFD5)|2;
 40.2071 +                        else if (IOPLp) flags=(flags&0x3000)|(tempw&0x4FD5)|2;
 40.2072 +                        else            flags=(flags&0x7200)|(tempw&0x0DD5)|2;
 40.2073 +                        pclog("POPF %04X %04X  %04X:%04X\n", tempw, flags, CS, pc);
 40.2074 +                        cycles -= 5;
 40.2075 +                        break;
 40.2076 +                        case 0x9E: /*SAHF*/
 40.2077 +                        flags=(flags&0xFF00)|(AH&0xD5)|2;
 40.2078 +                        cycles -= 2;
 40.2079 +                        break;
 40.2080 +                        case 0x9F: /*LAHF*/
 40.2081 +                        AH=flags&0xFF;
 40.2082 +                        cycles -= 2;
 40.2083 +                        break;
 40.2084 +
 40.2085 +                        case 0xA0: /*MOV AL,(w)*/
 40.2086 +                        addr=getword(); if (abrt) break;
 40.2087 +                        temp=readmemb(ds,addr);         if (abrt) break;
 40.2088 +                        AL=temp;
 40.2089 +                        cycles -= 5;
 40.2090 +                        break;
 40.2091 +                        case 0xA1: /*MOV AX,(w)*/
 40.2092 +                        addr=getword(); if (abrt) break;
 40.2093 +                        tempw=readmemw(ds,addr);        if (abrt) break;
 40.2094 +                        AX=tempw;
 40.2095 +                        cycles -= 5;
 40.2096 +                        break;
 40.2097 +                        case 0xA2: /*MOV (w),AL*/
 40.2098 +                        addr=getword(); if (abrt) break;
 40.2099 +                        writememb(ds,addr,AL);
 40.2100 +                        cycles -= 3;
 40.2101 +                        break;
 40.2102 +                        case 0xA3: /*MOV (w),AX*/
 40.2103 +                        addr=getword(); if (abrt) break;
 40.2104 +                        writememw(ds,addr,AX);
 40.2105 +                        cycles -= 3;
 40.2106 +                        break;
 40.2107 +
 40.2108 +                        case 0xA4: /*MOVSB*/
 40.2109 +                        temp=readmemb(ds,SI);  if (abrt) break;
 40.2110 +                        writememb(es,DI,temp); if (abrt) break;
 40.2111 +                        if (flags&D_FLAG) { DI--; SI--; }
 40.2112 +                        else              { DI++; SI++; }
 40.2113 +                        cycles -= 5;
 40.2114 +                        break;
 40.2115 +                        case 0xA5: /*MOVSW*/
 40.2116 +                        tempw=readmemw(ds,SI);  if (abrt) break;
 40.2117 +                        writememw(es,DI,tempw); if (abrt) break;
 40.2118 +                        if (flags&D_FLAG) { DI-=2; SI-=2; }
 40.2119 +                        else              { DI+=2; SI+=2; }
 40.2120 +                        cycles -= 5;
 40.2121 +                        break;
 40.2122 +                        case 0xA6: /*CMPSB*/
 40.2123 +                        temp =readmemb(ds,SI);
 40.2124 +                        temp2=readmemb(es,DI);
 40.2125 +                        if (abrt) break;
 40.2126 +                        setsub8(temp,temp2);
 40.2127 +                        if (flags&D_FLAG) { DI--; SI--; }
 40.2128 +                        else              { DI++; SI++; }
 40.2129 +                        cycles -= 8;
 40.2130 +                        break;
 40.2131 +                        case 0xA7: /*CMPSW*/
 40.2132 +                        tempw =readmemw(ds,SI);
 40.2133 +                        tempw2=readmemw(es,DI);
 40.2134 +                        if (abrt) break;
 40.2135 +                        setsub16(tempw,tempw2);
 40.2136 +                        if (flags&D_FLAG) { DI-=2; SI-=2; }
 40.2137 +                        else              { DI+=2; SI+=2; }
 40.2138 +                        cycles -= 8;
 40.2139 +                        break;
 40.2140 +                        case 0xA8: /*TEST AL,#8*/
 40.2141 +                        temp=getbytef();
 40.2142 +                        setznp8(AL&temp);
 40.2143 +                        cycles -= 3;
 40.2144 +                        break;
 40.2145 +                        case 0xA9: /*TEST AX,#16*/
 40.2146 +                        tempw=getwordf();
 40.2147 +                        setznp16(AX&tempw);
 40.2148 +                        cycles -= 3;
 40.2149 +                        break;
 40.2150 +                        case 0xAA: /*STOSB*/
 40.2151 +                        writememb(es,DI,AL);    if (abrt) break;
 40.2152 +                        if (flags&D_FLAG) DI--;
 40.2153 +                        else              DI++;
 40.2154 +                        cycles -= 3;
 40.2155 +                        break;
 40.2156 +                        case 0xAB: /*STOSW*/
 40.2157 +                        writememw(es,DI,AX);    if (abrt) break;
 40.2158 +                        if (flags&D_FLAG) DI-=2;
 40.2159 +                        else              DI+=2;
 40.2160 +                        cycles -= 3;
 40.2161 +                        break;
 40.2162 +                        case 0xAC: /*LODSB*/
 40.2163 +                        temp=readmemb(ds,SI);
 40.2164 +                        if (abrt) break;
 40.2165 +                        AL=temp;
 40.2166 +                        if (flags&D_FLAG) SI--;
 40.2167 +                        else              SI++;
 40.2168 +                        cycles -= 5;
 40.2169 +                        break;
 40.2170 +                        case 0xAD: /*LODSW*/
 40.2171 +                        tempw=readmemw(ds,SI);
 40.2172 +                        if (abrt) break;
 40.2173 +                        AX=tempw;
 40.2174 +//                        if (output) pclog("Load from %05X:%04X\n",ds,SI);
 40.2175 +                        if (flags&D_FLAG) SI-=2;
 40.2176 +                        else              SI+=2;
 40.2177 +                        cycles -= 5;
 40.2178 +                        break;
 40.2179 +                        case 0xAE: /*SCASB*/
 40.2180 +                        temp=readmemb(es,DI);
 40.2181 +                        if (abrt) break;
 40.2182 +                        setsub8(AL,temp);
 40.2183 +                        if (flags&D_FLAG) DI--;
 40.2184 +                        else              DI++;
 40.2185 +                        cycles -= 7;
 40.2186 +                        break;
 40.2187 +                        case 0xAF: /*SCASW*/
 40.2188 +                        tempw=readmemw(es,DI);
 40.2189 +                        if (abrt) break;
 40.2190 +                        setsub16(AX,tempw);
 40.2191 +                        if (flags&D_FLAG) DI-=2;
 40.2192 +                        else              DI+=2;
 40.2193 +                        cycles -= 7;
 40.2194 +                        break;
 40.2195 +
 40.2196 +                        case 0xB0: /*MOV AL,#8*/
 40.2197 +                        AL=getbytef();
 40.2198 +                        cycles -= 2;
 40.2199 +                        break;
 40.2200 +                        case 0xB1: /*MOV CL,#8*/
 40.2201 +                        CL=getbytef();
 40.2202 +                        cycles -= 2;
 40.2203 +                        break;
 40.2204 +                        case 0xB2: /*MOV DL,#8*/
 40.2205 +                        DL=getbytef();
 40.2206 +                        cycles -= 2;
 40.2207 +                        break;
 40.2208 +                        case 0xB3: /*MOV BL,#8*/
 40.2209 +                        BL=getbytef();
 40.2210 +                        cycles -= 2;
 40.2211 +                        break;
 40.2212 +                        case 0xB4: /*MOV AH,#8*/
 40.2213 +                        AH=getbytef();
 40.2214 +                        cycles -= 2;
 40.2215 +                        break;
 40.2216 +                        case 0xB5: /*MOV CH,#8*/
 40.2217 +                        CH=getbytef();
 40.2218 +                        cycles -= 2;
 40.2219 +                        break;
 40.2220 +                        case 0xB6: /*MOV DH,#8*/
 40.2221 +                        DH=getbytef();
 40.2222 +                        cycles -= 2;
 40.2223 +                        break;
 40.2224 +                        case 0xB7: /*MOV BH,#8*/
 40.2225 +                        BH=getbytef();
 40.2226 +                        cycles -= 2;
 40.2227 +                        break;
 40.2228 +                        case 0xB8: case 0xB9: case 0xBA: case 0xBB: /*MOV reg,#16*/
 40.2229 +                        case 0xBC: case 0xBD: case 0xBE: case 0xBF:
 40.2230 +                        regs[opcode&7].w=getwordf();
 40.2231 +                        cycles -= 2;
 40.2232 +                        break;
 40.2233 +
 40.2234 +                        case 0xC0:
 40.2235 +                        fetchea();
 40.2236 +                        c=readmemb(cs,pc); pc++;
 40.2237 +                        temp=geteab();          if (abrt) break;
 40.2238 +                        c&=31;
 40.2239 +                        if (!c) break;
 40.2240 +                        cycles -= c;                        
 40.2241 +                        switch (rmdat&0x38)
 40.2242 +                        {
 40.2243 +                                case 0x00: /*ROL b,CL*/
 40.2244 +                                while (c>0)
 40.2245 +                                {
 40.2246 +                                        temp2=(temp&0x80)?1:0;
 40.2247 +                                        temp=(temp<<1)|temp2;
 40.2248 +                                        c--;
 40.2249 +                                }
 40.2250 +                                seteab(temp);   if (abrt) break;
 40.2251 +                                flags&=~(C_FLAG|V_FLAG);
 40.2252 +                                if (temp2) flags|=C_FLAG;
 40.2253 +                                if ((flags&C_FLAG)^(temp>>7)) flags|=V_FLAG;
 40.2254 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2255 +                                break;
 40.2256 +                                case 0x08: /*ROR b,CL*/
 40.2257 +                                while (c>0)
 40.2258 +                                {
 40.2259 +                                        temp2=temp&1;
 40.2260 +                                        temp>>=1;
 40.2261 +                                        if (temp2) temp|=0x80;
 40.2262 +                                        c--;
 40.2263 +                                }
 40.2264 +                                seteab(temp);   if (abrt) break;
 40.2265 +                                flags&=~(C_FLAG|V_FLAG);
 40.2266 +                                if (temp2) flags|=C_FLAG;
 40.2267 +                                if ((temp^(temp>>1))&0x40) flags|=V_FLAG;
 40.2268 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2269 +                                break;
 40.2270 +                                case 0x10: /*RCL b,CL*/
 40.2271 +                                temp2=flags&C_FLAG;
 40.2272 +                                while (c>0)
 40.2273 +                                {
 40.2274 +                                        tempc=(temp2)?1:0;
 40.2275 +                                        temp2=temp&0x80;
 40.2276 +                                        temp=(temp<<1)|tempc;
 40.2277 +                                        c--;
 40.2278 +                                        if (is486) cycles--;
 40.2279 +                                }
 40.2280 +                                seteab(temp);   if (abrt) break;
 40.2281 +                                flags&=~(C_FLAG|V_FLAG);
 40.2282 +                                if (temp2) flags|=C_FLAG;
 40.2283 +                                if ((flags&C_FLAG)^(temp>>7)) flags|=V_FLAG;
 40.2284 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2285 +                                break;
 40.2286 +                                case 0x18: /*RCR b,CL*/
 40.2287 +                                temp2=flags&C_FLAG;
 40.2288 +                                while (c>0)
 40.2289 +                                {
 40.2290 +                                        tempc=(temp2)?0x80:0;
 40.2291 +                                        temp2=temp&1;
 40.2292 +                                        temp=(temp>>1)|tempc;
 40.2293 +                                        c--;
 40.2294 +                                        if (is486) cycles--;
 40.2295 +                                }
 40.2296 +                                seteab(temp);   if (abrt) break;
 40.2297 +                                flags&=~(C_FLAG|V_FLAG);
 40.2298 +                                if (temp2) flags|=C_FLAG;
 40.2299 +                                if ((temp^(temp>>1))&0x40) flags|=V_FLAG;
 40.2300 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2301 +                                break;
 40.2302 +                                case 0x20: case 0x30: /*SHL b,CL*/
 40.2303 +                                seteab(temp<<c);        if (abrt) break;
 40.2304 +                                setznp8(temp<<c);
 40.2305 +                                if ((temp<<(c-1))&0x80) flags|=C_FLAG;
 40.2306 +                                if (((temp<<c)^(temp<<(c-1)))&0x80) flags|=V_FLAG;
 40.2307 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2308 +                                break;
 40.2309 +                                case 0x28: /*SHR b,CL*/
 40.2310 +                                seteab(temp>>c);        if (abrt) break;
 40.2311 +                                setznp8(temp>>c);
 40.2312 +                                if ((temp>>(c-1))&1) flags|=C_FLAG;
 40.2313 +                                if (c==1 && temp&0x80) flags|=V_FLAG;
 40.2314 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2315 +                                break;
 40.2316 +                                case 0x38: /*SAR b,CL*/
 40.2317 +                                tempc=((temp>>(c-1))&1);
 40.2318 +                                while (c>0)
 40.2319 +                                {
 40.2320 +                                        temp>>=1;
 40.2321 +                                        if (temp&0x40) temp|=0x80;
 40.2322 +                                        c--;
 40.2323 +                                }
 40.2324 +                                seteab(temp);   if (abrt) break;
 40.2325 +                                setznp8(temp);
 40.2326 +                                if (tempc) flags|=C_FLAG;
 40.2327 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2328 +                                break;
 40.2329 +
 40.2330 +//                                default:
 40.2331 +//                                pclog("Bad C0 opcode %02X\n",rmdat&0x38);
 40.2332 +//                                dumpregs();
 40.2333 +//                                exit(-1);
 40.2334 +                        }
 40.2335 +                        break;
 40.2336 +
 40.2337 +                        case 0xC1:
 40.2338 +                        fetchea();
 40.2339 +                        c=readmemb(cs,pc)&31; pc++;
 40.2340 +                        tempw=geteaw();         if (abrt) break;
 40.2341 +                        if (!c) break;
 40.2342 +                        cycles -= c;
 40.2343 +                        switch (rmdat&0x38)
 40.2344 +                        {
 40.2345 +                                case 0x00: /*ROL w,CL*/
 40.2346 +                                while (c>0)
 40.2347 +                                {
 40.2348 +                                        temp=(tempw&0x8000)?1:0;
 40.2349 +                                        tempw=(tempw<<1)|temp;
 40.2350 +                                        c--;
 40.2351 +                                }
 40.2352 +                                seteaw(tempw);  if (abrt) break;
 40.2353 +                                flags&=~(C_FLAG|V_FLAG);
 40.2354 +                                if (temp) flags|=C_FLAG;
 40.2355 +                                if ((flags&C_FLAG)^(tempw>>15)) flags|=V_FLAG;
 40.2356 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2357 +                                break;
 40.2358 +                                case 0x08: /*ROR w,CL*/
 40.2359 +                                while (c>0)
 40.2360 +                                {
 40.2361 +                                        tempw2=(tempw&1)?0x8000:0;
 40.2362 +                                        tempw=(tempw>>1)|tempw2;
 40.2363 +                                        c--;
 40.2364 +                                }
 40.2365 +                                seteaw(tempw);  if (abrt) break;
 40.2366 +                                flags&=~(C_FLAG|V_FLAG);
 40.2367 +                                if (tempw2) flags|=C_FLAG;
 40.2368 +                                if ((tempw^(tempw>>1))&0x4000) flags|=V_FLAG;
 40.2369 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2370 +                                break;
 40.2371 +                                case 0x10: /*RCL w,CL*/
 40.2372 +                                temp2=flags&C_FLAG;
 40.2373 +                                while (c>0)
 40.2374 +                                {
 40.2375 +                                        tempc=(temp2)?1:0;
 40.2376 +                                        temp2=(tempw>>15);
 40.2377 +                                        tempw=(tempw<<1)|tempc;
 40.2378 +                                        c--;
 40.2379 +                                        if (is486) cycles--;
 40.2380 +                                }
 40.2381 +                                seteaw(tempw);  if (abrt) break;
 40.2382 +                                flags&=~(C_FLAG|V_FLAG);
 40.2383 +                                if (temp2) flags|=C_FLAG;
 40.2384 +                                if ((flags&C_FLAG)^(tempw>>15)) flags|=V_FLAG;
 40.2385 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2386 +                                break;
 40.2387 +                                case 0x18: /*RCR w,CL*/
 40.2388 +                                temp2=flags&C_FLAG;
 40.2389 +                                while (c>0)
 40.2390 +                                {
 40.2391 +                                        tempc=(temp2)?0x8000:0;
 40.2392 +                                        temp2=tempw&1;
 40.2393 +                                        tempw=(tempw>>1)|tempc;
 40.2394 +                                        c--;
 40.2395 +                                        if (is486) cycles--;
 40.2396 +                                }
 40.2397 +                                seteaw(tempw);  if (abrt) break;
 40.2398 +                                flags&=~(C_FLAG|V_FLAG);
 40.2399 +                                if (temp2) flags|=C_FLAG;
 40.2400 +                                if ((tempw^(tempw>>1))&0x4000) flags|=V_FLAG;
 40.2401 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2402 +                                break;
 40.2403 +
 40.2404 +                                case 0x20: case 0x30: /*SHL w,CL*/
 40.2405 +                                seteaw(tempw<<c); if (abrt) break;
 40.2406 +                                setznp16(tempw<<c);
 40.2407 +                                if ((tempw<<(c-1))&0x8000) flags|=C_FLAG;
 40.2408 +                                if (((tempw<<c)^(tempw<<(c-1)))&0x8000) flags|=V_FLAG;
 40.2409 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2410 +                                break;
 40.2411 +
 40.2412 +                                case 0x28:            /*SHR w,CL*/
 40.2413 +                                seteaw(tempw>>c); if (abrt) break;
 40.2414 +                                setznp16(tempw>>c);
 40.2415 +                                if ((tempw>>(c-1))&1) flags|=C_FLAG;
 40.2416 +                                if (c==1 && tempw&0x8000) flags|=V_FLAG;
 40.2417 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2418 +                                break;
 40.2419 +
 40.2420 +                                case 0x38:            /*SAR w,CL*/
 40.2421 +                                tempw2=tempw&0x8000;
 40.2422 +                                tempc=(tempw>>(c-1))&1;
 40.2423 +                                while (c>0)
 40.2424 +                                {
 40.2425 +                                        tempw=(tempw>>1)|tempw2;
 40.2426 +                                        c--;
 40.2427 +                                }
 40.2428 +                                seteaw(tempw);  if (abrt) break;
 40.2429 +                                setznp16(tempw);
 40.2430 +                                if (tempc) flags|=C_FLAG;
 40.2431 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2432 +                                break;
 40.2433 +
 40.2434 +//                                default:
 40.2435 +//                                pclog("Bad C1 opcode %02X\n",rmdat&0x38);
 40.2436 +//                                dumpregs();
 40.2437 +//                                exit(-1);
 40.2438 +                        }
 40.2439 +                        break;
 40.2440 +
 40.2441 +                        case 0xC2: /*RET*/
 40.2442 +                        tempw=getword();
 40.2443 +                        if (ssegs) ss=oldss;
 40.2444 +                        tempw2=readmemw(ss,SP); if (abrt) break;
 40.2445 +                        SP+=2+tempw;
 40.2446 +                        pc=tempw2;
 40.2447 +                        cycles -= 11;
 40.2448 +                        break;
 40.2449 +                        case 0xC3: /*RET*/
 40.2450 +                        if (ssegs) ss=oldss;
 40.2451 +                        tempw=readmemw(ss,SP);  if (abrt) break;
 40.2452 +                        SP+=2;
 40.2453 +                        pc=tempw;
 40.2454 +                        cycles -= 11;
 40.2455 +                        break;
 40.2456 +                        case 0xC4: /*LES*/
 40.2457 +                        fetchea();
 40.2458 +                        tempw2=readmemw(easeg,eaaddr);
 40.2459 +                        tempw=readmemw(easeg,eaaddr+2); if (abrt) break;
 40.2460 +                        loadseg(tempw,&_es);            if (abrt) break;
 40.2461 +                        regs[reg].w=tempw2;
 40.2462 +                        cycles -= 7;
 40.2463 +                        break;
 40.2464 +                        case 0xC5: /*LDS*/
 40.2465 +                        fetchea();
 40.2466 +                        tempw2=readmemw(easeg,eaaddr);
 40.2467 +                        tempw=readmemw(easeg,eaaddr+2); if (abrt) break;
 40.2468 +                        loadseg(tempw,&_ds);            if (abrt) break;
 40.2469 +                        if (ssegs) oldds=ds;
 40.2470 +                        regs[reg].w=tempw2;
 40.2471 +                        cycles -= 7;
 40.2472 +                        break;
 40.2473 +                        case 0xC6: /*MOV b,#8*/
 40.2474 +                        fetchea();
 40.2475 +                        temp=readmemb(cs,pc); pc++;     if (abrt) break;
 40.2476 +                        seteab(temp);
 40.2477 +                        cycles -= (mod == 3) ? 2 : 3;
 40.2478 +                        break;
 40.2479 +                        case 0xC7: /*MOV w,#16*/
 40.2480 +                        fetchea();
 40.2481 +                        tempw=getword();                if (abrt) break;
 40.2482 +                        seteaw(tempw);
 40.2483 +                        cycles -= (mod == 3) ? 2 : 3;
 40.2484 +                        break;
 40.2485 +                        case 0xC8: /*ENTER*/
 40.2486 +                        tempw2=getword();
 40.2487 +                        tempi=readmemb(cs,pc); pc++;
 40.2488 +                        templ=BP;
 40.2489 +                        writememw(ss,((SP-2)&0xFFFF),BP); if (abrt) break; 
 40.2490 +                        SP-=2;
 40.2491 +                        templ2=SP;
 40.2492 +                        if (tempi>0)
 40.2493 +                        {
 40.2494 +                                while (--tempi)
 40.2495 +                                {
 40.2496 +                                        BP-=2;
 40.2497 +                                        tempw=readmemw(ss,BP);
 40.2498 +                                        if (abrt) { SP=templ2; BP=templ; break; }
 40.2499 +                                        writememw(ss,((SP-2)&0xFFFF),tempw); SP-=2;
 40.2500 +                                        if (abrt) { SP=templ2; BP=templ; break; }
 40.2501 +                                        cycles-=(is486)?3:4;
 40.2502 +                                }
 40.2503 +                                writememw(ss,((SP-2)&0xFFFF),templ2); SP-=2;
 40.2504 +                                if (abrt) { SP=templ2; BP=templ; break; }
 40.2505 +                                cycles -= 4;
 40.2506 +                        }
 40.2507 +                        BP = templ2;
 40.2508 +                        SP-=tempw2;
 40.2509 +                        cycles -= 12;
 40.2510 +                        break;
 40.2511 +                        case 0xC9: /*LEAVE*/
 40.2512 +                        templ=SP;
 40.2513 +                        SP=BP;
 40.2514 +                        tempw=readmemw(ss,SP);   SP+=2;
 40.2515 +                        if (abrt) { SP=templ; break; }
 40.2516 +                        BP=tempw;
 40.2517 +                        cycles -= 5;
 40.2518 +                        break;
 40.2519 +                        case 0xCA: /*RETF*/
 40.2520 +                        tempw=getword();
 40.2521 +                        if (msw&1)
 40.2522 +                        {
 40.2523 +                                pmoderetf(0,tempw);
 40.2524 +                                break;
 40.2525 +                        }
 40.2526 +                        tempw2=CPL;
 40.2527 +                        if (ssegs) ss=oldss;
 40.2528 +                        oxpc=pc;
 40.2529 +                        pc=readmemw(ss,SP);
 40.2530 +                        loadcs(readmemw(ss,SP+2));
 40.2531 +                        if (abrt) break;
 40.2532 +                        SP+=4+tempw;
 40.2533 +                        cycles -= 15;
 40.2534 +                        break;
 40.2535 +                        case 0xCB: /*RETF*/
 40.2536 +                        if (msw&1)
 40.2537 +                        {
 40.2538 +                                pmoderetf(0,0);
 40.2539 +                                break;
 40.2540 +                        }
 40.2541 +                        tempw2=CPL;
 40.2542 +                        if (ssegs) ss=oldss;
 40.2543 +                        oxpc=pc;
 40.2544 +                        pc=readmemw(ss,SP);
 40.2545 +                        loadcs(readmemw(ss,SP+2));
 40.2546 +                        if (abrt) break;
 40.2547 +                        SP+=4;
 40.2548 +                        cycles -= 15;
 40.2549 +                        break;
 40.2550 +                        case 0xCC: /*INT 3*/
 40.2551 +                        if (msw&1)
 40.2552 +                        {
 40.2553 +                                pmodeint(3,1);
 40.2554 +                                cycles -= 40;
 40.2555 +                        }
 40.2556 +                        else
 40.2557 +                        {
 40.2558 +                                if (ssegs) ss=oldss;
 40.2559 +                                writememw(ss,((SP-2)&0xFFFF),flags);
 40.2560 +                                writememw(ss,((SP-4)&0xFFFF),CS);
 40.2561 +                                writememw(ss,((SP-6)&0xFFFF),pc);
 40.2562 +                                SP-=6;
 40.2563 +                                addr=3<<2;
 40.2564 +//                                flags&=~I_FLAG;
 40.2565 +                                flags&=~T_FLAG;
 40.2566 +                                oxpc=pc;
 40.2567 +                                pc=readmemw(0,addr);
 40.2568 +                                loadcs(readmemw(0,addr+2));
 40.2569 +                                cycles -= 23;
 40.2570 +                        }
 40.2571 +                        break;
 40.2572 +                        case 0xCD: /*INT*/
 40.2573 +                        lastpc=pc;
 40.2574 +                        lastcs=CS;
 40.2575 +                        temp=readmemb(cs,pc); pc++;
 40.2576 +                        intrt:
 40.2577 +                                pclog("INT %02X  %04X %04X %04X %04X  %04X:%04X\n", temp, AX, BX, CX, DX, CS, pc);
 40.2578 +                        if (1)
 40.2579 +                        {
 40.2580 +                                if (msw&1)
 40.2581 +                                {
 40.2582 +//                                        pclog("PMODE int %02X %04X at %04X:%04X  ",temp,AX,CS,pc);
 40.2583 +                                        pmodeint(temp,1);
 40.2584 +                                        cycles -= 40;
 40.2585 +//                                        pclog("to %04X:%04X\n",CS,pc);
 40.2586 +                                }
 40.2587 +                                else
 40.2588 +                                {
 40.2589 +                                        if (ssegs) ss=oldss;
 40.2590 +                                        writememw(ss,((SP-2)&0xFFFF),flags);
 40.2591 +                                        writememw(ss,((SP-4)&0xFFFF),CS);
 40.2592 +                                        writememw(ss,((SP-6)&0xFFFF),pc);
 40.2593 +                                        SP-=6;
 40.2594 +                                        addr=temp<<2;
 40.2595 +//                                        flags&=~I_FLAG;
 40.2596 +                                        flags&=~T_FLAG;
 40.2597 +                                        oxpc=pc;
 40.2598 +//                                        pclog("%04X:%04X : ",CS,pc);
 40.2599 +                                        pc=readmemw(0,addr);
 40.2600 +                                        loadcs(readmemw(0,addr+2));
 40.2601 +                                        cycles -= 23;
 40.2602 +//                                        pclog("INT %02X - %04X %04X:%04X\n",temp,addr,CS,pc);
 40.2603 +                                }
 40.2604 +                        }
 40.2605 +                        break;
 40.2606 +                        case 0xCE: /*INTO*/
 40.2607 +                        if (flags&V_FLAG)
 40.2608 +                        {
 40.2609 +                                temp=4;
 40.2610 +                                goto intrt;
 40.2611 +/*                                pclog("INTO interrupt!\n");
 40.2612 +                                dumpregs();
 40.2613 +                                exit(-1);*/
 40.2614 +                        }
 40.2615 +                        cycles-=3;
 40.2616 +                        break;
 40.2617 +                        case 0xCF: /*IRET*/
 40.2618 +                        if (ssegs) ss=oldss;
 40.2619 +                        if (msw&1)
 40.2620 +                        {
 40.2621 +                                optype=IRET;
 40.2622 +                                pmodeiret(0);
 40.2623 +                                optype=0;
 40.2624 +                        }
 40.2625 +                        else
 40.2626 +                        {
 40.2627 +                                tempw=CS;
 40.2628 +                                tempw2=pc;
 40.2629 +                                inint=0;
 40.2630 +                                oxpc=pc;
 40.2631 +                                pc=readmemw(ss,SP);
 40.2632 +                                loadcs(readmemw(ss,((SP+2)&0xFFFF)));
 40.2633 +                                flags=(readmemw(ss,((SP+4)&0xFFFF))&0x0FD5)|2;
 40.2634 +                                SP+=6;
 40.2635 +                        }
 40.2636 +                        cycles -= 17;
 40.2637 +                        break;
 40.2638 +                        
 40.2639 +                        case 0xD0:
 40.2640 +                        fetchea();
 40.2641 +                        temp=geteab(); if (abrt) break;
 40.2642 +                        switch (rmdat&0x38)
 40.2643 +                        {
 40.2644 +                                case 0x00: /*ROL b,1*/
 40.2645 +                                seteab((temp<<1)|((temp&0x80)?1:0)); if (abrt) break;
 40.2646 +                                if (temp&0x80) flags|=C_FLAG;
 40.2647 +                                else           flags&=~C_FLAG;
 40.2648 +                                temp<<=1;
 40.2649 +                                if (flags&C_FLAG) temp|=1;
 40.2650 +                                if ((flags&C_FLAG)^(temp>>7)) flags|=V_FLAG;
 40.2651 +                                else                          flags&=~V_FLAG;
 40.2652 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2653 +                                break;
 40.2654 +                                case 0x08: /*ROR b,1*/
 40.2655 +                                seteab((temp>>1)|((temp&1)?0x80:0)); if (abrt) break;
 40.2656 +                                if (temp&1) flags|=C_FLAG;
 40.2657 +                                else        flags&=~C_FLAG;
 40.2658 +                                temp>>=1;
 40.2659 +                                if (flags&C_FLAG) temp|=0x80;
 40.2660 +                                if ((temp^(temp>>1))&0x40) flags|=V_FLAG;
 40.2661 +                                else                       flags&=~V_FLAG;
 40.2662 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2663 +                                break;
 40.2664 +                                case 0x10: /*RCL b,1*/
 40.2665 +                                temp2=flags&C_FLAG;
 40.2666 +                                seteab((temp<<1)|temp2); if (abrt) break;
 40.2667 +                                if (temp&0x80) flags|=C_FLAG;
 40.2668 +                                else           flags&=~C_FLAG;
 40.2669 +                                temp<<=1;
 40.2670 +                                if (temp2) temp|=1;
 40.2671 +                                if ((flags&C_FLAG)^(temp>>7)) flags|=V_FLAG;
 40.2672 +                                else                          flags&=~V_FLAG;
 40.2673 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2674 +                                break;
 40.2675 +                                case 0x18: /*RCR b,1*/
 40.2676 +                                temp2=flags&C_FLAG;
 40.2677 +                                seteab((temp>>1)|(temp2?0x80:0)); if (abrt) break;
 40.2678 +                                if (temp&1) flags|=C_FLAG;
 40.2679 +                                else        flags&=~C_FLAG;
 40.2680 +                                temp>>=1;
 40.2681 +                                if (temp2) temp|=0x80;
 40.2682 +                                if ((temp^(temp>>1))&0x40) flags|=V_FLAG;
 40.2683 +                                else                       flags&=~V_FLAG;
 40.2684 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2685 +                                break;
 40.2686 +                                case 0x20: case 0x30: /*SHL b,1*/
 40.2687 +                                seteab(temp<<1); if (abrt) break;
 40.2688 +                                setznp8(temp<<1);
 40.2689 +                                if (temp&0x80) flags|=C_FLAG;
 40.2690 +                                if ((temp^(temp<<1))&0x80) flags|=V_FLAG;
 40.2691 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2692 +                                break;
 40.2693 +                                case 0x28: /*SHR b,1*/
 40.2694 +                                seteab(temp>>1); if (abrt) break;
 40.2695 +                                setznp8(temp>>1);
 40.2696 +                                if (temp&1) flags|=C_FLAG;
 40.2697 +                                if (temp&0x80) flags|=V_FLAG;
 40.2698 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2699 +                                break;
 40.2700 +                                case 0x38: /*SAR b,1*/
 40.2701 +                                seteab((temp>>1)|(temp&0x80)); if (abrt) break;
 40.2702 +                                setznp8((temp>>1)|(temp&0x80));
 40.2703 +                                if (temp&1) flags|=C_FLAG;
 40.2704 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2705 +                                break;
 40.2706 +
 40.2707 +//                                default:
 40.2708 +//                                pclog("Bad D0 opcode %02X\n",rmdat&0x38);
 40.2709 +//                                dumpregs();
 40.2710 +//                                exit(-1);
 40.2711 +                        }
 40.2712 +                        break;
 40.2713 +                        case 0xD1:
 40.2714 +                        fetchea();
 40.2715 +                        tempw=geteaw(); if (abrt) break;
 40.2716 +                        switch (rmdat&0x38)
 40.2717 +                        {
 40.2718 +                                case 0x00: /*ROL w,1*/
 40.2719 +                                seteaw((tempw<<1)|(tempw>>15)); if (abrt) break;
 40.2720 +                                if (tempw&0x8000) flags|=C_FLAG;
 40.2721 +                                else              flags&=~C_FLAG;
 40.2722 +                                tempw<<=1;
 40.2723 +                                if (flags&C_FLAG) tempw|=1;
 40.2724 +                                if ((flags&C_FLAG)^(tempw>>15)) flags|=V_FLAG;
 40.2725 +                                else                            flags&=~V_FLAG;
 40.2726 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2727 +                                break;
 40.2728 +                                case 0x08: /*ROR w,1*/
 40.2729 +                                seteaw((tempw>>1)|(tempw<<15)); if (abrt) break;
 40.2730 +                                if (tempw&1) flags|=C_FLAG;
 40.2731 +                                else         flags&=~C_FLAG;
 40.2732 +                                tempw>>=1;
 40.2733 +                                if (flags&C_FLAG) tempw|=0x8000;
 40.2734 +                                if ((tempw^(tempw>>1))&0x4000) flags|=V_FLAG;
 40.2735 +                                else                           flags&=~V_FLAG;
 40.2736 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2737 +                                break;
 40.2738 +                                case 0x10: /*RCL w,1*/
 40.2739 +                                temp2=flags&C_FLAG;
 40.2740 +                                seteaw((tempw<<1)|temp2);       if (abrt) break;
 40.2741 +                                if (tempw&0x8000) flags|=C_FLAG;
 40.2742 +                                else              flags&=~C_FLAG;
 40.2743 +                                tempw<<=1;
 40.2744 +                                if (temp2) tempw|=1;
 40.2745 +                                if ((flags&C_FLAG)^(tempw>>15)) flags|=V_FLAG;
 40.2746 +                                else                            flags&=~V_FLAG;
 40.2747 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2748 +                                break;
 40.2749 +                                case 0x18: /*RCR w,1*/
 40.2750 +                                temp2=flags&C_FLAG;
 40.2751 +                                seteaw((tempw>>1)|(temp2?0x8000:0));      if (abrt) break;
 40.2752 +                                if (tempw&1) flags|=C_FLAG;
 40.2753 +                                else         flags&=~C_FLAG;
 40.2754 +                                tempw>>=1;
 40.2755 +                                if (temp2) tempw|=0x8000;
 40.2756 +                                if ((tempw^(tempw>>1))&0x4000) flags|=V_FLAG;
 40.2757 +                                else                           flags&=~V_FLAG;
 40.2758 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2759 +                                break;
 40.2760 +                                case 0x20: case 0x30: /*SHL w,1*/
 40.2761 +                                seteaw(tempw<<1);       if (abrt) break;
 40.2762 +                                setznp16(tempw<<1);
 40.2763 +                                if (tempw&0x8000) flags|=C_FLAG;
 40.2764 +                                if ((tempw^(tempw<<1))&0x8000) flags|=V_FLAG;
 40.2765 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2766 +                                break;
 40.2767 +                                case 0x28: /*SHR w,1*/
 40.2768 +                                seteaw(tempw>>1);       if (abrt) break;
 40.2769 +                                setznp16(tempw>>1);
 40.2770 +                                if (tempw&1) flags|=C_FLAG;
 40.2771 +                                if (tempw&0x8000) flags|=V_FLAG;
 40.2772 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2773 +                                break;
 40.2774 +                                case 0x38: /*SAR w,1*/
 40.2775 +                                seteaw((tempw>>1)|(tempw&0x8000)); if (abrt) break;
 40.2776 +                                setznp16((tempw>>1)|(tempw&0x8000));
 40.2777 +                                if (tempw&1) flags|=C_FLAG;
 40.2778 +                                cycles -= (mod == 3) ? 2 : 7;
 40.2779 +                                break;
 40.2780 +
 40.2781 +                                default:
 40.2782 +                                pclog("Bad D1 opcode %02X\n",rmdat&0x38);
 40.2783 +                        }
 40.2784 +                        break;
 40.2785 +
 40.2786 +                        case 0xD2:
 40.2787 +                        fetchea();
 40.2788 +                        temp=geteab();  if (abrt) break;
 40.2789 +                        c=CL&31;
 40.2790 +//                        cycles-=c;
 40.2791 +                        if (!c) break;
 40.2792 +//                        if (c>7) pclog("Shiftb %i %02X\n",rmdat&0x38,c);
 40.2793 +                        cycles -= c;
 40.2794 +                        switch (rmdat&0x38)
 40.2795 +                        {
 40.2796 +                                case 0x00: /*ROL b,CL*/
 40.2797 +                                while (c>0)
 40.2798 +                                {
 40.2799 +                                        temp2=(temp&0x80)?1:0;
 40.2800 +                                        temp=(temp<<1)|temp2;
 40.2801 +                                        c--;
 40.2802 +                                }
 40.2803 +                                seteab(temp); if (abrt) break;
 40.2804 +                                flags&=~(C_FLAG|V_FLAG);
 40.2805 +                                if (temp2) flags|=C_FLAG;
 40.2806 +                                if ((flags&C_FLAG)^(temp>>7)) flags|=V_FLAG;
 40.2807 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2808 +                                break;
 40.2809 +                                case 0x08: /*ROR b,CL*/
 40.2810 +                                while (c>0)
 40.2811 +                                {
 40.2812 +                                        temp2=temp&1;
 40.2813 +                                        temp>>=1;
 40.2814 +                                        if (temp2) temp|=0x80;
 40.2815 +                                        c--;
 40.2816 +                                }
 40.2817 +                                seteab(temp); if (abrt) break;
 40.2818 +                                flags&=~(C_FLAG|V_FLAG);
 40.2819 +                                if (temp2) flags|=C_FLAG;
 40.2820 +                                if ((temp^(temp>>1))&0x40) flags|=V_FLAG;
 40.2821 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2822 +                                break;
 40.2823 +                                case 0x10: /*RCL b,CL*/
 40.2824 +                                tempc=flags&C_FLAG;
 40.2825 +                                while (c>0)
 40.2826 +                                {
 40.2827 +                                        templ=tempc;
 40.2828 +                                        tempc=temp&0x80;
 40.2829 +                                        temp<<=1;
 40.2830 +                                        if (templ) temp|=1;
 40.2831 +                                        c--;
 40.2832 +                                }
 40.2833 +                                seteab(temp); if (abrt) break;
 40.2834 +                                flags&=~(C_FLAG|V_FLAG);
 40.2835 +                                if (tempc) flags|=C_FLAG;
 40.2836 +                                if ((flags&C_FLAG)^(temp>>7)) flags|=V_FLAG;
 40.2837 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2838 +                                break;
 40.2839 +                                case 0x18: /*RCR b,CL*/
 40.2840 +                                tempc=flags&C_FLAG;
 40.2841 +                                while (c>0)
 40.2842 +                                {
 40.2843 +                                        templ=tempc;
 40.2844 +                                        tempc=temp&1;
 40.2845 +                                        temp>>=1;
 40.2846 +                                        if (templ) temp|=0x80;
 40.2847 +                                        c--;
 40.2848 +                                }
 40.2849 +                                seteab(temp); if (abrt) break;
 40.2850 +                                flags&=~(C_FLAG|V_FLAG);
 40.2851 +                                if (tempc) flags|=C_FLAG;
 40.2852 +                                if ((temp^(temp>>1))&0x40) flags|=V_FLAG;
 40.2853 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2854 +                                break;
 40.2855 +                                case 0x20: case 0x30: /*SHL b,CL*/
 40.2856 +                                seteab(temp<<c); if (abrt) break;
 40.2857 +                                setznp8(temp<<c);
 40.2858 +                                if ((temp<<(c-1))&0x80) flags|=C_FLAG;
 40.2859 +                                if (((temp<<c)^(temp<<(c-1)))&0x80) flags|=V_FLAG;
 40.2860 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2861 +                                break;
 40.2862 +                                case 0x28: /*SHR b,CL*/
 40.2863 +                                seteab(temp>>c); if (abrt) break;
 40.2864 +                                setznp8(temp>>c);
 40.2865 +                                if ((temp>>(c-1))&1) flags|=C_FLAG;
 40.2866 +                                if (c==1 && temp&0x80) flags|=V_FLAG;
 40.2867 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2868 +                                break;
 40.2869 +                                case 0x38: /*SAR b,CL*/
 40.2870 +                                tempc=(temp>>(c-1))&1;
 40.2871 +                                while (c>0)
 40.2872 +                                {
 40.2873 +                                        temp>>=1;
 40.2874 +                                        if (temp&0x40) temp|=0x80;
 40.2875 +                                        c--;
 40.2876 +                                }
 40.2877 +                                seteab(temp); if (abrt) break;
 40.2878 +                                setznp8(temp);
 40.2879 +                                if (tempc) flags|=C_FLAG;
 40.2880 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2881 +                                break;
 40.2882 +
 40.2883 +//                                default:
 40.2884 +//                                pclog("Bad D2 opcode %02X\n",rmdat&0x38);
 40.2885 +//                                dumpregs();
 40.2886 +//                                exit(-1);
 40.2887 +                        }
 40.2888 +                        break;
 40.2889 +
 40.2890 +                        case 0xD3:
 40.2891 +                        fetchea();
 40.2892 +                        tempw=geteaw(); if (abrt) break;
 40.2893 +                        c=CL&31;
 40.2894 +                        if (!c) break;
 40.2895 +                        cycles -= c;
 40.2896 +                        switch (rmdat&0x38)
 40.2897 +                        {
 40.2898 +                                case 0x00: /*ROL w,CL*/
 40.2899 +                                while (c>0)
 40.2900 +                                {
 40.2901 +                                        temp=(tempw&0x8000)?1:0;
 40.2902 +                                        tempw=(tempw<<1)|temp;
 40.2903 +                                        c--;
 40.2904 +                                }
 40.2905 +                                seteaw(tempw); if (abrt) break;
 40.2906 +                                flags&=~(C_FLAG|V_FLAG);
 40.2907 +                                if (temp) flags|=C_FLAG;
 40.2908 +                                if ((flags&C_FLAG)^(tempw>>15)) flags|=V_FLAG;
 40.2909 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2910 +                                break;
 40.2911 +                                case 0x08: /*ROR w,CL*/
 40.2912 +                                while (c>0)
 40.2913 +                                {
 40.2914 +                                        tempw2=(tempw&1)?0x8000:0;
 40.2915 +                                        tempw=(tempw>>1)|tempw2;
 40.2916 +                                        c--;
 40.2917 +                                }
 40.2918 +                                seteaw(tempw); if (abrt) break;
 40.2919 +                                flags&=~(C_FLAG|V_FLAG);
 40.2920 +                                if (tempw2) flags|=C_FLAG;
 40.2921 +                                if ((tempw^(tempw>>1))&0x4000) flags|=V_FLAG;
 40.2922 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2923 +                                break;
 40.2924 +                                case 0x10: /*RCL w,CL*/
 40.2925 +                                tempc=flags&C_FLAG;
 40.2926 +                                while (c>0)
 40.2927 +                                {
 40.2928 +                                        templ=tempc;
 40.2929 +                                        tempc=tempw&0x8000;
 40.2930 +                                        tempw=(tempw<<1)|templ;
 40.2931 +                                        c--;
 40.2932 +                                }
 40.2933 +                                seteaw(tempw); if (abrt) break;
 40.2934 +                                flags&=~(C_FLAG|V_FLAG);
 40.2935 +                                if (tempc) flags|=C_FLAG;
 40.2936 +                                if ((flags&C_FLAG)^(tempw>>15)) flags|=V_FLAG;
 40.2937 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2938 +                                break;
 40.2939 +                                case 0x18: /*RCR w,CL*/
 40.2940 +                                tempc=flags&C_FLAG;
 40.2941 +                                while (c>0)
 40.2942 +                                {
 40.2943 +                                        templ=tempc;
 40.2944 +                                        tempw2=(templ&1)?0x8000:0;
 40.2945 +                                        tempc=tempw&1;
 40.2946 +                                        tempw=(tempw>>1)|tempw2;
 40.2947 +                                        c--;
 40.2948 +                                }
 40.2949 +                                seteaw(tempw); if (abrt) break;
 40.2950 +                                flags&=~(C_FLAG|V_FLAG);
 40.2951 +                                if (tempc) flags|=C_FLAG;
 40.2952 +                                if ((tempw^(tempw>>1))&0x4000) flags|=V_FLAG;
 40.2953 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2954 +                                break;
 40.2955 +
 40.2956 +                                case 0x20: case 0x30: /*SHL w,CL*/
 40.2957 +                                seteaw(tempw<<c); if (abrt) break;
 40.2958 +                                setznp16(tempw<<c);
 40.2959 +                                if ((tempw<<(c-1))&0x8000) flags|=C_FLAG;
 40.2960 +                                if (((tempw<<c)^(tempw<<(c-1)))&0x8000) flags|=V_FLAG;
 40.2961 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2962 +                                break;
 40.2963 +
 40.2964 +                                case 0x28:            /*SHR w,CL*/
 40.2965 +                                seteaw(tempw>>c); if (abrt) break;
 40.2966 +                                setznp16(tempw>>c);
 40.2967 +                                if ((tempw>>(c-1))&1) flags|=C_FLAG;
 40.2968 +                                if (c==1 && tempw&0x8000) flags|=V_FLAG;
 40.2969 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2970 +                                break;
 40.2971 +
 40.2972 +                                case 0x38:            /*SAR w,CL*/
 40.2973 +                                tempw2=tempw&0x8000;
 40.2974 +                                tempc=((int16_t)tempw>>(c-1))&1;
 40.2975 +                                while (c>0)
 40.2976 +                                {
 40.2977 +                                        tempw=(tempw>>1)|tempw2;
 40.2978 +                                        c--;
 40.2979 +                                }
 40.2980 +                                seteaw(tempw); if (abrt) break;
 40.2981 +                                setznp16(tempw);
 40.2982 +                                if (tempc) flags|=C_FLAG;
 40.2983 +                                cycles -= (mod == 3) ? 5 : 8;
 40.2984 +                                break;
 40.2985 +
 40.2986 +//                                default:
 40.2987 +//                                pclog("Bad D3 opcode %02X\n",rmdat&0x38);
 40.2988 +//                                dumpregs();
 40.2989 +//                                exit(-1);
 40.2990 +                        }
 40.2991 +                        break;
 40.2992 +
 40.2993 +                        case 0xD4: /*AAM*/
 40.2994 +                        tempws=readmemb(cs,pc); pc++;
 40.2995 +                        AH=AL/tempws;
 40.2996 +                        AL%=tempws;
 40.2997 +                        setznp16(AX);
 40.2998 +                        cycles -= 16;
 40.2999 +                        break;
 40.3000 +                        case 0xD5: /*AAD*/
 40.3001 +                        tempws=readmemb(cs,pc); pc++;
 40.3002 +                        AL=(AH*tempws)+AL;
 40.3003 +                        AH=0;
 40.3004 +                        setznp16(AX);
 40.3005 +                        cycles -= 14;
 40.3006 +                        break;
 40.3007 +                        case 0xD6: /*SETALC*/
 40.3008 +                        AL=(flags&C_FLAG)?0xFF:0;
 40.3009 +                        cycles -= 3;
 40.3010 +                        break;
 40.3011 +                        case 0xD7: /*XLAT*/
 40.3012 +                        addr=(BX+AL)&0xFFFF;
 40.3013 +                        temp=readmemb(ds,addr); if (abrt) break;
 40.3014 +                        AL=temp;
 40.3015 +                        cycles -= 5;
 40.3016 +                        break;
 40.3017 +                        case 0xD9: case 0xDA: case 0xDB: case 0xDD:     /*ESCAPE*/
 40.3018 +                        case 0xD8:
 40.3019 +                        case 0xDC:
 40.3020 +                        case 0xDE:
 40.3021 +                        case 0xDF:
 40.3022 +                        if ((msw & 6) == 4)
 40.3023 +                        {
 40.3024 +                                pc=oldpc;
 40.3025 +                                pmodeint(7,0);
 40.3026 +                                cycles -= 40;
 40.3027 +                        }
 40.3028 +                        else
 40.3029 +                        {
 40.3030 +                                fetchea();
 40.3031 +                        }
 40.3032 +                        break;
 40.3033 +
 40.3034 +                        case 0xE0: /*LOOPNE*/
 40.3035 +                        offset=(int8_t)readmemb(cs,pc); pc++;
 40.3036 +                        CX--;
 40.3037 +                        if (CX && !(flags&Z_FLAG)) { pc+=offset; cycles -= 4; cycles -= 2; }
 40.3038 +                        cycles -= 4;
 40.3039 +                        break;
 40.3040 +                        case 0xE1: /*LOOPE*/
 40.3041 +                        offset=(int8_t)readmemb(cs,pc); pc++;
 40.3042 +                        CX--;
 40.3043 +                        if (CX && (flags&Z_FLAG)) { pc+=offset; cycles -= 4; cycles -= 2; }
 40.3044 +                        cycles -= 4;
 40.3045 +                        break;
 40.3046 +                        case 0xE2: /*LOOP*/
 40.3047 +                        offset=(int8_t)readmemb(cs,pc); pc++;
 40.3048 +                        CX--;
 40.3049 +                        if (CX) { pc+=offset; cycles -= 4; cycles -= 2; }
 40.3050 +                        cycles -= 4;
 40.3051 +                        break;
 40.3052 +                        case 0xE3: /*JCXZ*/
 40.3053 +                        offset=(int8_t)readmemb(cs,pc); pc++;
 40.3054 +                        if (!CX) { pc+=offset; cycles -= 4; cycles -= 2; }
 40.3055 +                        cycles-=4;
 40.3056 +                        break;
 40.3057 +
 40.3058 +                        case 0xE4: /*IN AL*/
 40.3059 +                        temp=readmemb(cs,pc);
 40.3060 +                        checkio_perm(temp);
 40.3061 +                        pc++;
 40.3062 +                        AL=inb(temp);
 40.3063 +                        cycles -= 5;
 40.3064 +                        break;
 40.3065 +                        case 0xE5: /*IN AX*/
 40.3066 +                        temp=readmemb(cs,pc);
 40.3067 +                        checkio_perm(temp);
 40.3068 +                        checkio_perm(temp+1);
 40.3069 +                        pc++;
 40.3070 +                        AX=inw(temp);
 40.3071 +                        cycles -= 5;
 40.3072 +                        break;
 40.3073 +                        case 0xE6: /*OUT AL*/
 40.3074 +                        temp=readmemb(cs,pc);
 40.3075 +                        checkio_perm(temp);
 40.3076 +                        pc++;
 40.3077 +                        outb(temp,AL);
 40.3078 +                        cycles -= 3;
 40.3079 +                        break;
 40.3080 +                        case 0xE7: /*OUT AX*/
 40.3081 +                        temp=readmemb(cs,pc);
 40.3082 +                        checkio_perm(temp);
 40.3083 +                        checkio_perm(temp+1);
 40.3084 +                        pc++;
 40.3085 +                        outw(temp,AX);
 40.3086 +                        cycles -= 3;
 40.3087 +                        break;
 40.3088 +
 40.3089 +                        case 0xE8: /*CALL rel 16*/
 40.3090 +                        tempw=getword(); if (abrt) break;
 40.3091 +                        if (ssegs) ss=oldss;
 40.3092 +                        writememw(ss,((SP-2)&0xFFFF),pc); if (abrt) break;
 40.3093 +                        SP-=2;
 40.3094 +                        pc+=(int16_t)tempw;
 40.3095 +                        cycles -= 7;
 40.3096 +                        break;
 40.3097 +                        case 0xE9: /*JMP rel 16*/
 40.3098 +                        tempw=getword(); if (abrt) break;
 40.3099 +                        pc+=(int16_t)tempw;
 40.3100 +                        cycles -= 7;
 40.3101 +                        break;
 40.3102 +                        case 0xEA: /*JMP far*/
 40.3103 +                        addr=getword();
 40.3104 +                        tempw=getword(); if (abrt) { if (output==3) pclog("JMP ABRT\n"); break; }
 40.3105 +                        oxpc=pc;
 40.3106 +                        pc=addr;
 40.3107 +                        loadcsjmp(tempw,oxpc);
 40.3108 +                        cycles -= 11;
 40.3109 +                        break;
 40.3110 +                        case 0xEB: /*JMP rel*/
 40.3111 +                        offset=(int8_t)readmemb(cs,pc); pc++;
 40.3112 +                        pc+=offset;
 40.3113 +                        cycles -= 7;
 40.3114 +                        break;
 40.3115 +                        case 0xEC: /*IN AL,DX*/
 40.3116 +                        checkio_perm(DX);
 40.3117 +                        AL=inb(DX);
 40.3118 +                        cycles -= 5;
 40.3119 +                        break;
 40.3120 +                        case 0xED: /*IN AX,DX*/
 40.3121 +                        checkio_perm(DX);
 40.3122 +                        checkio_perm(DX+1);
 40.3123 +                        AX=inw(DX);
 40.3124 +                        cycles -= 5;
 40.3125 +                        break;
 40.3126 +                        case 0xEE: /*OUT DX,AL*/
 40.3127 +                        checkio_perm(DX);
 40.3128 +                        outb(DX,AL);
 40.3129 +                        cycles -= 4;
 40.3130 +                        break;
 40.3131 +                        case 0xEF: /*OUT DX,AX*/
 40.3132 +                        checkio_perm(DX);
 40.3133 +                        checkio_perm(DX+1);
 40.3134 +                        outw(DX,AX);
 40.3135 +                        cycles -= 4;
 40.3136 +                        break;
 40.3137 +
 40.3138 +                        case 0xF0: /*LOCK*/
 40.3139 +                        break;
 40.3140 +
 40.3141 +                        case 0xF2: /*REPNE*/
 40.3142 +                        rep386(0);
 40.3143 +                        break;
 40.3144 +                        case 0xF3: /*REPE*/
 40.3145 +                        rep386(1);
 40.3146 +                        break;
 40.3147 +
 40.3148 +                        case 0xF4: /*HLT*/
 40.3149 +                        inhlt=1;
 40.3150 +                        pc--;
 40.3151 +                        cycles -= 2;
 40.3152 +/*                        if (!(flags & I_FLAG))
 40.3153 +                        {
 40.3154 +                                pclog("Complete HLT\n");
 40.3155 +                                dumpregs();
 40.3156 +                                exit(-1);
 40.3157 +                        }*/
 40.3158 +                        break;
 40.3159 +                        case 0xF5: /*CMC*/
 40.3160 +                        flags^=C_FLAG;
 40.3161 +                        cycles -= 2;
 40.3162 +                        break;
 40.3163 +
 40.3164 +                        case 0xF6:
 40.3165 +                        fetchea();
 40.3166 +                        temp=geteab(); if (abrt) break;
 40.3167 +                        switch (rmdat&0x38)
 40.3168 +                        {
 40.3169 +                                case 0x00: /*TEST b,#8*/
 40.3170 +                                temp2=readmemb(cs,pc); pc++; if (abrt) break;
 40.3171 +//                                pclog("TEST %02X,%02X\n",temp,temp2);
 40.3172 +/*                        if (cs==0x700 && !temp && temp2==0x10)
 40.3173 +                        {
 40.3174 +                                dumpregs();
 40.3175 +                                exit(-1);
 40.3176 +                        }*/
 40.3177 +                                temp&=temp2;
 40.3178 +                                setznp8(temp);
 40.3179 +                                cycles -= (mod == 3) ? 3 : 6;
 40.3180 +                                break;
 40.3181 +                                case 0x10: /*NOT b*/
 40.3182 +                                temp=~temp;
 40.3183 +                                seteab(temp);
 40.3184 +                                cycles -= (mod == 3) ? 2 : 7;
 40.3185 +                                break;
 40.3186 +                                case 0x18: /*NEG b*/
 40.3187 +                                setsub8(0,temp);
 40.3188 +                                temp=0-temp;
 40.3189 +                                seteab(temp);
 40.3190 +                                cycles -= (mod == 3) ? 2 : 7;
 40.3191 +                                break;
 40.3192 +                                case 0x20: /*MUL AL,b*/
 40.3193 +//                                setznp8(AL);
 40.3194 +                                AX=AL*temp;
 40.3195 +//                                if (AX) flags&=~Z_FLAG;
 40.3196 +//                                else    flags|=Z_FLAG;
 40.3197 +                                if (AH) flags|=(C_FLAG|V_FLAG);
 40.3198 +                                else    flags&=~(C_FLAG|V_FLAG);
 40.3199 +                                cycles -= (mod == 3) ? 13 : 16;
 40.3200 +                                break;
 40.3201 +                                case 0x28: /*IMUL AL,b*/
 40.3202 +//                                setznp8(AL);
 40.3203 +                                tempws=(int)((int8_t)AL)*(int)((int8_t)temp);
 40.3204 +                                AX=tempws&0xFFFF;
 40.3205 +//                                if (AX) flags&=~Z_FLAG;
 40.3206 +//                                else    flags|=Z_FLAG;
 40.3207 +                                if (AH && AH!=0xFF) flags|=(C_FLAG|V_FLAG);
 40.3208 +                                else                flags&=~(C_FLAG|V_FLAG);
 40.3209 +                                cycles -= (mod == 3) ? 13 : 16;
 40.3210 +                                break;
 40.3211 +                                case 0x30: /*DIV AL,b*/
 40.3212 +                                tempw=AX;
 40.3213 +                                if (temp) tempw2=tempw/temp;
 40.3214 +//                                pclog("DIV %04X/%02X %04X:%04X\n",tempw,temp,CS,pc);
 40.3215 +                                if (temp && !(tempw2&0xFF00))
 40.3216 +                                {
 40.3217 +                                        tempw2=tempw%temp;
 40.3218 +                                        AH=tempw2;
 40.3219 +                                        tempw/=temp;
 40.3220 +                                        AL=tempw&0xFF;
 40.3221 +                                        flags|=0x8D5; /*Not a Cyrix*/
 40.3222 +                                }
 40.3223 +                                else
 40.3224 +                                {
 40.3225 +                                        pclog("DIVb BY 0 %04X:%04X\n",cs>>4,pc);
 40.3226 +                                        pc=oldpc;
 40.3227 +                                        if (msw&1) pmodeint(0,0);
 40.3228 +                                        else
 40.3229 +                                        {
 40.3230 +//                                        pclog("%04X:%04X\n",cs>>4,pc);
 40.3231 +                                                writememw(ss,(SP-2)&0xFFFF,flags);
 40.3232 +                                                writememw(ss,(SP-4)&0xFFFF,CS);
 40.3233 +                                                writememw(ss,(SP-6)&0xFFFF,pc);
 40.3234 +                                                SP-=6;
 40.3235 +                                                flags&=~I_FLAG;
 40.3236 +                                                oxpc=pc;
 40.3237 +                                                pc=readmemw(0,0);
 40.3238 +                                                loadcs(readmemw(0,2));
 40.3239 +                                        }
 40.3240 +//                                                cs=loadcs(CS);
 40.3241 +//                                                cs=CS<<4;
 40.3242 +//                                        pclog("Div by zero %04X:%04X %02X %02X\n",cs>>4,pc,0xf6,0x30);
 40.3243 +//                                        dumpregs();
 40.3244 +//                                        exit(-1);
 40.3245 +                                }
 40.3246 +                                cycles -= (mod == 3) ? 14 : 17;
 40.3247 +                                break;
 40.3248 +                                case 0x38: /*IDIV AL,b*/
 40.3249 +//                                pclog("IDIV %04X/%02X\n",tempw,temp);
 40.3250 +                                tempws=(int)(int16_t)AX;
 40.3251 +                                if (temp!=0) tempws2=tempws/(int)((int8_t)temp);
 40.3252 +                                temps=tempws2&0xFF;
 40.3253 +                                if ((temp!=0) && ((int)temps==tempws2))
 40.3254 +                                {
 40.3255 +                                        tempw2=tempws%(int)((int8_t)temp);
 40.3256 +                                        AH=tempw2&0xFF;
 40.3257 +                                        AL=tempws2&0xFF;
 40.3258 +                                        if (!cpu_iscyrix) flags|=0x8D5; /*Not a Cyrix*/
 40.3259 +                                }
 40.3260 +                                else
 40.3261 +                                {
 40.3262 +                                        pclog("IDIVb exception - %X / %08X = %X\n",tempws,temp,tempws2);
 40.3263 +//                                        pclog("IDIVb BY 0 %04X:%04X\n",cs>>4,pc);
 40.3264 +                                        pc=oldpc;
 40.3265 +                                        if (msw&1) pmodeint(0,0);
 40.3266 +                                        else
 40.3267 +                                        {
 40.3268 +                                                writememw(ss,(SP-2)&0xFFFF,flags);
 40.3269 +                                                writememw(ss,(SP-4)&0xFFFF,CS);
 40.3270 +                                                writememw(ss,(SP-6)&0xFFFF,pc);
 40.3271 +                                                SP-=6;
 40.3272 +                                                flags&=~I_FLAG;
 40.3273 +                                                oxpc=pc;
 40.3274 +                                                pc=readmemw(0,0);
 40.3275 +                                                loadcs(readmemw(0,2));
 40.3276 +                                        }
 40.3277 +//                                                cs=loadcs(CS);
 40.3278 +//                                                cs=CS<<4;
 40.3279 +//                                        pclog("Div by zero %04X:%04X %02X %02X\n",cs>>4,pc,0xf6,0x38);
 40.3280 +                                }
 40.3281 +                                cycles -= (mod == 3) ? 17 : 20;
 40.3282 +                                break;
 40.3283 +
 40.3284 +                                default:
 40.3285 +                                pclog("Bad F6 opcode %02X\n",rmdat&0x38);
 40.3286 +                                x86illegal();
 40.3287 +//                                dumpregs();
 40.3288 +//                                exit(-1);
 40.3289 +                        }
 40.3290 +                        break;
 40.3291 +
 40.3292 +                        case 0xF7:
 40.3293 +                        fetchea();
 40.3294 +                        tempw=geteaw(); if (abrt) break;
 40.3295 +                        switch (rmdat&0x38)
 40.3296 +                        {
 40.3297 +                                case 0x00: /*TEST w*/
 40.3298 +                                tempw2=getword(); if (abrt) break;
 40.3299 +//                                if (output==3) pclog("TEST %04X %04X\n",tempw,tempw2);
 40.3300 +                                setznp16(tempw&tempw2);
 40.3301 +                                cycles -= (mod == 3) ? 3 : 6;
 40.3302 +                                break;
 40.3303 +                                case 0x10: /*NOT w*/
 40.3304 +                                seteaw(~tempw);
 40.3305 +                                cycles -= (mod == 3) ? 2 : 7;
 40.3306 +                                break;
 40.3307 +                                case 0x18: /*NEG w*/
 40.3308 +                                setsub16(0,tempw);
 40.3309 +                                tempw=0-tempw;
 40.3310 +                                seteaw(tempw);
 40.3311 +                                cycles -= (mod == 3) ? 2 : 7;
 40.3312 +                                break;
 40.3313 +                                case 0x20: /*MUL AX,w*/
 40.3314 +//                                setznp16(AX);
 40.3315 +                                templ=AX*tempw;
 40.3316 +                                AX=templ&0xFFFF;
 40.3317 +                                DX=templ>>16;
 40.3318 +//                                if (AX|DX) flags&=~Z_FLAG;
 40.3319 +//                                else       flags|=Z_FLAG;
 40.3320 +                                if (DX)    flags|=(C_FLAG|V_FLAG);
 40.3321 +                                else       flags&=~(C_FLAG|V_FLAG);
 40.3322 +                                cycles -= (mod == 3) ? 21 : 24;
 40.3323 +                                break;
 40.3324 +                                case 0x28: /*IMUL AX,w*/
 40.3325 +                                templ=(int)((int16_t)AX)*(int)((int16_t)tempw);
 40.3326 +                                AX=templ&0xFFFF;
 40.3327 +                                DX=templ>>16;
 40.3328 +                                if (DX && DX!=0xFFFF) flags|=(C_FLAG|V_FLAG);
 40.3329 +                                else                  flags&=~(C_FLAG|V_FLAG);
 40.3330 +                                cycles -= (mod == 3) ? 21 : 24;
 40.3331 +                                break;
 40.3332 +                                case 0x30: /*DIV AX,w*/
 40.3333 +                                templ=(DX<<16)|AX;
 40.3334 +                                if (tempw) templ2=templ/tempw;
 40.3335 +                                if (tempw && !(templ2&0xFFFF0000))
 40.3336 +                                {
 40.3337 +                                        tempw2=templ%tempw;
 40.3338 +                                        DX=tempw2;
 40.3339 +                                        templ/=tempw;
 40.3340 +                                        AX=templ&0xFFFF;
 40.3341 +                                        if (!cpu_iscyrix) setznp16(AX); /*Not a Cyrix*/
 40.3342 +                                }
 40.3343 +                                else
 40.3344 +                                {
 40.3345 +//                                        AX=DX=0;
 40.3346 +//                                        break;
 40.3347 +                                        pclog("DIVw BY 0 %04X:%04X %i\n",cs>>4,pc,ins);
 40.3348 +//                                        dumpregs();
 40.3349 +//                                        exit(-1);
 40.3350 +                                        pc=oldpc;
 40.3351 +                                        if (msw&1) pmodeint(0,0);
 40.3352 +                                        else
 40.3353 +                                        {
 40.3354 +//                                        pclog("%04X:%04X\n",cs>>4,pc);
 40.3355 +                                                writememw(ss,(SP-2)&0xFFFF,flags);
 40.3356 +                                                writememw(ss,(SP-4)&0xFFFF,CS);
 40.3357 +                                                writememw(ss,(SP-6)&0xFFFF,pc);
 40.3358 +                                                SP-=6;
 40.3359 +                                                flags&=~I_FLAG;
 40.3360 +                                                oxpc=pc;
 40.3361 +                                                pc=readmemw(0,0);
 40.3362 +                                                loadcs(readmemw(0,2));
 40.3363 +                                        }
 40.3364 +//                                                cs=loadcs(CS);
 40.3365 +//                                                cs=CS<<4;
 40.3366 +//                                        pclog("Div by zero %04X:%04X %02X %02X 1\n",cs>>4,pc,0xf7,0x30);
 40.3367 +                                }
 40.3368 +                                cycles -= (mod == 3) ? 22 : 25;
 40.3369 +                                break;
 40.3370 +                                case 0x38: /*IDIV AX,w*/
 40.3371 +                                tempws=(int)((DX<<16)|AX);
 40.3372 +                                if (tempw!=0) tempws2=tempws/(int)((int16_t)tempw);
 40.3373 +                                temps16=tempws2&0xFFFF;
 40.3374 +//                                pclog("IDIV %i %i ",tempws,tempw);
 40.3375 +                                if ((tempw!=0) && ((int)temps16==tempws2))
 40.3376 +                                {
 40.3377 +                                        DX=tempws%(int)((int16_t)tempw);
 40.3378 +                                        AX=tempws2&0xFFFF;
 40.3379 +                                        if (!cpu_iscyrix) setznp16(AX); /*Not a Cyrix*/
 40.3380 +                                }
 40.3381 +                                else
 40.3382 +                                {
 40.3383 +                                        pclog("IDIVw exception - %X / %08X = %X\n",tempws,tempw,tempws2);
 40.3384 +//                                        pclog("IDIVw BY 0 %04X:%04X\n",cs>>4,pc);
 40.3385 +//                                        DX=0;
 40.3386 +//                                        AX=0xFFFF;
 40.3387 +                                        pc=oldpc;
 40.3388 +                                        if (msw&1) pmodeint(0,0);
 40.3389 +                                        else
 40.3390 +                                        {
 40.3391 +//                                        pclog("%04X:%04X\n",cs>>4,pc);
 40.3392 +                                                writememw(ss,(SP-2)&0xFFFF,flags);
 40.3393 +                                                writememw(ss,(SP-4)&0xFFFF,CS);
 40.3394 +                                                writememw(ss,(SP-6)&0xFFFF,pc);
 40.3395 +                                                SP-=6;
 40.3396 +                                                flags&=~I_FLAG;
 40.3397 +                                                oxpc=pc;
 40.3398 +                                                pc=readmemw(0,0);
 40.3399 +                                                loadcs(readmemw(0,2));
 40.3400 +                                        }
 40.3401 +//                                                cs=loadcs(CS);
 40.3402 +//                                                cs=CS<<4;
 40.3403 +//                                        pclog("Div by zero %04X:%04X %02X %02X 1\n",cs>>4,pc,0xf7,0x38);
 40.3404 +                                }
 40.3405 +                                cycles -= (mod == 3) ? 25 : 28;
 40.3406 +                                break;
 40.3407 +
 40.3408 +                                default:
 40.3409 +                                pclog("Bad F7 opcode %02X\n",rmdat&0x38);
 40.3410 +                                x86illegal();
 40.3411 +//                                dumpregs();
 40.3412 +//                                exit(-1);
 40.3413 +                        }
 40.3414 +                        break;
 40.3415 +
 40.3416 +                        case 0xF8: /*CLC*/
 40.3417 +                        flags&=~C_FLAG;
 40.3418 +                        cycles -= 2;
 40.3419 +                        break;
 40.3420 +                        case 0xF9: /*STC*/
 40.3421 +//                        pclog("STC %04X\n",pc);
 40.3422 +                        flags|=C_FLAG;
 40.3423 +                        cycles -= 2;
 40.3424 +                        break;
 40.3425 +                        case 0xFA: /*CLI*/
 40.3426 +                        if (!IOPLp)
 40.3427 +                        {
 40.3428 +                                x86gpf(NULL,0);
 40.3429 +                        }
 40.3430 +                        else
 40.3431 +                           flags&=~I_FLAG;
 40.3432 +                        cycles -= 3;
 40.3433 +                        break;
 40.3434 +                        case 0xFB: /*STI*/
 40.3435 +                        if (!IOPLp)
 40.3436 +                        {
 40.3437 +                                x86gpf(NULL,0);
 40.3438 +                        }
 40.3439 +                        else
 40.3440 +                           flags|=I_FLAG;
 40.3441 +                        cycles -= 2;
 40.3442 +                        break;
 40.3443 +                        case 0xFC: /*CLD*/
 40.3444 +                        flags&=~D_FLAG;
 40.3445 +                        cycles -= 2;
 40.3446 +                        break;
 40.3447 +                        case 0xFD: /*STD*/
 40.3448 +                        flags|=D_FLAG;
 40.3449 +                        cycles -= 2;
 40.3450 +                        break;
 40.3451 +
 40.3452 +                        case 0xFE: /*INC/DEC b*/
 40.3453 +                        fetchea();
 40.3454 +                        temp=geteab(); if (abrt) break;
 40.3455 +                        if (rmdat&0x38)
 40.3456 +                        {
 40.3457 +                                seteab(temp-1); if (abrt) break;
 40.3458 +                                flags&=~V_FLAG;
 40.3459 +                                setsub8nc(temp,1);
 40.3460 +                                temp2=temp-1;
 40.3461 +                                if ((temp&0x80) && !(temp2&0x80)) flags|=V_FLAG;
 40.3462 +                        }
 40.3463 +                        else
 40.3464 +                        {
 40.3465 +                                seteab(temp+1); if (abrt) break;
 40.3466 +                                flags&=~V_FLAG;
 40.3467 +                                setadd8nc(temp,1);
 40.3468 +                                temp2=temp+1;
 40.3469 +                                if ((temp2&0x80) && !(temp&0x80)) flags|=V_FLAG;
 40.3470 +                        }
 40.3471 +                        cycles -= (mod == 3) ? 2 : 7;
 40.3472 +                        break;
 40.3473 +
 40.3474 +                        case 0xFF:
 40.3475 +                        fetchea();
 40.3476 +                        switch (rmdat&0x38)
 40.3477 +                        {
 40.3478 +                                case 0x00: /*INC w*/
 40.3479 +                                tempw=geteaw();  if (abrt) break;
 40.3480 +                                seteaw(tempw+1); if (abrt) break;
 40.3481 +                                setadd16nc(tempw,1);
 40.3482 +                                cycles -= (mod == 3) ? 2 : 7;
 40.3483 +                                break;
 40.3484 +                                case 0x08: /*DEC w*/
 40.3485 +                                tempw=geteaw();  if (abrt) break;
 40.3486 +                                seteaw(tempw-1); if (abrt) break;
 40.3487 +                                setsub16nc(tempw,1);
 40.3488 +                                cycles -= (mod == 3) ? 2 : 7;
 40.3489 +                                break;
 40.3490 +                                case 0x10: /*CALL*/
 40.3491 +                                tempw=geteaw();
 40.3492 +                                if (abrt) break;
 40.3493 +                                if (ssegs) ss=oldss;
 40.3494 +                                writememw(ss,(SP-2)&0xFFFF,pc); if (abrt) break;
 40.3495 +                                SP-=2;
 40.3496 +                                pc=tempw;
 40.3497 +                                cycles -= (mod == 3) ? 7 : 11;
 40.3498 +                                break;
 40.3499 +                                case 0x18: /*CALL far*/
 40.3500 +                                tempw=readmemw(easeg,eaaddr);
 40.3501 +                                tempw2=readmemw(easeg,(eaaddr+2)); if (output==3) pclog("CALL FAR %04X:%04X\n",tempw,tempw2); if (abrt) break;
 40.3502 +                                tempw3=CS;
 40.3503 +                                templ2=pc;
 40.3504 +                                if (ssegs) ss=oldss;
 40.3505 +                                oxpc=pc;
 40.3506 +                                pc=tempw;
 40.3507 +                                optype=CALL;
 40.3508 +                                if (msw&1) loadcscall(tempw2);
 40.3509 +                                else       loadcs(tempw2);
 40.3510 +                                optype=0;
 40.3511 +                                if (abrt) break;
 40.3512 +                                oldss=ss;
 40.3513 +                                writememw(ss,(SP-2)&0xFFFF,tempw3);
 40.3514 +                                writememw(ss,((SP-4)&0xFFFF),templ2);
 40.3515 +                                SP-=4;
 40.3516 +                                cycles -= 16;
 40.3517 +                                break;
 40.3518 +                                case 0x20: /*JMP*/
 40.3519 +                                tempw=geteaw(); if (abrt) break;
 40.3520 +                                pc=tempw;
 40.3521 +                                cycles -= (mod == 3) ? 7 : 11;
 40.3522 +                                break;
 40.3523 +                                case 0x28: /*JMP far*/
 40.3524 +                                oxpc=pc;
 40.3525 +                                tempw=readmemw(easeg,eaaddr);
 40.3526 +                                tempw2=readmemw(easeg,eaaddr+2); if (abrt) break;
 40.3527 +                                pc=tempw;                                
 40.3528 +                                loadcsjmp(tempw2,oxpc); if (abrt) break;
 40.3529 +                                cycles -= 15;
 40.3530 +                                break;
 40.3531 +                                case 0x30: /*PUSH w*/
 40.3532 +                                tempw=geteaw(); if (abrt) break;
 40.3533 +                                if (ssegs) ss=oldss;
 40.3534 +                                writememw(ss,((SP-2)&0xFFFF),tempw); if (abrt) break;
 40.3535 +                                SP-=2;
 40.3536 +                                cycles -= (mod==3) ? 3 : 5;
 40.3537 +                                break;
 40.3538 +
 40.3539 +                                default:
 40.3540 +                                pclog("Bad FF opcode %02X\n",rmdat&0x38);
 40.3541 +                                x86illegal();
 40.3542 +                                //dumpregs();
 40.3543 +                                //exit(-1);
 40.3544 +                        }
 40.3545 +                        break;
 40.3546 +
 40.3547 +                        default:
 40.3548 +//                        pc--;
 40.3549 +//                        cycles-=8;
 40.3550 +//                        break;
 40.3551 +                        pclog("Bad opcode %02X at %04X:%04X from %04X:%04X %08X\n",opcode,cs>>4,pc,old8>>16,old8&0xFFFF,old82);
 40.3552 +                        x86illegal();
 40.3553 +//                        dumpregs();
 40.3554 +//                        exit(-1);
 40.3555 +                }
 40.3556 +                opcodeend:
 40.3557 +                pc&=0xFFFF;
 40.3558 +
 40.3559 +//                output = 3;
 40.3560 +/*                output = 3;
 40.3561 +                
 40.3562 +                if (pc == 0xcdd && CS == 0xf000)
 40.3563 +                {
 40.3564 +                        dumpregs();
 40.3565 +                        exit(-1);
 40.3566 +                }*/
 40.3567 +                //if (ins == 20768972) output = 3;
 40.3568 +                
 40.3569 +                if (ssegs)
 40.3570 +                {
 40.3571 +                        ds=oldds; _ds.limit=olddslimit; _ds.limitw=olddslimitw;
 40.3572 +                        ss=oldss; _ss.limit=oldsslimit; _ss.limitw=oldsslimitw;
 40.3573 +                        ssegs=0;
 40.3574 +                }
 40.3575 +                if (abrt)
 40.3576 +                {
 40.3577 +                        tempi = abrt;
 40.3578 +                        abrt = 0;
 40.3579 +                        x86_doabrt(tempi);
 40.3580 +                        if (abrt)
 40.3581 +                        {
 40.3582 +                                abrt = 0;
 40.3583 +                                CS = oldcs;
 40.3584 +                                pc = oldpc;
 40.3585 +                                pclog("Double fault\n");
 40.3586 +//                                dumpregs();
 40.3587 +//                                exit(-1);
 40.3588 +                                pmodeint(8, 0);
 40.3589 +                                if (abrt)
 40.3590 +                                {
 40.3591 +                                        abrt = 0;
 40.3592 +                                        softresetx86();
 40.3593 +                                        pclog("Triple fault - reset\n");
 40.3594 +                                }
 40.3595 +                        }
 40.3596 +                }
 40.3597 +                cycdiff-=cycles;
 40.3598 +
 40.3599 +                pit.c[0]-=cycdiff;
 40.3600 +                pit.c[1]-=cycdiff;
 40.3601 +                if (ppi.pb&1)         pit.c[2]-=cycdiff;
 40.3602 +
 40.3603 +                if ((pit.c[0]<1)||(pit.c[1]<1)||(pit.c[2]<1)) pit_poll();
 40.3604 +
 40.3605 +                spktime-=cycdiff;
 40.3606 +                if (spktime<=0.0)
 40.3607 +                {
 40.3608 +                        spktime+=SPKCONST;
 40.3609 +//                        pclog("1Poll spk\n");
 40.3610 +                        pollspk();
 40.3611 +                        pollgussamp();
 40.3612 +                        getsbsamp();
 40.3613 +                        polladlib();
 40.3614 +                        getdacsamp();
 40.3615 +//                        pclog("2Poll spk\n");
 40.3616 +                }
 40.3617 +                soundtime-=cycdiff;
 40.3618 +                if (soundtime<=0.0)
 40.3619 +                {
 40.3620 +                        soundtime+=SOUNDCONST;
 40.3621 +//                        pclog("1Poll sound60hz\n");
 40.3622 +                        pollsound60hz();
 40.3623 +//                        pclog("2Poll sound60hz\n");
 40.3624 +                }
 40.3625 +                gustime-=cycdiff;
 40.3626 +                while (gustime<=0.0)
 40.3627 +                {
 40.3628 +                        gustime+=GUSCONST;
 40.3629 +                        pollgus();
 40.3630 +                }
 40.3631 +                gustime2-=cycdiff;
 40.3632 +                while (gustime2<=0.0)
 40.3633 +                {
 40.3634 +                        gustime2+=GUSCONST2;
 40.3635 +                        pollgus2();
 40.3636 +                }
 40.3637 +                vidtime-=cycdiff;
 40.3638 +                if (vidtime<=0.0)
 40.3639 +                {
 40.3640 +//                        pclog("1Poll video\n");
 40.3641 +                        pollvideo();
 40.3642 +//                        pclog("2Poll video\n");
 40.3643 +                }
 40.3644 +                if (disctime)
 40.3645 +                {
 40.3646 +                        disctime-=cycdiff/4;
 40.3647 +                        if (disctime<=0)
 40.3648 +                        {
 40.3649 +//                                pclog("1Poll disc\n");
 40.3650 +                                disctime=0;
 40.3651 +                                fdc_poll();
 40.3652 +//                                pclog("2Poll disc\n");
 40.3653 +                        }
 40.3654 +                }
 40.3655 +                if (mousedelay)
 40.3656 +                {
 40.3657 +                        mousedelay-=20;
 40.3658 +                        if (!mousedelay)
 40.3659 +                        {
 40.3660 +//                                pclog("1Poll mouse\n");
 40.3661 +                                mousecallback();
 40.3662 +//                                pclog("2Poll disc\n");
 40.3663 +                        }
 40.3664 +                }
 40.3665 +                if (sbenable)
 40.3666 +                {
 40.3667 +                        sbcount-=cycdiff;
 40.3668 +                        if (sbcount<0)
 40.3669 +                        {
 40.3670 +                                sbcount+=sblatcho;
 40.3671 +                                pollsb();
 40.3672 +                        }
 40.3673 +                }
 40.3674 +                if (sb_enable_i)
 40.3675 +                {
 40.3676 +                        sb_count_i-=cycdiff;
 40.3677 +                        if (sb_count_i<0)
 40.3678 +                        {
 40.3679 +                                sb_count_i+=sblatchi;
 40.3680 +                                sb_poll_i();
 40.3681 +                        }
 40.3682 +                }
 40.3683 +                rtctime-=cycdiff;
 40.3684 +                if (rtctime<0)
 40.3685 +                {
 40.3686 +                        nvr_rtc();
 40.3687 +                }
 40.3688 +                if (idecallback[0])
 40.3689 +                {
 40.3690 +                        idecallback[0]--;
 40.3691 +                        if (idecallback[0]<=0)
 40.3692 +                        {
 40.3693 +//                                pclog("IDE time over\n");
 40.3694 +                                idecallback[0]=0;
 40.3695 +                                callbackide(0);
 40.3696 +                        }
 40.3697 +                }
 40.3698 +                if (idecallback[1])
 40.3699 +                {
 40.3700 +                        idecallback[1]--;
 40.3701 +                        if (idecallback[1]<=0)
 40.3702 +                        {
 40.3703 +//                                pclog("IDE time over\n");
 40.3704 +                                idecallback[1]=0;
 40.3705 +                                callbackide(1);
 40.3706 +                        }
 40.3707 +                }
 40.3708 +                if (trap && (flags&T_FLAG) && !noint)
 40.3709 +                {
 40.3710 +                        if (msw&1)
 40.3711 +                        {
 40.3712 +                                pmodeint(1,0);
 40.3713 +                                cycles -= 40;
 40.3714 +                        }
 40.3715 +                        else
 40.3716 +                        {
 40.3717 +                                writememw(ss,(SP-2)&0xFFFF,flags);
 40.3718 +                                writememw(ss,(SP-4)&0xFFFF,CS);
 40.3719 +                                writememw(ss,(SP-6)&0xFFFF,pc);
 40.3720 +                                SP-=6;
 40.3721 +                                addr=1<<2;
 40.3722 +                                flags&=~I_FLAG;
 40.3723 +                                flags&=~T_FLAG;
 40.3724 +                                pc=readmemw(0,addr);
 40.3725 +                                loadcs(readmemw(0,addr+2));
 40.3726 +                                cycles -= 23;
 40.3727 +                        }
 40.3728 +                }
 40.3729 +                else if ((flags&I_FLAG) && (((pic.pend&~pic.mask)&~pic.mask2) || ((pic2.pend&~pic2.mask)&~pic2.mask2)) && !ssegs && !noint)
 40.3730 +                {
 40.3731 +//                        pclog("Test %02X %02X %02X\n", pic.pend, pic.mask, pic.mask2);
 40.3732 +                        temp=picinterrupt();
 40.3733 +                        if (temp!=0xFF)
 40.3734 +                        {
 40.3735 +//                                pclog("286 int %02X %02X %02X %02X\n",temp, pic.pend, pic.mask, pic.mask2);
 40.3736 +                                if (inhlt) pc++;
 40.3737 +//                                intcount++;
 40.3738 +                                if (msw&1)
 40.3739 +                                {
 40.3740 +                                        pmodeint(temp,0);
 40.3741 +                                        cycles -= 40;
 40.3742 +                                }
 40.3743 +                                else
 40.3744 +                                {
 40.3745 +                                        writememw(ss,(SP-2)&0xFFFF,flags);
 40.3746 +                                        writememw(ss,(SP-4)&0xFFFF,CS);
 40.3747 +                                        writememw(ss,(SP-6)&0xFFFF,pc);
 40.3748 +                                        SP-=6;
 40.3749 +                                        addr=temp<<2;
 40.3750 +                                        flags&=~I_FLAG;
 40.3751 +                                        flags&=~T_FLAG;
 40.3752 +                                        pc=readmemw(0,addr);
 40.3753 +                                        loadcs(readmemw(0,addr+2));
 40.3754 +                                        cycles -= 23;
 40.3755 +                                }
 40.3756 +                                inint=1;
 40.3757 +                        }
 40.3758 +                }
 40.3759 +
 40.3760 +/*                if (pc==0xCC32 && es>0x180000)
 40.3761 +                {
 40.3762 +                        pc=0xCBEB;
 40.3763 +//                        output=1;
 40.3764 +//                        timetolive=500000;
 40.3765 +                }*/
 40.3766 +
 40.3767 +                if (noint) noint=0;
 40.3768 +                ins++;
 40.3769 +                insc++;
 40.3770 +                
 40.3771 +//                if (ins == 25000000) output = 3;
 40.3772 +/*                if (timetolive)
 40.3773 +                {
 40.3774 +                        timetolive--;
 40.3775 +                        if (!timetolive)
 40.3776 +                        {
 40.3777 +                                dumpregs();
 40.3778 +                                exit(-1);
 40.3779 +                        } //output=0;
 40.3780 +                }*/
 40.3781 +                keybsenddelay--;
 40.3782 +                if (keybsenddelay<1)
 40.3783 +                {
 40.3784 +                        keybsenddelay = 2500;
 40.3785 +                        keyboard_poll();
 40.3786 +                }
 40.3787 +                //output = 3;
 40.3788 +        }
 40.3789 +}
 40.3790 +//#endif