Multiply using ***Real*** numbers Inspired by a restriction on What do you get when you multiply 6 by 9? (42)

By order of the President, we are no longer permitted to use confusing fake numbers (i.e. numbers other than integers from 0 to 99 inclusive), and are instead to use only real numbers, that is, those that are not fake.

Unfortunately, most maths are very unpatriotic at present and thus it is necessary to revolutionalize a new, revised, mathematics for the glory of the State.

Your task is to create a program or function which takes as its input two numbers and provides as its output their product.  Your program, obviously, must be consistent with Minitrue's standards for programmatic excellence.  Specifically:


You may use real numbers in your code; users of fake numbers will be referred to Miniluv
If a fake number is provided as input, you are to raise an error to that effect raised only in this case.  If your chosen language is incapable of error, you are to write a consistent Truthy or Falsy value to a different output stream than normal, this value being written to that output stream only in this case.
Your program must never output any fake numbers; users of fake numbers will by referred to Miniluv
Your program must output consistently with pre-Ministry math texts, except where those texts are influenced by thoughtcrime (i.e. where the input or output would be a fake number).  In those cases, you are free to define whatever truth you think best furthers the Party's goals, provided your output is consistent with above principles.
Your input is guaranteed to be either two real numbers, two fake numbers, or one real and one fake number


This is code golf; the shortest code in bytes wins.

Some test cases:

Input: 0, 3 Output: 0
Input: 2, 5 Output: 10
Input: 9, 11 Output: 99
Input: 10, 10 Output*: 5
Input: -1, 0 Output*: ERROR: THOUGHTCRIME COMMITTED
Input: 2, 2.5 Output*: ERROR: THOUGHTCRIME COMMITTED
Input: 99, 2 Output*: 5
Input: -1, 53 Output*: ERROR: THOUGHTCRIME COMMITTED


Test cases with an 'Output*' indicate that there are multiple valid outputs for that test case.

Please note that while your output in the case of a fake product from real numbers may be an error, it cannot be the same error as for fake input (unless both cases trigger), as explained in rule #2.
Python, &nbsp;54&nbsp; 52 bytes

lambda a,b:[v for v in(a,b,a*b%-~99)if'd'&gt;chr(v)][2]


An unnamed function raising an error if either of the inputs are fake otherwise returning the product of the inputs modulo 100 (always real and correct if the product itself is real).

Try it online!

How?

First creates a tuple of the inputs and their product modulo 100 using (a,b,a*b%-~99) where ~x computes -1-x and % is the modulo operator.

Then traverses that tuple creating a list of those values which are real numbers.

The test for real-ness is performed by first attempting to cast each value, v, to characters with chr(v) - which will raise a ValueError if v is not a non-negative integer less than 256, then checking the value is less than 100 by a less-than-comparison, &lt;, to the 100th character, 'd'.

If both a and b are real the list will have three entries (the product modulo 100 is alway real), otherwise it will have less. The [...][2] attempts to get the item at the second index (third item), raising an IndexError if it does not exist.

Thus either input being fake results in either a ValueError or IndexError, while both inputs being real always succeeds and returns a real number, and if that product is itself real it is the returned value.