user: Converte this assembly snippet into its equivalent C code:

```asm
<solve_at_xy>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x48,%rsp
  mov    %rdi,(%rsp)
  mov    %esi,%r14d
  mov    %edx,%r15d
  movslq %esi,%rax
  lea    (%rax,%rax,8),%rdx
  mov    %rdi,%rsi
  lea    (%rdi,%rdx,4),%rdi
  mov    %rdi,0x18(%rsp)
  imul   $0x55555556,%rax,%rax
  shr    $0x20,%rax
  mov    %r14d,%edx
  sar    $0x1f,%edx
  sub    %edx,%eax
  lea    (%rax,%rax,2),%edi
  mov    %edi,0x38(%rsp)
  movslq %r15d,%rdx
  imul   $0x55555556,%rdx,%rax
  shr    $0x20,%rax
  mov    %r15d,%ecx
  sar    $0x1f,%ecx
  sub    %ecx,%eax
  lea    (%rax,%rax,2),%ecx
  mov    %ecx,0x14(%rsp)
  mov    %edi,%eax
  lea    0x2(%rdi),%edi
  mov    %edi,0x20(%rsp)
  lea    0x3(%rax),%edi
  mov    %edi,0x24(%rsp)
  lea    0x3(%rcx),%edi
  mov    %edi,0x3c(%rsp)
  lea    (%rsi,%rdx,4),%rdx
  mov    %rdx,0x30(%rsp)
  cltq
  lea    (%rax,%rax,8),%rax
  movslq %ecx,%rdx
  add    %rdx,%rax
  lea    (%rsi,%rax,4),%rax
  mov    %rax,0x28(%rsp)
  movl   $0x1,0x10(%rsp)
  lea    0x2(%rcx),%r13d
  jmp    L170
L192:
  add    $0x1,%ebp
  add    $0x4,%r12
  cmp    $0x9,%ebp
  je     L144
L16:
  cmpl   $0x0,(%r12)
  jne    L192
  cmp    %ebp,%r15d
  je     L192
  mov    %ebp,%ecx
  mov    %r14d,%edx
  mov    0x10(%rsp),%esi
  mov    %rbx,%rdi
  call   <check_conflict@plt>
  test   %eax,%eax
  jne    L192
  mov    %eax,%ebx
  cmp    $0x9,%ebp
  je     L144
  mov    0x30(%rsp),%rbp
  mov    (%rsp),%r12
  jmp    L184
L58:
  add    $0x1,%ebx
  add    $0x24,%rbp
  cmp    $0x9,%ebx
  je     L144
L184:
  cmpl   $0x0,0x0(%rbp)
  jne    L58
  cmp    %ebx,%r14d
  je     L58
  mov    %r15d,%ecx
  mov    %ebx,%edx
  mov    0x10(%rsp),%esi
  mov    %r12,%rdi
  call   <check_conflict@plt>
  test   %eax,%eax
  jne    L58
  cmp    $0x9,%ebx
  je     L144
  mov    0x28(%rsp),%rax
  mov    %rax,0x8(%rsp)
  mov    0x38(%rsp),%r12d
  jmp    L20
L42:
  mov    %ebx,%ecx
  mov    %r12d,%edx
  mov    0x10(%rsp),%esi
  mov    (%rsp),%rdi
  call   <check_conflict@plt>
  test   %eax,%eax
  je     L260
L151:
  add    $0x1,%ebx
  add    $0x4,%rbp
  cmp    %r13d,%ebx
  jg     L85
L46:
  cmpl   $0x0,0x0(%rbp)
  jne    L151
  cmp    %r12d,%r14d
  jne    L42
  cmp    %ebx,%r15d
  je     L151
  jmp    L42
L260:
  cmp    %ebx,%r13d
  jge    L69
L85:
  add    $0x1,%r12d
  addq   $0x24,0x8(%rsp)
  cmp    0x20(%rsp),%r12d
  jg     L69
L20:
  mov    0x8(%rsp),%rbp
  mov    0x14(%rsp),%ebx
  jmp    L46
L69:
  cmp    %r12d,0x24(%rsp)
  je     L134
L113:
  addl   $0x1,0x10(%rsp)
  mov    0x10(%rsp),%eax
  cmp    $0xa,%eax
  je     L163
L170:
  mov    %r15d,%ecx
  mov    %r14d,%edx
  mov    0x10(%rsp),%esi
  mov    (%rsp),%rbx
  mov    %rbx,%rdi
  call   <check_conflict@plt>
  cmp    $0x1,%eax
  je     L113
  mov    0x18(%rsp),%r12
  mov    $0x0,%ebp
  jmp    L16
L134:
  cmp    %ebx,0x3c(%rsp)
  jne    L113
  jmp    L144
L163:
  movl   $0x0,0x10(%rsp)
L144:
  mov    0x10(%rsp),%eax
  add    $0x48,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

assistant: ```c
int solve_at_xy(const int sudoku[9][9], const int row_no, const int column_no) {
  int test_value, i, j, row_start, column_start;
  for (test_value = 1; test_value <= 9; ++test_value) {
    if (check_conflict(sudoku, test_value, row_no, column_no) == 1) {
      continue;
    }
    for (i = 0; i < 9; ++i) {
      if ((sudoku[row_no][i] != 0) || (i == column_no)) {
        continue;
      }
      if (check_conflict(sudoku, test_value, row_no, i) == 0) {
        break;
      }
    }
    if (i == 9) {
      return test_value;
    }
    for (i = 0; i < 9; ++i) {
      if ((sudoku[i][column_no] != 0) || (i == row_no)) {
        continue;
      }
      if (check_conflict(sudoku, test_value, i, column_no) == 0) {
        break;
      }
    }
    if (i == 9) {
      return test_value;
    }
    row_start = row_no - (row_no % 3);
    column_start = column_no - (column_no % 3);
    for (i = row_start; i < row_start + 3; ++i) {
      for (j = column_start; j < column_start + 3; ++j) {
        if ((sudoku[i][j] != 0) || (i == row_no && j == column_no)) {
          continue;
        }
        if (check_conflict(sudoku, test_value, i, j) == 0) {
          break;
        }
      }
      if (j < column_start + 3) {
        break;
      }
    }
    if ((i == row_start + 3) && (j == column_start + 3)) {
      return test_value;
    }
  }
  return 0;
}
```