human
Solve the following python programming problem given the following code:
# Construct a custom lifter
class LifterFixCallStack(LifterModelCall_x86_32):
        def call_effects(self, addr, instr):
            if addr.is_loc():
                if self.loc_db.get_location_offset(addr.loc_key) == 0x11223344:
                    # Suppose the function at 0x11223344 has 3 arguments
                    args_count = 3
                else:
                    # It's a function we didn't analyze
                    raise RuntimeError("Unknown function parameters")
            else:
                # It's a dynamic call !
                raise RuntimeError("Dynamic destination ?")
            # Arguments are taken from stack
            args = []
            for i in range(args_count):
                args.append(ExprMem(self.sp + ExprInt(i * 4, 32), 32))
            # Generate the model
            call_assignblk = AssignBlock(
                [
                    ExprAssign(self.ret_reg, ExprOp('call_func_ret', addr, *args)),
                    ExprAssign(self.sp, self.sp + ExprInt(args_count * 4, self.sp.size))
                ],
                instr
            )
            return [call_assignblk], []

graph_ir_x86("""
main:
    MOV  EBX, 0x1234
    PUSH 3
    PUSH 2
    PUSH 1
    CALL 0x11223344
    MOV  ECX, EAX
    RET
""", lifter_custom=LifterFixCallStack)
Given the above code, generate some markdown instructions for it.
assistant
#Here is the Python program you requested.

What happened here?
The translation of the call is replaced by two side effects which occur in parallel:
- EAX is set to the result of the operator call_func_ret which has two arguments: loc_11223344 and ESP
- ESP is set to the result of the operator call_func_stack which has two arguments: loc_11223344 and ESP
The first one is there to model the assignment in 'classic' x86 code of the return value. The second one is there to model a possible change of the stack pointer depending on the function called, that the old stack pointer.
Everything here can be subclassed in order to customize the translation behavior.
Subfunction call custom modeling
The code responsible of the modelisation of function calls is located in the LifterModelCall class (the lifter with call modeling) in miasm/ir/analysis.py:
```python
...
    def call_effects(self, addr, instr):
        """Default modelisation of a function call to @addr. This may be used to:
    * insert dependencies to arguments (stack base, registers, ...)
    * add some side effects (stack clean, return value, ...)

    Return a couple:
    * list of assignments to add to the current irblock
    * list of additional irblocks

    @addr: (Expr) address of the called function
    @instr: native instruction which is responsible of the call
    """

    call_assignblk = AssignBlock(
        [
            ExprAssign(self.ret_reg, ExprOp('call_func_ret', addr, self.sp)),
            ExprAssign(self.sp, ExprOp('call_func_stack', addr, self.sp))
        ],
        instr
    )
    return [call_assignblk], []

```
Some architectures subclass it to include some architecture dependent stuffs, for example in miasm/arch/x86/lifter_model_call.py in which we use a default calling convention linked to arguments passed through registers:
```python
...
    def call_effects(self, ad, instr):
        call_assignblk = AssignBlock(
            [
                ExprAssign(
                    self.ret_reg,
                    ExprOp(
                        'call_func_ret',
               ...