I have a program (ELF, 32 bits) that is probably quite short and simple, but which have been obfuscated with the following construction:

```
i = 0
switch(i):
    case 0:
        one small instruction
        i = 1
    case 1:
        one small instruction
        i = 2
    case 2:
        ....

```

An example of assembly would be:

```
loc_804E5E8:                                                             
                pop     eax             
                push    eax
                mov     eax, 20h
                push    eax
                mov     eax, 4B3h
                jmp     loc_804FE24

```

where loc\_804FE24 contains the loading of the offset from the table, and the `jmp eax`.

There are some minor differences sometimes, it is not always perfectly linear like this, but it mostly follow this schema. How should I approach the reversing of this program? I'm pretty sure there is a simple and basic way to handle this, but I am pretty new to the field of reverse engineering. Thank you.

EDIT : if there is a way to recover all the instructions that are effectively executed one after the another, maybe writing a parser would be efficient ?

EDIT2 : I wondered if using a symbolic execution engine would be appropriate or not. Based on [this link](https://doar-e.github.io/blog/2013/09/16/breaking-kryptonites-obfuscation-with-symbolic-execution/), symbolic execution is best used when:

* there is no branches, no loops,
* the instruction aren't playing with the EFLAGS register.
* the instruction only used 32 bits registers (not 16 bits, or 8 bits).
* the number of unique instruction is really small (i.e. only mov, shr, shl, xor, and, xor, add)
* the instructions used are easy to emulate.

though in my case, there are a couple branches, some EFLAGS uses with `pushf / popf`, and some low sized registers. But if this approach really isn't pertinent here, I really am at a loss for ideas.