you CAN, but you have to write your own routines to do so.

well, it's much mroe complicated than you think.  basically, you're treating data not in bytes or words, but rather in dwords and 24 bit values.  Basically, to do math in this format, you have to check the value of the added number to see how large it is and how many bytes it consumes.  so, if it's within one byte, add the number to the very least significant byte and add overflow to the nextmost significant byte (and continue if that overflows too)

for a 16 bit addition, add the least most significant bits, carry overflow, then add the next most next significant byte, then carry overflow etc.

Never really done in axe before, though very possible to do in assembly.

any information would be great.
i would b using L1 for the byte probably.

You want to look here:
http://future_history.freehostia.com/Files/Resources/ASM/ASMin28Days/lesson/day15.html

However, it's ridiculously complex and would be better suited for an Axiom.

any information would be great.
i would b using L1 for the byte probably.

Let's see... You probably know how to do equality (just check the two byte pairs for equality individually). Greater than/less than is also pretty easy: check the high (most significant) byte pair first, whichever one that is, and if it's equal, check the other byte pair. AND, OR, and XOR should work about the same: just do it on both byte pairs, then compare.

For math, addition and subtraction should be easiest, but the fastest way to do it would involve carries, which would require some messing with Asm(.

You can also do it without ASM (in normal Axe), so here's a quick rundown involving two 4-byte numbers (since it's the easiest to do). By "least-significant byte pair" I mean the two bytes that take up the smallest place value, and the "most-significant byte pair" is the two bytes that are at the highest place value.

Let's say you want to add two numbers together. It's easy if the least significant byte pair doesn't end up overflowing past 65535, since in that case all you have to do is add the least significant byte pair, then the other one. No messing around with anything; just simple addition.

But then if the smaller byte pair overflows, you'll have to add an extra one (carrying) to the other one. We tend to get used to it in real life, so to recap, it's like this:

 1
 19
+22
 41

That extra 1's the carry I'm talking about. So how would you check for it? Well, basically if you add the least significant byte pair and it ends up being smaller than the first number you started with, you know there's a carry (like the 9+2 becoming a 1 above). Just test for this before and after you do the actual addition, and if there is a carry, add one more when you add the most significant byte pairs together.

Subtraction works pretty much the same way, but in the opposite direction: if you subtract two least-significant byte pairs and it ends up being bigger than the one you started with, there's a carry, so subtract one more when you do the other byte pair.

No problem, and sorry if it's confusing. I should probably give you more examples, but I gotta go. If anyone else understands it, they can give you any examples.

Lol, that'd be hard. Axe doesn't even support that for one or two-byte numbers...