Since in the other emulators im not exactly seeing the ABCD instruction (probably because it was sort of embeded into the ADD instruction itself I'm assuming...at least in one of the emulators) we are going to skip that and focus on ADD. So according to the Motorola 68000 PDF documentation:

Code:
ADD
(M68000 Family)

Operation: Source + Destination→Destination

Assembler: ADD < ea > ,Dn

Syntax: ADD Dn, < ea >

Attributes: Size = (Byte, Word, Long)
Description: Adds the source operand to the destination operand using binary addition and stores the result in the destination location. The size of the operation may be specified as byte, word, or long. The mode of the instruction indicates which operand is the source and which is the destination, as well as the operand size.

Condition Codes:
X — Set the same as the carry bit.
N — Set if the result is negative; cleared otherwise.
Z — Set if the result is zero; cleared otherwise.
V — Set if an overflow is generated; cleared otherwise.
C — Set if a carry is generated; cleared otherwise.

Instruction Format:
X *
N *
Z *
V *
C *

|15|14|13|12|11|10|09|08|07|06|05|04|03||02|01|00|
| 1 | 1 | 0| 1 |REGISTER|OPMODE| MODE | REGISTER |
There are also multiple data types used for ADD such as Byte (8 bit), Short (16 Bit), as well as Integer (32 bit). 64 bit instructions are not supported. And according to one emulators I examined, there are 2 different versions of each. One version having condition code registers updated and the other not having condition code registers updated. For example, here is the C# version:

C# Code:
  1. #region Add Helper Functions
  2.         private sbyte Add(sbyte a, sbyte b, bool updateConditions, bool useX)
  3.         {
  4.             int result = useX ? (int)a + (int)b + (this.X ? 1 : 0) : (int)a + (int)b;
  5.  
  6.             if (updateConditions)
  7.             {
  8.                 this.C = this.X = (result & 0x100) > 0;
  9.                 this.V = result > sbyte.MaxValue || result < sbyte.MinValue;
  10.                 this.N = result < 0;
  11.                 if (!useX) { this.Z = result == 0; }
  12.             }
  13.  
  14.             return (sbyte)result;
  15.         }
  16.  
  17.         private short Add(short a, short b, bool updateConditions, bool useX)
  18.         {
  19.             int result = useX ? (int)a + (int)b + (this.X ? 1 : 0) : (int)a + (int)b;
  20.  
  21.             if (updateConditions)
  22.             {
  23.                 this.C = this.X = (result & 0x10000) > 0;
  24.                 this.V = result > short.MaxValue || result < short.MinValue;
  25.                 this.N = result < 0;
  26.                 if (!useX) { this.Z = result == 0; }
  27.             }
  28.  
  29.             return (short)result;
  30.         }
  31.  
  32.         private int Add(int a, int b, bool updateConditions, bool useX)
  33.         {
  34.             long result = useX ? (long)a + (long)b + (this.X ? 1 : 0) : (long)a + (long)b;
  35.  
  36.             if (updateConditions)
  37.             {
  38.                 this.C = this.X = (result & 0x100000000) > 0;
  39.                 this.V = result > int.MaxValue || result < int.MinValue;
  40.                 this.N = result < 0;
  41.                 if (!useX) { this.Z = result == 0; }
  42.             }
  43.  
  44.             return (int)result;
  45.         }
  46.         #endregion Add Helper Functions

The C++ version unfortunately had waaaay too many versions of ADD and I believe was overkill and complex for no reason IMO. I think the main difference was the Program Counter (PC) and thats about it but I will need to examine the code more closely. So this will be the primary focus before we translate it to VB.