user: Demonstrate the C code that generates the assembly output below:

```asm
<LzmaDecode>:
  endbr64
  push   %r15
  mov    %esi,%r10d
  mov    %ecx,%esi
  add    %edx,%ecx
  push   %r14
  mov    $0x2,%r11d
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %edx,-0x28(%rsp)
  mov    $0x300,%edx
  shl    %cl,%edx
  mov    %rdi,-0x38(%rsp)
  lea    0x736(%rdx),%eax
  mov    %rax,%rcx
  add    %rax,%rax
  cmp    %rax,%r10
  jb     L9
  test   %ecx,%ecx
  je     L519
  mov    -0x38(%rsp),%rdi
  add    $0x735,%edx
  mov    %rdi,%rax
  lea    0x2(%rdi,%rdx,2),%rdx
  nopw   0x0(%rax,%rax,1)
L172:
  mov    $0x400,%ecx
  add    $0x2,%rax
  mov    %cx,-0x2(%rax)
  cmp    %rax,%rdx
  jne    L172
L519:
  mov    0x38(%rsp),%edi
  lea    0x5(%r9),%rcx
  xor    %edx,%edx
  add    %r9,%rdi
L865:
  cmp    %r9,%rdi
  je     L37
  movzbl (%r9),%eax
  shl    $0x8,%edx
  add    $0x1,%r9
  or     %eax,%edx
  cmp    %rcx,%r9
  jne    L865
  mov    0x50(%rsp),%rax
  movl   $0x0,(%rax)
  mov    0x48(%rsp),%eax
  test   %eax,%eax
  je     L397
  mov    $0x1,%eax
  mov    %r8d,%ecx
  movl   $0x1,-0xc(%rsp)
  xor    %r10d,%r10d
  mov    %eax,%ebx
  movl   $0x1,-0x1c(%rsp)
  xor    %r12d,%r12d
  xor    %r11d,%r11d
  shl    %cl,%ebx
  mov    %esi,%ecx
  movl   $0x1,-0x20(%rsp)
  mov    $0x800,%r8d
  shl    %cl,%eax
  lea    -0x1(%rbx),%ebx
  movl   $0x1,-0x24(%rsp)
  mov    $0xffffffff,%ecx
  sub    $0x1,%eax
  mov    %ebx,-0x18(%rsp)
  mov    %eax,-0x14(%rsp)
  mov    -0x38(%rsp),%rax
  movl   $0x0,-0x30(%rsp)
  mov    %rax,%rbx
  add    $0x644,%rax
  movl   $0x0,-0x2c(%rsp)
  mov    %rax,-0x8(%rsp)
  mov    $0x8,%eax
  sub    -0x28(%rsp),%eax
  mov    %eax,-0x10(%rsp)
L561:
  movzwl (%rbx),%ebp
  mov    %ecx,%eax
  shr    $0xb,%eax
  imul   %ebp,%eax
  mov    %ebp,%esi
  cmp    %eax,%edx
  jae    L242
  mov    %r8d,%ecx
  mov    -0x14(%rsp),%esi
  sub    %ebp,%ecx
  sar    $0x5,%ecx
  add    %ebp,%ecx
  mov    %cx,(%rbx)
  mov    -0x2c(%rsp),%ebx
  movzbl -0x28(%rsp),%ecx
  and    %ebx,%esi
  shl    %cl,%esi
  movzbl -0x10(%rsp),%ecx
  sar    %cl,%r10d
  lea    (%rsi,%r10,1),%ecx
  mov    -0x38(%rsp),%rsi
  lea    (%rcx,%rcx,2),%ecx
  shl    $0x8,%ecx
  cmpl   $0x6,-0x30(%rsp)
  lea    0xe6c(%rsi,%rcx,2),%r12
  jle    L10
  mov    %ebx,%ecx
  mov    0x40(%rsp),%rbx
  sub    -0x24(%rsp),%ecx
  movzbl (%rbx,%rcx,1),%r11d
  mov    $0x1,%ecx
  jmp    L689
  nopw   0x0(%rax,%rax,1)
L61:
  mov    %r8d,%eax
  add    %ecx,%ecx
  sub    %r13d,%eax
  sar    $0x5,%eax
  add    %r13d,%eax
  mov    %ax,0x0(%rbp)
  mov    %esi,%eax
  test   %ebx,%ebx
  jne    L597
L594:
  cmp    $0xff,%ecx
  jg     L186
L689:
  add    %r11d,%r11d
  movslq %ecx,%r10
  mov    %r11d,%ebx
  and    $0x100,%ebx
  lea    0x100(%rbx),%esi
  movslq %esi,%rsi
  add    %r10,%rsi
  lea    (%r12,%rsi,2),%rbp
  cmp    $0xffffff,%eax
  ja     L675
  cmp    %rdi,%r9
  je     L37
  movzbl (%r9),%esi
  shl    $0x8,%edx
  shl    $0x8,%eax
  add    $0x1,%r9
  or     %esi,%edx
L675:
  movzwl 0x0(%rbp),%r13d
  mov    %eax,%esi
  shr    $0xb,%esi
  imul   %r13d,%esi
  mov    %r13d,%r10d
  cmp    %esi,%edx
  jb     L61
  sub    %esi,%eax
  sub    %esi,%edx
  lea    0x1(%rcx,%rcx,1),%ecx
  mov    %r13d,%esi
  shr    $0x5,%si
  sub    %esi,%r10d
  mov    %r10w,0x0(%rbp)
  test   %ebx,%ebx
  jne    L594
L597:
  cmp    $0xff,%ecx
  jle    L103
  nop
L186:
  mov    -0x2c(%rsp),%esi
  mov    0x40(%rsp),%r15
  movzbl %cl,%r10d
  mov    %rsi,%rbx
  mov    %cl,(%r15,%rsi,1)
  mov    %r9,%rsi
  add    $0x1,%ebx
  mov    %ebx,-0x2c(%rsp)
L91:
  mov    -0x30(%rsp),%ebx
  lea    -0x3(%rbx),%ecx
  lea    -0x6(%rbx),%r9d
  cmp    $0x9,%ebx
  cmovg  %r9d,%ecx
  mov    %ecx,-0x30(%rsp)
  jmp    L927
  nopl   0x0(%rax)
L242:
  sub    %eax,%ecx
  sub    %eax,%edx
  mov    %ebp,%eax
  shr    $0x5,%ax
  sub    %eax,%esi
  movslq -0x30(%rsp),%rax
  mov    %si,(%rbx)
  lea    0x180(%rax,%rax,1),%rsi
  mov    -0x38(%rsp),%rax
  lea    (%rax,%rsi,1),%rbx
  cmp    $0xffffff,%ecx
  jbe    L582
L217:
  movzwl (%rbx),%ebp
  mov    %ecx,%r10d
  shr    $0xb,%r10d
  imul   %ebp,%r10d
  mov    %ebp,%eax
  cmp    %r10d,%edx
  jb     L665
  sub    %r10d,%ecx
  sub    %r10d,%edx
  mov    %ebp,%r10d
  shr    $0x5,%r10w
  sub    %r10d,%eax
  mov    %ax,(%rbx)
  mov    -0x38(%rsp),%rax
  lea    0x18(%rax,%rsi,1),%rbx
  cmp    $0xffffff,%ecx
  jbe    L895
L820:
  movzwl (%rbx),%ebp
  mov    %ecx,%r10d
  shr    $0xb,%r10d
  imul   %ebp,%r10d
  mov    %ebp,%eax
  cmp    %r10d,%edx
  jae    L915
  mov    %r8d,%ecx
  mov    -0x38(%rsp),%rax
  sub    %ebp,%ecx
  sar    $0x5,%ecx
  lea    0x1e0(%rax,%r11,2),%rsi
  add    %ebp,%ecx
  mov    %cx,(%rbx)
  cmp    $0xffffff,%r10d
  ja     L566
  cmp    %rdi,%r9
  je     L37
  movzbl (%r9),%eax
  shl    $0x8,%edx
  shl    $0x8,%r10d
  add    $0x1,%r9
  or     %eax,%edx
L566:
  movzwl (%rsi),%r11d
  mov    %r10d,%eax
  shr    $0xb,%eax
  imul   %r11d,%eax
  mov    %r11d,%ecx
  cmp    %eax,%edx
  jae    L213
  mov    %r8d,%r10d
  mov    -0x2c(%rsp),%ebx
  sub    %r11d,%r10d
  sar    $0x5,%r10d
  add    %r10d,%ecx
  mov    %cx,(%rsi)
  test   %ebx,%ebx
  jne    L153
  nopl   0x0(%rax,%rax,1)
L37:
  mov    $0x1,%r11d
L9:
  pop    %rbx
  mov    %r11d,%eax
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L582:
  cmp    %rdi,%r9
  je     L37
  movzbl (%r9),%eax
  shl    $0x8,%edx
  shl    $0x8,%ecx
  add    $0x1,%r9
  or     %eax,%edx
  jmp    L217
  nopw   0x0(%rax,%rax,1)
L10:
  mov    $0x1,%ecx
  jmp    L103
  nop
L749:
  mov    %r8d,%eax
  add    %ecx,%ecx
  sub    %ebx,%eax
  sar    $0x5,%eax
  add    %eax,%r10d
  mov    %esi,%eax
  mov    %r10w,(%r11)
  cmp    $0xff,%ecx
  jg     L666
L103:
  movslq %ecx,%rsi
  lea    (%r12,%rsi,2),%r11
  cmp    $0xffffff,%eax
  ja     L35
  cmp    %rdi,%r9
  je     L37
  movzbl (%r9),%esi
  shl    $0x8,%edx
  shl    $0x8,%eax
  add    $0x1,%r9
  or     %esi,%edx
L35:
  movzwl (%r11),%ebx
  mov    %eax,%esi
  shr    $0xb,%esi
  imul   %ebx,%esi
  mov    %ebx,%r10d
  cmp    %esi,%edx
  jb     L749
  sub    %esi,%eax
  sub    %esi,%edx
  lea    0x1(%rcx,%rcx,1),%ecx
  mov    %ebx,%esi
  shr    $0x5,%si
  sub    %esi,%r10d
  mov    %r10w,(%r11)
  cmp    $0xff,%ecx
  jle    L103
L666:
  mov    -0x2c(%rsp),%esi
  mov    0x40(%rsp),%rbx
  movzbl %cl,%r10d
  cmpl   $0x3,-0x30(%rsp)
  lea    0x1(%rsi),%r11d
  mov    %cl,(%rbx,%rsi,1)
  mov    %r9,%rsi
  mov    %r11d,-0x2c(%rsp)
  jg     L91
  movl   $0x0,-0x30(%rsp)
  jmp    L927
  nopw   0x0(%rax,%rax,1)
L665:
  mov    %r8d,%ecx
  xor    %eax,%eax
  mov    %r9,%rsi
  sub    %ebp,%ecx
  sar    $0x5,%ecx
  add    %ebp,%ecx
  cmpl   $0x7,-0x30(%rsp)
  setge  %al
  mov    %cx,(%rbx)
  lea    (%rax,%rax,2),%eax
  mov    %eax,-0x30(%rsp)
  mov    -0x38(%rsp),%rax
  lea    0x664(%rax),%r14
  mov    -0x1c(%rsp),%eax
  mov    %eax,-0xc(%rsp)
  mov    -0x20(%rsp),%eax
  mov    %eax,-0x1c(%rsp)
  mov    -0x24(%rsp),%eax
  mov    %eax,-0x20(%rsp)
L167:
  cmp    $0xffffff,%r10d
  ja     L744
  cmp    %rdi,%r9
  je     L37
  movzbl (%r9),%eax
  shl    $0x8,%edx
  shl    $0x8,%r10d
  lea    0x1(%r9),%rsi
  or     %eax,%edx
L744:
  movzwl (%r14),%r9d
  mov    %r10d,%eax
  shr    $0xb,%eax
  imul   %r9d,%eax
  mov    %r9d,%ecx
  cmp    %eax,%edx
  jb     L843
  sub    %eax,%r10d
  sub    %eax,%edx
  mov    %r9d,%eax
  shr    $0x5,%ax
  sub    %eax,%ecx
  mov    %cx,(%r14)
  cmp    $0xffffff,%r10d
  ja     L646
  cmp    %rdi,%rsi
  je     L37
  movzbl (%rsi),%eax
  shl    $0x8,%edx
  shl    $0x8,%r10d
  add    $0x1,%rsi
  or     %eax,%edx
L646:
  movzwl 0x2(%r14),%r9d
  mov    %r10d,%eax
  shr    $0xb,%eax
  imul   %r9d,%eax
  mov    %r9d,%ecx
  cmp    %eax,%edx
  jae    L406
  mov    %r8d,%r10d
  shl    $0x3,%r12d
  mov    $0x8,%r13d
  mov    $0x3,%ecx
  sub    %r9d,%r10d
  movslq %r12d,%r12
  sar    $0x5,%r10d
  add    %r9d,%r10d
  mov    %r10w,0x2(%r14)
  lea    0x104(%r14,%r12,2),%r14
L626:
  mov    %ecx,%ebp
  mov    $0x1,%ebx
  jmp    L835
  nopl   0x0(%rax)
L260:
  mov    %r8d,%eax
  add    %ebx,%ebx
  sub    %r12d,%eax
  sar    $0x5,%eax
  add    %eax,%r10d
  mov    %r9d,%eax
  mov    %r10w,(%r11)
  sub    $0x1,%ebp
  je     L429
L835:
  movslq %ebx,%r9
  lea    (%r14,%r9,2),%r11
  cmp    $0xffffff,%eax
  ja     L708
  cmp    %rdi,%rsi
  je     L37
  movzbl (%rsi),%r9d
  shl    $0x8,%edx
  shl    $0x8,%eax
  add    $0x1,%rsi
  or     %r9d,%edx
L708:
  movzwl (%r11),%r12d
  mov    %eax,%r9d
  shr    $0xb,%r9d
  imul   %r12d,%r9d
  mov    %r12d,%r10d
  cmp    %r9d,%edx
  jb     L260
  sub    %r9d,%eax
  sub    %r9d,%edx
  lea    0x1(%rbx,%rbx,1),%ebx
  mov    %r12d,%r9d
  shr    $0x5,%r9w
  sub    %r9d,%r10d
  mov    %r10w,(%r11)
  sub    $0x1,%ebp
  jne    L835
L429:
  mov    $0x1,%r15d
  shl    %cl,%r15d
  sub    %r15d,%ebx
  add    %ebx,%r13d
  cmpl   $0x3,-0x30(%rsp)
  jg     L63
  mov    $0x3,%ecx
  mov    -0x38(%rsp),%r11
  mov    $0x6,%ebx
  mov    $0x1,%r10d
  cmp    %ecx,%r13d
  cmovle %r13d,%ecx
  mov    %ecx,%r12d
  shl    $0x6,%r12d
  movslq %r12d,%r12
  add    $0x1b0,%r12
  jmp    L425
L365:
  mov    %r8d,%eax
  add    %r10d,%r10d
  sub    %r14d,%eax
  sar    $0x5,%eax
  add    %eax,%ecx
  mov    %r9d,%eax
  mov    %cx,0x0(%rbp)
  sub    $0x1,%ebx
  je     L945
L425:
  movslq %r10d,%rcx
  add    %r12,%rcx
  lea    (%r11,%rcx,2),%rbp
  cmp    $0xffffff,%eax
  ja     L432
  cmp    %rdi,%rsi
  je     L37
  movzbl (%rsi),%ecx
  shl    $0x8,%edx
  shl    $0x8,%eax
  add    $0x1,%rsi
  or     %ecx,%edx
L432:
  movzwl 0x0(%rbp),%r14d
  mov    %eax,%r9d
  shr    $0xb,%r9d
  imul   %r14d,%r9d
  mov    %r14d,%ecx
  cmp    %r9d,%edx
  jb     L365
  sub    %r9d,%eax
  sub    %r9d,%edx
  lea    0x1(%r10,%r10,1),%r10d
  mov    %r14d,%r9d
  shr    $0x5,%r9w
  sub    %r9d,%ecx
  mov    %cx,0x0(%rbp)
  sub    $0x1,%ebx
  jne    L425
L945:
  sub    $0x40,%r10d
  mov    %r10d,%r14d
  cmp    $0x3,%r10d
  jle    L468
  mov    %r10d,%r9d
  mov    %r10d,%ecx
  and    $0x1,%r9d
  sar    %ecx
  or     $0x2,%r9d
  cmp    $0xd,%r10d
  jg     L755
  mov    %r9d,%r14d
  sub    $0x1,%ecx
  movslq %r10d,%r10
  mov    $0x2b0,%r9d
  shl    %cl,%r14d
  sub    %r10,%r9
  mov    -0x38(%rsp),%rbx
  mov    %r14d,%r10d
  add    %r10,%r9
  lea    -0x2(%rbx,%r9,2),%r15
L684:
  mov    $0x1,%ebx
  mov    $0x1,%r12d
  jmp    L488
  nopw   0x0(%rax,%rax,1)
L599:
  mov    %r8d,%eax
  add    %ebx,%ebx
  sub    %ebp,%eax
  sar    $0x5,%eax
  add    %eax,%r9d
  mov    %r10d,%eax
L359:
  mov    %r9w,(%r11)
  add    %r12d,%r12d
  sub    $0x1,%ecx
  je     L468
L488:
  movslq %ebx,%r9
  lea    (%r15,%r9,2),%r11
  cmp    $0xffffff,%eax
  ja     L256
  cmp    %rdi,%rsi
  je     L37
  movzbl (%rsi),%r9d
  shl    $0x8,%edx
  shl    $0x8,%eax
  add    $0x1,%rsi
  or     %r9d,%edx
L256:
  movzwl (%r11),%ebp
  mov    %eax,%r10d
  shr    $0xb,%r10d
  imul   %ebp,%r10d
  mov    %ebp,%r9d
  cmp    %r10d,%edx
  jb     L599
  sub    %r10d,%eax
  sub    %r10d,%edx
  mov    %ebp,%r10d
  or     %r12d,%r14d
  shr    $0x5,%r10w
  lea    0x1(%rbx,%rbx,1),%ebx
  sub    %r10d,%r9d
  jmp    L359
  nopl   (%rax)
L468:
  add    $0x1,%r14d
  mov    %r14d,-0x24(%rsp)
  je     L88
  addl   $0x7,-0x30(%rsp)
L63:
  mov    -0x24(%rsp),%r15d
  mov    -0x2c(%rsp),%ebx
  lea    0x2(%r13),%r9d
  cmp    %ebx,%r15d
  ja     L37
  mov    %ebx,%ecx
  mov    0x40(%rsp),%rbp
  lea    0x2(%rbx,%r13,1),%ebx
  mov    0x48(%rsp),%r12d
  sub    %r15d,%ebx
  cs nopw 0x0(%rax,%rax,1)
L302:
  mov    %ebx,%r10d
  mov    %ecx,%r11d
  add    $0x1,%ecx
  sub    %r9d,%r10d
  movzbl 0x0(%rbp,%r10,1),%r10d
  mov    %r10b,0x0(%rbp,%r11,1)
  sub    $0x1,%r9d
  je     L415
  cmp    %ecx,%r12d
  ja     L302
L415:
  mov    %ecx,-0x2c(%rsp)
L927:
  mov    -0x2c(%rsp),%ebx
  cmp    0x48(%rsp),%ebx
  jae    L88
  mov    -0x30(%rsp),%r11d
  mov    -0x2c(%rsp),%r12d
  and    -0x18(%rsp),%r12d
  mov    -0x38(%rsp),%rbx
  shl    $0x4,%r11d
  movslq %r12d,%rcx
  movslq %r11d,%r11
  add    %rcx,%r11
  lea    (%rbx,%r11,2),%rbx
  cmp    $0xffffff,%eax
  ja     L160
  cmp    %rdi,%rsi
  je     L37
  shl    $0x8,%eax
  shl    $0x8,%edx
  lea    0x1(%rsi),%r9
  mov    %eax,%ecx
  movzbl (%rsi),%eax
  or     %eax,%edx
  jmp    L561
  nopl   0x0(%rax,%rax,1)
L406:
  shr    $0x5,%r9w
  sub    %eax,%r10d
  sub    %eax,%edx
  mov    $0x10,%r13d
  sub    %r9d,%ecx
  add    $0x204,%r14
  mov    %r10d,%eax
  mov    %cx,-0x202(%r14)
  mov    $0x8,%ecx
  jmp    L626
  nopw   0x0(%rax,%rax,1)
L895:
  cmp    %rdi,%r9
  je     L37
  movzbl (%r9),%eax
  shl    $0x8,%edx
  shl    $0x8,%ecx
  add    $0x1,%r9
  or     %eax,%edx
  jmp    L820
  xchg   %ax,%ax
L915:
  sub    %r10d,%ecx
  sub    %r10d,%edx
  mov    %ebp,%r10d
  shr    $0x5,%r10w
  sub    %r10d,%eax
  mov    %ax,(%rbx)
  mov    -0x38(%rsp),%rax
  lea    0x30(%rax,%rsi,1),%r11
  cmp    $0xffffff,%ecx
  ja     L180
  cmp    %rdi,%r9
  je     L37
  movzbl (%r9),%eax
  shl    $0x8,%edx
  shl    $0x8,%ecx
  add    $0x1,%r9
  or     %eax,%edx
L180:
  movzwl (%r11),%ebx
  mov    %ecx,%r10d
  shr    $0xb,%r10d
  imul   %ebx,%r10d
  mov    %ebx,%eax
  cmp    %r10d,%edx
  jae    L394
  mov    %r8d,%ecx
  mov    %r9,%rsi
  sub    %ebx,%ecx
  mov    -0x20(%rsp),%ebx
  sar    $0x5,%ecx
  add    %ecx,%eax
  mov    %ax,(%r11)
  mov    -0x24(%rsp),%eax
  mov    %ebx,-0x24(%rsp)
  mov    %eax,-0x20(%rsp)
L190:
  xor    %eax,%eax
  cmpl   $0x7,-0x30(%rsp)
  setge  %al
  lea    0x8(%rax,%rax,2),%eax
  mov    %eax,-0x30(%rsp)
  mov    -0x38(%rsp),%rax
  lea    0xa68(%rax),%r14
  jmp    L167
  nopl   0x0(%rax)
L843:
  mov    %r8d,%r10d
  shl    $0x3,%r12d
  xor    %r13d,%r13d
  mov    $0x3,%ecx
  sub    %r9d,%r10d
  movslq %r12d,%r12
  sar    $0x5,%r10d
  add    %r9d,%r10d
  mov    %r10w,(%r14)
  lea    0x4(%r14,%r12,2),%r14
  jmp    L626
  nopw   0x0(%rax,%rax,1)
L394:
  sub    %r10d,%ecx
  sub    %r10d,%edx
  mov    %ebx,%r10d
  shr    $0x5,%r10w
  sub    %r10d,%eax
  mov    %ax,(%r11)
  mov    -0x38(%rsp),%rax
  lea    0x48(%rax,%rsi,1),%r11
  cmp    $0xffffff,%ecx
  ja     L638
  cmp    %rdi,%r9
  je     L37
  movzbl (%r9),%eax
  shl    $0x8,%edx
  shl    $0x8,%ecx
  add    $0x1,%r9
  or     %eax,%edx
L638:
  movzwl (%r11),%r10d
  mov    %ecx,%eax
  shr    $0xb,%eax
  imul   %r10d,%eax
  mov    %r10d,%esi
  cmp    %eax,%edx
  jae    L290
  mov    %r8d,%ecx
  mov    -0x1c(%rsp),%ebx
  mov    %r9,%rsi
  sub    %r10d,%ecx
  sar    $0x5,%ecx
  add    %r10d,%ecx
  mov    %eax,%r10d
  mov    -0x24(%rsp),%eax
  mov    %ebx,-0x24(%rsp)
  mov    -0x20(%rsp),%ebx
  mov    %cx,(%r11)
  mov    %eax,-0x20(%rsp)
  mov    %ebx,-0x1c(%rsp)
  jmp    L190
  nopl   0x0(%rax,%rax,1)
L213:
  sub    %eax,%r10d
  sub    %eax,%edx
  mov    %r11d,%eax
  shr    $0x5,%ax
  sub    %eax,%ecx
  mov    %cx,(%rsi)
  mov    %r9,%rsi
  jmp    L190
L755:
  sub    $0x5,%ecx
  nopl   0x0(%rax)
L893:
  cmp    $0xffffff,%eax
  ja     L529
  cmp    %rdi,%rsi
  je     L37
  movzbl (%rsi),%r10d
  shl    $0x8,%edx
  shl    $0x8,%eax
  add    $0x1,%rsi
  or     %r10d,%edx
L529:
  shr    %eax
  add    %r9d,%r9d
  cmp    %eax,%edx
  jb     L501
  sub    %eax,%edx
  or     $0x1,%r9d
L501:
  sub    $0x1,%ecx
  jne    L893
  mov    %r9d,%r14d
  mov    -0x8(%rsp),%r15
  mov    $0x4,%ecx
  shl    $0x4,%r14d
  jmp    L684
L290:
  mov    -0xc(%rsp),%ebx
  sub    %eax,%ecx
  sub    %eax,%edx
  mov    %esi,%eax
  shr    $0x5,%ax
  mov    %ecx,%r10d
  sub    %eax,%esi
  mov    -0x24(%rsp),%eax
  mov    %ebx,-0x24(%rsp)
  mov    -0x1c(%rsp),%ebx
  mov    %si,(%r11)
  mov    %r9,%rsi
  mov    %ebx,-0xc(%rsp)
  mov    -0x20(%rsp),%ebx
  mov    %eax,-0x20(%rsp)
  mov    %ebx,-0x1c(%rsp)
  jmp    L190
L153:
  xor    %ecx,%ecx
  cmpl   $0x7,-0x30(%rsp)
  mov    0x40(%rsp),%rsi
  setge  %cl
  lea    0x9(%rcx,%rcx,1),%ecx
  mov    %ecx,-0x30(%rsp)
  mov    %ebx,%ecx
  sub    -0x24(%rsp),%ecx
  movzbl (%rsi,%rcx,1),%r10d
  mov    %ebx,%ecx
  add    $0x1,%ebx
  mov    %ebx,-0x2c(%rsp)
  mov    %r10b,(%rsi,%rcx,1)
  mov    %r9,%rsi
  jmp    L927
L160:
  mov    %eax,%ecx
  mov    %rsi,%r9
  jmp    L561
L88:
  cmp    %rdi,%rsi
  jne    L111
  cmp    $0xffffff,%eax
  jbe    L37
L111:
  mov    0x50(%rsp),%rax
  mov    -0x2c(%rsp),%edi
  xor    %r11d,%r11d
  mov    %edi,(%rax)
  jmp    L9
L397:
  movl   $0x0,-0x2c(%rsp)
  jmp    L111
```

assistant: ```c
int LzmaDecode(unsigned char *buffer, unsigned int bufferSize, int lc, int lp, int pb, unsigned char *inStream, unsigned int inSize, unsigned char *outStream, unsigned int outSize, unsigned int *outSizeProcessed) {
  unsigned int numProbs = (((((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) + (4 << 6)) + (1 << (14 >> 1)) - 14) + (1 << 4)) + (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) + (1 << 8))) + (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) + (1 << 8))) + ((unsigned int)768 << (lc + lp));
  unsigned short *p = (unsigned short *)buffer;
  unsigned int i;
  int state = 0;
  unsigned char previousByte = 0;
  unsigned int rep0 = 1, rep1 = 1, rep2 = 1, rep3 = 1;
  unsigned int nowPos = 0;
  unsigned int posStateMask = (1 << pb) - 1;
  unsigned int literalPosMask = (1 << lp) - 1;
  int len = 0;
  unsigned char *Buffer;
  unsigned char *BufferLim;
  unsigned int Range;
  unsigned int Code;
  if (bufferSize < numProbs * sizeof(unsigned short))
    return 2;
  for (i = 0; i < numProbs; i++)
    p[i] = (1 << 11) >> 1;
  Buffer = inStream;
  BufferLim = inStream + inSize;
  Code = 0;
  Range = 0xFFFFFFFF;
  {
    int i;
    for (i = 0; i < 5; i++) {
      {
        if (Buffer == BufferLim)
          return 1;
      };
      Code = (Code << 8) | (*Buffer++);
    }
  };
  *outSizeProcessed = 0;
  while (nowPos < outSize) {
    unsigned short *prob;
    unsigned int bound;
    int posState = (int)((nowPos)&posStateMask);
    prob = p + 0 + (state << 4) + posState;
    if (Range < ((unsigned int)1 << 24)) {
      {
        if (Buffer == BufferLim)
          return 1;
      };
      Range <<= 8;
      Code = (Code << 8) | (*Buffer++);
    };
    bound = (Range >> 11) * *(prob);
    if (Code < bound) {
      int symbol = 1;
      Range = bound;
      *(prob) += ((1 << 11) - *(prob)) >> 5;
      prob = p + (((((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) + (4 << 6)) + (1 << (14 >> 1)) - 14) + (1 << 4)) + (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) + (1 << 8))) + (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) + (1 << 8))) + (768 * ((((nowPos)&literalPosMask) << lc) + (previousByte >> (8 - lc))));
      if (state >= 7) {
        int matchByte;
        matchByte = outStream[nowPos - rep0];
        do {
          int bit;
          unsigned short *probLit;
          matchByte <<= 1;
          bit = (matchByte & 0x100);
          probLit = prob + 0x100 + bit + symbol;
          if (Range < ((unsigned int)1 << 24)) {
            {
              if (Buffer == BufferLim)
                return 1;
            };
            Range <<= 8;
            Code = (Code << 8) | (*Buffer++);
          };
          bound = (Range >> 11) * *(probLit);
          if (Code < bound) {
            Range = bound;
            *(probLit) += ((1 << 11) - *(probLit)) >> 5;
            ;
            symbol <<= 1;
            if (bit != 0)
              break;
          } else {
            Range -= bound;
            Code -= bound;
            *(probLit) -= (*(probLit)) >> 5;
            ;
            symbol = (symbol + symbol) + 1;
            if (bit == 0)
              break;
          }
        } while (symbol < 0x100);
      }
      while (symbol < 0x100) {
        unsigned short *probLit = prob + symbol;
        if (Range < ((unsigned int)1 << 24)) {
          {
            if (Buffer == BufferLim)
              return 1;
          };
          Range <<= 8;
          Code = (Code << 8) | (*Buffer++);
        };
        bound = (Range >> 11) * *(probLit);
        if (Code < bound) {
          Range = bound;
          *(probLit) += ((1 << 11) - *(probLit)) >> 5;
          ;
          symbol <<= 1;
          ;
          ;
        } else {
          Range -= bound;
          Code -= bound;
          *(probLit) -= (*(probLit)) >> 5;
          ;
          symbol = (symbol + symbol) + 1;
          ;
          ;
        }
      }
      previousByte = (unsigned char)symbol;
      outStream[nowPos++] = previousByte;
      if (state < 4)
        state = 0;
      else if (state < 10)
        state -= 3;
      else
        state -= 6;
    } else {
      Range -= bound;
      Code -= bound;
      *(prob) -= (*(prob)) >> 5;
      ;
      prob = p + (0 + (12 << 4)) + state;
      if (Range < ((unsigned int)1 << 24)) {
        {
          if (Buffer == BufferLim)
            return 1;
        };
        Range <<= 8;
        Code = (Code << 8) | (*Buffer++);
      };
      bound = (Range >> 11) * *(prob);
      if (Code < bound) {
        Range = bound;
        *(prob) += ((1 << 11) - *(prob)) >> 5;
        ;
        rep3 = rep2;
        rep2 = rep1;
        rep1 = rep0;
        state = state < 7 ? 0 : 3;
        prob = p + (((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) + (4 << 6)) + (1 << (14 >> 1)) - 14) + (1 << 4));
      } else {
        Range -= bound;
        Code -= bound;
        *(prob) -= (*(prob)) >> 5;
        ;
        prob = p + ((0 + (12 << 4)) + 12) + state;
        if (Range < ((unsigned int)1 << 24)) {
          {
            if (Buffer == BufferLim)
              return 1;
          };
          Range <<= 8;
          Code = (Code << 8) | (*Buffer++);
        };
        bound = (Range >> 11) * *(prob);
        if (Code < bound) {
          Range = bound;
          *(prob) += ((1 << 11) - *(prob)) >> 5;
          ;
          prob = p + (((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (state << 4) + posState;
          if (Range < ((unsigned int)1 << 24)) {
            {
              if (Buffer == BufferLim)
                return 1;
            };
            Range <<= 8;
            Code = (Code << 8) | (*Buffer++);
          };
          bound = (Range >> 11) * *(prob);
          if (Code < bound) {
            Range = bound;
            *(prob) += ((1 << 11) - *(prob)) >> 5;
            ;
            if (nowPos == 0)
              return 1;
            state = state < 7 ? 9 : 11;
            previousByte = outStream[nowPos - rep0];
            outStream[nowPos++] = previousByte;
            continue;
          } else {
            Range -= bound;
            Code -= bound;
            *(prob) -= (*(prob)) >> 5;
            ;
          }
        } else {
          unsigned int distance;
          Range -= bound;
          Code -= bound;
          *(prob) -= (*(prob)) >> 5;
          ;
          prob = p + (((0 + (12 << 4)) + 12) + 12) + state;
          if (Range < ((unsigned int)1 << 24)) {
            {
              if (Buffer == BufferLim)
                return 1;
            };
            Range <<= 8;
            Code = (Code << 8) | (*Buffer++);
          };
          bound = (Range >> 11) * *(prob);
          if (Code < bound) {
            Range = bound;
            *(prob) += ((1 << 11) - *(prob)) >> 5;
            ;
            distance = rep1;
          } else {
            Range -= bound;
            Code -= bound;
            *(prob) -= (*(prob)) >> 5;
            ;
            prob = p + ((((0 + (12 << 4)) + 12) + 12) + 12) + state;
            if (Range < ((unsigned int)1 << 24)) {
              {
                if (Buffer == BufferLim)
                  return 1;
              };
              Range <<= 8;
              Code = (Code << 8) | (*Buffer++);
            };
            bound = (Range >> 11) * *(prob);
            if (Code < bound) {
              Range = bound;
              *(prob) += ((1 << 11) - *(prob)) >> 5;
              ;
              distance = rep2;
            } else {
              Range -= bound;
              Code -= bound;
              *(prob) -= (*(prob)) >> 5;
              ;
              distance = rep3;
              rep3 = rep2;
            }
            rep2 = rep1;
          }
          rep1 = rep0;
          rep0 = distance;
        }
        state = state < 7 ? 8 : 11;
        prob = p + ((((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) + (4 << 6)) + (1 << (14 >> 1)) - 14) + (1 << 4)) + (((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3)) + (1 << 8)));
      }
      {
        int numBits, offset;
        unsigned short *probLen = prob + 0;
        if (Range < ((unsigned int)1 << 24)) {
          {
            if (Buffer == BufferLim)
              return 1;
          };
          Range <<= 8;
          Code = (Code << 8) | (*Buffer++);
        };
        bound = (Range >> 11) * *(probLen);
        if (Code < bound) {
          Range = bound;
          *(probLen) += ((1 << 11) - *(probLen)) >> 5;
          ;
          probLen = prob + ((0 + 1) + 1) + (posState << 3);
          offset = 0;
          numBits = 3;
        } else {
          Range -= bound;
          Code -= bound;
          *(probLen) -= (*(probLen)) >> 5;
          ;
          probLen = prob + (0 + 1);
          if (Range < ((unsigned int)1 << 24)) {
            {
              if (Buffer == BufferLim)
                return 1;
            };
            Range <<= 8;
            Code = (Code << 8) | (*Buffer++);
          };
          bound = (Range >> 11) * *(probLen);
          if (Code < bound) {
            Range = bound;
            *(probLen) += ((1 << 11) - *(probLen)) >> 5;
            ;
            probLen = prob + (((0 + 1) + 1) + ((1 << 4) << 3)) + (posState << 3);
            offset = (1 << 3);
            numBits = 3;
          } else {
            Range -= bound;
            Code -= bound;
            *(probLen) -= (*(probLen)) >> 5;
            ;
            probLen = prob + ((((0 + 1) + 1) + ((1 << 4) << 3)) + ((1 << 4) << 3));
            offset = (1 << 3) + (1 << 3);
            numBits = 8;
          }
        }
        {
          int i = numBits;
          len = 1;
          do {
            unsigned short *p = probLen + len;
            if (Range < ((unsigned int)1 << 24)) {
              {
                if (Buffer == BufferLim)
                  return 1;
              };
              Range <<= 8;
              Code = (Code << 8) | (*Buffer++);
            };
            bound = (Range >> 11) * *(p);
            if (Code < bound) {
              Range = bound;
              *(p) += ((1 << 11) - *(p)) >> 5;
              ;
              len <<= 1;
              ;
              ;
            } else {
              Range -= bound;
              Code -= bound;
              *(p) -= (*(p)) >> 5;
              ;
              len = (len + len) + 1;
              ;
              ;
            }
          } while (--i != 0);
          len -= (1 << numBits);
        };
        len += offset;
      }
      if (state < 4) {
        int posSlot;
        state += 7;
        prob = p + ((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) + ((len < 4 ? len : 4 - 1) << 6);
        {
          int i = 6;
          posSlot = 1;
          do {
            unsigned short *p = prob + posSlot;
            if (Range < ((unsigned int)1 << 24)) {
              {
                if (Buffer == BufferLim)
                  return 1;
              };
              Range <<= 8;
              Code = (Code << 8) | (*Buffer++);
            };
            bound = (Range >> 11) * *(p);
            if (Code < bound) {
              Range = bound;
              *(p) += ((1 << 11) - *(p)) >> 5;
              ;
              posSlot <<= 1;
              ;
              ;
            } else {
              Range -= bound;
              Code -= bound;
              *(p) -= (*(p)) >> 5;
              ;
              posSlot = (posSlot + posSlot) + 1;
              ;
              ;
            }
          } while (--i != 0);
          posSlot -= (1 << 6);
        };
        if (posSlot >= 4) {
          int numDirectBits = ((posSlot >> 1) - 1);
          rep0 = (2 | ((unsigned int)posSlot & 1));
          if (posSlot < 14) {
            rep0 <<= numDirectBits;
            prob = p + (((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) + (4 << 6)) + rep0 - posSlot - 1;
          } else {
            numDirectBits -= 4;
            do {
              if (Range < ((unsigned int)1 << 24)) {
                {
                  if (Buffer == BufferLim)
                    return 1;
                };
                Range <<= 8;
                Code = (Code << 8) | (*Buffer++);
              }
              Range >>= 1;
              rep0 <<= 1;
              if (Code >= Range) {
                Code -= Range;
                rep0 |= 1;
              }
            } while (--numDirectBits != 0);
            prob = p + ((((((((0 + (12 << 4)) + 12) + 12) + 12) + 12) + (12 << 4)) + (4 << 6)) + (1 << (14 >> 1)) - 14);
            rep0 <<= 4;
            numDirectBits = 4;
          }
          {
            int i = 1;
            int mi = 1;
            do {
              unsigned short *prob3 = prob + mi;
              if (Range < ((unsigned int)1 << 24)) {
                {
                  if (Buffer == BufferLim)
                    return 1;
                };
                Range <<= 8;
                Code = (Code << 8) | (*Buffer++);
              };
              bound = (Range >> 11) * *(prob3);
              if (Code < bound) {
                Range = bound;
                *(prob3) += ((1 << 11) - *(prob3)) >> 5;
                ;
                mi <<= 1;
                ;
                ;
              } else {
                Range -= bound;
                Code -= bound;
                *(prob3) -= (*(prob3)) >> 5;
                ;
                mi = (mi + mi) + 1;
                rep0 |= i;
              };
              i <<= 1;
            } while (--numDirectBits != 0);
          }
        } else
          rep0 = posSlot;
        if (++rep0 == (unsigned int)(0)) {
          len = -1;
          break;
        }
      }
      len += 2;
      if (rep0 > nowPos)
        return 1;
      do {
        previousByte = outStream[nowPos - rep0];
        len--;
        outStream[nowPos++] = previousByte;
      } while (len != 0 && nowPos < outSize);
    }
  }
  if (Range < ((unsigned int)1 << 24)) {
    {
      if (Buffer == BufferLim)
        return 1;
    };
    Range <<= 8;
    Code = (Code << 8) | (*Buffer++);
  };
  *outSizeProcessed = nowPos;
  return 0;
}
```