void sub_120()
{
    Block0();
    Block1();
    Block2();
    Block3();
    do
    {
        Block4();
    }
    while(Block5())
    Block6();
    Block7();
    Block8();
    while(Block9());
    Block10();
    Block11();
    do
    {
        if(Block12())
        {
            Block15();
        }
        else
        {
            if(!Block13())
            {
                Block14();
            }
        }
        while(Block16());
        Block17();
    }
    while(Block18())
    Block19();
    Block20();
    Block21();
    Block22();
    Block23();
    while(Block24());
    Block25();
}

void Block0()
{
    _asm
    {
        mfspr     r12, LR                       #(mfspr) Copies the contents of a special-purpose register into a general-purpose register.
        std       r12, -8(r1)
        std       response, -0x10(r1)
        std       r30, -0x18(r1)
        std       r29, -0x20(r1)
        std       r28, -0x28(r1)
        std       r27, -0x30(r1)
        std       r26, -0x38(r1)
        std       r25, -0x40(r1)
        stdu      r1, -0xF0(r1)
        addi      response, r3, 0x20            #increment the contents of r3 by 0x20 then store the result back into r31(response)
        ld        r12, 0(r0)                    #read from 0x0 in HV & Load a double-word of data into the specified general purpose register.
        std       r12, 8(response)              #store HV 8 byte header at response + 0x28 = wHvMagic
        ld        r12, 0x10(r0)                 #read from 0x10 in HV & Load a double-word of data into the specified general purpose register.
        std       r12, 0x10(response)           #store BaseKernel+UpdateType at 0x30 = wHvVersion
        lwz       r12, dword_30                 #read from 0x30 in HV & Loads a word of data from a specified location in memory into a general-purpose register
        stw       r12, 0x18(response)           #response + 0x38 = dwBaseKernelVersion
        lwz       r12, dword_74                 #read from 0x74 in HV & Loads a word of data from a specified location in memory into a general-purpose register
        stw       r12, 0x1C(response)           #response + 0x3C = dwUpdateSequence
        std       r2, 0x20(response)            #store RTOC @ response + 0x40 (RTOC = 0x00000002000000000 = qwRTOC
        mfspr     r12, HRMOR                    #0x0000010000000000 (mfspr) Copies the contents of a special-purpose register into a general-purpose register.
        std       r12, 0x28(response)           #response + 0x48 = qwHRMOR
        lwz       r12, dword_4C                 #read from 0x4C in HV Loads a word of data from a specified location in memory into a general-purpose register
        add       r30, r2, r12                  #increments the contents of r2 by the contents of r12 storing the result back into r30
        lwz       r12, 8(r30)                   #Loads a word of data from a specified location in memory into a general-purpose register
        mtspr     CTR, r12                      #(mtspr) Copies the contents of a general-purpose register into a special-purpose register.
        mr        r3, r4                        #The mr subcommand modifies general purpose, segment, special, or floating point registers.
        li        r4, 0x1000                    #load immediate (take this constant value known at compile time and store it in this register)
        bctrl
    }
}

void Block1()
{
    _asm
    {
        mr        r25, r3                       #The mr subcommand modifies general purpose, segment, special, or floating point registers.
        lwz       r28, 0xD4(r30)                #Loads a word of data from a specified location in memory into a general-purpose register
        lwz       r29, 0xD8(r30)                #Loads a word of data from a specified location in memory into a general-purpose register
        lwz       r30, 0xD0(r30)                #Loads a word of data from a specified location in memory into a general-purpose register
        bl        XeCryptShaInit                #Branch (to call a function)
    }
}

void Block2()
{
    _asm
    {
        li        r5, 0x10                      #load immediate (take this constant value known at compile time and store it in this register)
        mr        r4, r25                       #The mr subcommand modifies general purpose, segment, special, or floating point registers.
        bl        XeCryptShaUpdate              #Branch (to call a function) & first hash HV salt
    }
}

void Block3()
{
    _asm
    {
        li        r26, 7                        #load immediate (take this constant value known at compile time and store it in this register)
        addi      r27, response, 0x388          #increment the contents of r31 by 0x388 then store the result back into r27
    }
}

void Block4()
{
    _asm
    {
        loc_1BC
        ldu       r6, 8(r27)                    #start reading from offset at 0x3B0 & Load a double-word of data into the specified general purpose register, updating the address base.
        andi.     r5, r6, 0xFFF                 #(create length) & Logically ANDs the contents of a general-purpose register with an immediate value.
        srdi      r4, r6, 16                    #(create offset) & Rotate double word right immediate
        bl        XeCryptShaUpdate              #Branch (to call a function)
    }
}

void Block5()
{
    _asm
    {
        addic.    r26, r26, -1                  #Performs an addition with carry of the contents of a general-purpose register and an immediate value.
        bne       loc_1BC
    }
}

void Block6()
{
    _asm
    {
        addi      r4, response, 0xCC            #(store at response + 0xEC) increment the contents of r31 by 0xCC then store the result back into r4
        bl        XeCryptShaFinal               #Branch (to call a function)
    }
}

void Block7()
{
    _asm
    {
        bl        XeCryptShaInit                #Branch (to call a function)
    }
}

void Block8()
{
    _asm
    {
        li        r5, 8                         #load immediate (take this constant value known at compile time and store it in this register)
        mtspr     CTR, r5                       #(mtspr) Copies the contents of a general-purpose register into a special-purpose register.
        addi      r26, response, 0x3E0          #increment the contents of r31 by 0x3E0 then store the result back into r26
        extrdi    r12, r26, 16,32               #Extract double word and right justify immediate
        sth       r12, 0xD8(response)           #Stores a halfword of data from a general-purpose register into a specified location in memory.
        addi      r4, r26, -8                   #increment the contents of r26 by -8 then store the result back into r4
    }
}

void Block9()
{
    _asm
    {
        loc_1F8
        ld        r12, 0(r25)                   #Load a double-word of data into the specified general purpose register.
        stdu      r12, 8(r4)                    #Store a double-word of data from a general purpose register into a specified memory location. Update the address base.
        ld        r12, 8(r25)                   #Load a double-word of data into the specified general purpose register.
        stdu      r12, 8(r4)                    #Store a double-word of data from a general purpose register into a specified memory location. Update the address base.
        bdnz+     loc_1F8
    }
}

void Block10()
{
    _asm
    {
        dcbst     r0, r26                       #Allows a program to copy the contents of a modified block to main memory.
        sync
        li        r25, 0x200                    #load immediate (take this constant value known at compile time and store it in this register)
        oris      r25, r25, 0x8000              #Logically ORs the upper 16 bits of the contents of a general-purpose register with a 16-bit unsigned integer and stores the result in another general-purpose register.
        sldi      r25, r25, 32                  #Shift left double word immediate
        oris      r25, r25, 1                   #Logically ORs the upper 16 bits of the contents of a general-purpose register with a 16-bit unsigned integer and stores the result in another general-purpose register.
        extrdi    r4, r26, 10,48                #Extract double word and right justify immediate
        ori       r4, r4, 0xF800                #Logically ORs the lower 16 bits of the contents of a general-purpose register with a 16-bit unsigned integer and stores the result in another general-purpose register.
        li        r5, 2                         #load immediate (take this constant value known at compile time and store it in this register)
        add       r4, r25, r4                   #increments the contents of r25 by the contents of r4 storing the result back into r4
        bl        XeCryptShaUpdate              #Branch (to call a function)
    }
}

void Block11()
{
    _asm
    {
        li        r26, 0xD                      #load immediate (take this constant value known at compile time and store it in this register)
        addi      r27, response, 0x320          #increment the contents of r31 by 0x320 then store the result back into r27
    }
}

void Block12()
{
    _asm
    {
        loc_240
        ldu       r6, 8(r27)                    #start reading from offset at 0x348 & Load a double-word of data into the specified general purpose register, updating the address base.
        andi.     r12, r6, 0x8000               #Logically ANDs the contents of a general-purpose register with an immediate value.
        bne       loc_278
    }
}

void Block13()
{
    _asm
    {
        li        r3, 1                         #load immediate (take this constant value known at compile time and store it in this register)
        mtspr     CTR, r3                       #(mtspr) Copies the contents of a general-purpose register into a special-purpose register.
        srdi      r3, r6, 16                    #Rotate double word right immediate
        mr        r4, r3                        #The mr subcommand modifies general purpose, segment, special, or floating point registers.
        andi.     r5, r6, 0x7F                  #Logically ANDs the contents of a general-purpose register with an immediate value.
        cmplwi    r5, 0x10                      #Compare Logical Word Immediate
        blt       loc_290
    }
}

void Block14()
{
    _asm
    {
        clrldi    r4, r4, 46                    #Clear left double word immediate
        li        r12, 1                        #load immediate (take this constant value known at compile time and store it in this register)
        insrdi    r4, r12, 1,0                  #Insert double word from right immediate
        b         loc_290
    }
}

void Block15()
{
    _asm
    {
        loc_278
        andi.     r5, r6, 0x3FF                 #Logically ANDs the contents of a general-purpose register with an immediate value.
        mtspr     CTR, r5                       #(mtspr) Copies the contents of a general-purpose register into a special-purpose register.
        srdi      r3, r6, 16                    #Rotate double word right immediate
        extrdi    r12, r3, 12,46                #Extract double word and right justify immediate
        add       r4, r25, r12                  #increments the contents of r25 by the contents of r12 storing the result back into r4
        sldi      r5, r5, 1                     #Shift left double word immediate
    }
}

void Block16()
{
    _asm
    {
        loc_290
        lbz       r12, 0(r3)                    #Loads a byte of data from a specified location in memory into a general-purpose register and sets the remaining 24 bits to 0.
        stb       r12, 0(r3)                    #Stores a byte of data from a general-purpose register into a specified location in memory.
        dcbst     r0, r3                        #Allows a program to copy the contents of a modified block to main memory.
        addi      r3, r3, 0x80                  #increment the contents of r3 by 0x80 then store the result back into r3
        bdnz+     loc_290
    }
}

void Block17()
{
    _asm
    {
        sync
        bl        XeCryptShaUpdate              #Branch (to call a function)
    }
}

void Block18()
{
    _asm
    {
        addic.    r26, r26, -1                  #Performs an addition with carry of the contents of a general-purpose register and an immediate value.
        bne       loc_240
    }
}

void Block19()
{
    _asm
    {
        addi      r4, response, 0x30            #(store at response + 0x50) increment the contents of r31 by 0x30 then store the result back into r4
        bl        XeCryptShaFinal               #Branch (to call a function)
    }
}

void Block20()
{
    _asm
    {
        bl        XeCryptShaInit                #Branch (to call a function)
    }
}

void Block21()
{
    _asm
    {
        li        r5, 0x10                      #load immediate (take this constant value known at compile time and store it in this register)
        li        r4, 0x20                      #' '                                    #Get The CPUKey off the HV
        bl        XeCryptShaUpdate              #Branch (to call a function)
    }
}

void Block22()
{
    _asm
    {
        addi      r4, response, 0x44            #(hash CPU key at response + 0x64) increment the contents of r31 by 0x44 then store the result back into r4
        bl        XeCryptShaFinal               #Branch (to call a function)
    }
}

void Block23()
{
    _asm
    {
        li        r5, 0x10                      #load immediate (take this constant value known at compile time and store it in this register)
        mtspr     CTR, r5                       #(mtspr) Copies the contents of a general-purpose register into a special-purpose register.
        addi      r4, response, 0x50            #(reading from response at 0x78) increment the contents of r31 by 0x50 then store the result back into r4
        lis       r3, 1                         #Load Immediate Shifted
        insrdi    r3, r3, 47,0                  #Insert double word from right immediate
        ori       r3, r3, 0x38                  #Logically ORs the lower 16 bits of the contents of a general-purpose register with a 16-bit unsigned integer and stores the result in another general-purpose register.
    }
}

void Block24()
{
    _asm
    {
        loc_2EC
        ldu       r12, 8(r3)                    #0000000200010040 (0x10040 in HV space) & Load a double-word of data into the specified general purpose register, updating the address base.
        stdu      r12, 8(r4)                    #Store a double-word of data from a general purpose register into a specified memory location. Update the address base.
        bdnz      loc_2EC                       #copy 0x74 bytes of data into response + 0x78
    }
}

void Block25()
{
    _asm
    {
        addi      r1, r1, 0xF0                  #increment the contents of r1 by 0xF0 then store the result back into r1
        ld        r12, -8(r1)                   #Load a double-word of data into the specified general purpose register.
        mtspr     LR, r12                       #(mtspr) Copies the contents of a general-purpose register into a special-purpose register.
        ld        r25, -0x40(r1)                #Load a double-word of data into the specified general purpose register.
        ld        r26, -0x38(r1)                #Load a double-word of data into the specified general purpose register.
        ld        r27, -0x30(r1)                #Load a double-word of data into the specified general purpose register.
        ld        r28, -0x28(r1)                #Load a double-word of data into the specified general purpose register.
        ld        r29, -0x20(r1)                #Load a double-word of data into the specified general purpose register.
        ld        r30, -0x18(r1)                #Load a double-word of data into the specified general purpose register.
        ld        response, -0x10(r1)           #Load a double-word of data into the specified general purpose register.
        li        r3, 0                         #load immediate (take this constant value known at compile time and store it in this register)
        blr
    }
}