Ok, I'll give it a try

In your example of assembly output you are using lazy evaluation in reverse ordering. That means that you are checking each comparison from right to left and you jump straight to the code block as soon as you can guarentee that the if statement is true.
Now I don't know the full scope of your If Parser language, but I suggest making a full evaluation of the if expression. In other words, in stead of testing each boolean comparison, you just calculate one single boolean value which you then test on whether to see if you should execute the code block or not. Now if your language only allows for simple boolean comparision like testing variables against immeduate values, you don't actual need full evaluation. Full evaluation is only needed if your comparisons may contain side effects. However full evalution is a nice language property IMHO and it reduces the number of branching operations to 1.

What I tried to write before was basically how the code could be seen from the parsers view point. Basically any comparision like 'eax == 10' or 'eax < 12' results in a boolean value. In the end all your if statement is doing is testing if a single boolean value is true or false to see if some code should be executed. I suggest you calculate that single boolean value and test that in stead of testing all the smaller boolean values.

Let me try and give a pseudo-code example of how your if statement could look like when using full evaluation:

Code:
//(((edx == 1) or (edx == 7)) or (eax == 5) or ((eax == 10) and (ebx == 10)))

r0 := edx = 1      // edx == 1
r1 := edx = 7      // edx == 7
r0 := r0 or r1      // (edx == 1) or (edx == 7)
r1 := eax = 5      // eax == 5
r0 := r0 or r1      // ((edx == 1) or (edx == 5)) or (eax == 5)
r1 := eax = 10    // eax == 10
r2 := ebx = 10    // ebx == 10
r1 := r1 and r2    // (eax == 10) and (ebx == 10)
r0 := r0 or r1      // ((edx == 1) or (edx == 7)) or (eax == 5) or ((eax == 10) and (ebx == 10))

jne r0 true :label:   // test if r0 is true or false
// the code 
:label:
// no code was executed
As you can see the code will at most make one jump while your method introduces more jumps the more complex your if statement is. I have no idea if my method is faster than yours on average, but I do know that branches are considered slow and it is good to reduce the number of them.

This method will however require that you implement boolean variables since booleans are saved in temporary registers. If you haven't implemented boolean variables already you'll have to judge if it's worth doing so. It depends on among other things whether you need boolean variables other places in your code and if you need/want full evaluation. I suppose it could be a good/fun exercise to implement boolean variables and logic in a language