jb | A simple and fast JSON API template engine for Ruby on Rails | Application Framework library

Current IntelliJ IDEA version requires Java 11 to run. Remove the overrides (idea.jdk file/environment variables) to use the default bundled JetBrains Runtime.

The elements of array are words, 2 bytes each, but you only increment your index bx by 1 on each iteration of your loop. Addresses on x86 are in units of bytes, so on the next loop iteration, you load from the middle of the word, and you end up with one byte from one element and another byte from the other.

Probably simplest to do everything in terms of bytes, instead of elements. (In 32- or 64-bit code you could use the scale addressing mode, mov cx, [array+ebx*2], and then keep counting ebx in elements, but that's not available in 16-bit real mode.)

Also, the high half of bx is uninitialized. It's probably best to just use 16-bit values for your indices.

I'd rewrite as (untested):

This is quite hard to optimize this loop. The main issue is that each iteration of the loop is dependent of the previous one and even instructions in the loops are dependent. This creates a long nearly sequential chain of instruction to be executed. As a result the processor cannot execute this efficiently. In addition, some instructions in this chain have a quite high latency: tzcnt has a 3-cycle latency on Intel processors and L1 load/store have a 3 cycle latency.

One solution is work directly with registers instead of an array with indirect accesses so to reduce the length of the chain and especially instruction with the highest latency. This can be done by unrolling the loop twice and splitting the problem in two different ones:

I keep getting the same error as 'Operand types do not match on lines 18 and 19

That's because TASM knows that the a and b variables are byte-sized given that they were defined using the DB directive, but your instructions mov bx,a and mov cx,b are word-sized operations. So, a mis-match.

Your program is using the a and b 'variables' for user input via the DOS.BufferedInput function 0Ah. Read all about this function here.

What your definitions should look like is:

Based on the code you've provided, the problem is the same as other Callback-related questions here: you're losing the native allocation of TRANX due to Java's garbage collection.

A JNA Structure consists of two parts: a pointer (to data), and the data itself. You have not provided the native typedef for TRANX to confirm your JNA mapping, but an instantiated object will have an internal pointer reference, pointing to a 4-byte allocation of memory (the int unused).

You only show the callback code where TRANX is already an argument, meaning you've already instantiated it to pass to the callback.

If you allocated it yourself using new TRANX() or new TRANX(int unused), then JNA has

• allocated 4 bytes of native memory
• stored the pointer to it internally

In JNA, the native memory attached to a Structure is automatically freed as a part of the garbage collection process. This is a common problem with callbacks, as you generally don't control the timing of the callback return, so the following sequence occurs:

• You create the object in Java (allocating the native 4 bytes which the TRANX structure tracks the pointer to internally)
• You pass the TRANX object to the callback
• Immediately after passing the object, Java no longer has need for its own object; it is unreachable and thus eligible for garbage collection
• When GC occurs the native 4 bytes are freed as part of the process
• The TRANX object in the callback still has the pointer internally, but it now points to memory that is no longer allocated, resulting in the SIGSEGV (or Invalid Memory Access error, or strange symptoms if the memory is allocated by another thread, or other undefined behavior).

The solution to the problem is to track the memory associated with TRANX.

• If you are allocating it yourself, keep a reference to the TRANX object to prevent it from being unreachable.
  • This generally requires accessing the TRANX structure at some later point after you are sure the callback will have been processed
  • In JDK9+ a ReachabilityFence can be used for this.
  • In JDK8 you should manipulate the class in some way (e.g., read a value from it, or call toString on it, etc.).
• If you are using a native allocation and creating the pointer from the peer value returned from the native API, then read the API to determine when that memory is freed.

"How do I use the stack to find out if every letter has been printed when is the end reached?"

You could always push a special character onto the stack before starting, and during your print loop you can check to see if you encounter this special character before printing. If you do, then instead jump to Ende. I would of course not use a character in the range of uppercase ASCII, as that would cause issues. Perhaps simply push 0x0 onto the stack to start with and check for that after pop eax in loop. Something like this:

The min proc exhibits these two errors:

• You are using the opposite of the condition that you would need in order to find the minimum.
• Your code will, in its final iteration, treat the $-terminator as if it were an array element. You must check for the terminator before comparing with a following array element because said element might not exist.

What the code does is InsertionSort in the ascending order.

I'm not sure this is the best way to unpack a dictionary, but it works:
(It's used to keep the child "metadata" like the id (duplicate), and holding account full name)

The QQ graph does not show that the data are normally distributed. If you would calculate a single indicator from a QQ plot, then you would measure the (positive vertical ) distances of the points to the red reference line and sum them up. In your case, almost all points deviate from the reference line, voting for a non-normal distribution.

A typical QQ plot of normally distributed data has got a large majority of points on the red reference line and some points at the ends (left and right) may deviate.