#if defined(__aarch64__)
#include "../int.h"

void exit(int8_t status){
  asm ( "mov x0, %0\n"        // Move the exit status into register x0
        "mov x8, #93\n"       // Syscall number for 'exit' is 93 in AArch64
        "svc #0\n"            // Make the syscall
        :                      // No output operands
        : "r" ((long)status)         // Input operand: status
        : "x0", "x8"           // Clobbered registers
  );
  for (;;);
}

intptr_t write(int32_t fd, const void* buf, intptr_t size){
  intptr_t n_written = 0;
  //register int32_t fd_w asm("w0") = fd;
  asm volatile( 
    // Assembly Instructions
    "mov x0, %1\n"  // Set x0 to value of fd
    "mov x1, %2\n"  // Set x1 to value of buf
    "mov x2, %3\n"  // Set x2 to value of size
    "mov x8, #64\n" // Syscall number for 'write' is 64 in AArch64
    "svc #0\n"      // Make syscall
    "mov %0, x0\n"  // Store return value in n_written
    // Output operands
    : "=r"(n_written)
    // Input operands
    : "r"((int64_t)fd), "r" (buf), "r"(size)
    // Clobbered registers
    : "x0", "x1", "x2", "x8"
  );
  return n_written;
}

intptr_t read(int32_t fd, const void* buf, intptr_t size){
  intptr_t n_read = 0;
  asm volatile( 
    // Assembly Instructions
    "mov x0, %1\n"  // Set x0 to value of fd
    "mov x1, %2\n"  // Set x1 to value of buf
    "mov x2, %3\n"  // Set x2 to value of size
    "mov x8, #63\n" // Syscall number for 'read' is 63 in AArch64
    "svc #0\n"      // Make syscall
    "mov %0, x0\n"  // Store return value in n_read
    // Output operands
    : "=r"(n_read)
    // Input operands
    : "r"((int64_t)fd), "r" (buf), "r"(size)
    // Clobbered registers
    : "x0", "x1", "x2", "x8", "memory"
  );
  return n_read;
}

#define CLONE_CHILD_SETTID   0x1000000
#define CLONE_CHILD_CLEARTID 0x200000
uint32_t fork(){
  long int rtn;
  long int flags = CLONE_CHILD_CLEARTID | CLONE_CHILD_SETTID;
  asm volatile (
    // Assembly Instructions
    "mov x8, #220\n"  // Syscall number for 'clone' is 220 in AArch64
    "mov x0, %1\n"    // clone flags
    "mov x1, #0\n"    // child stack pointer
    "mov x2, #0\n"    // parent_tidptr
    "mov x3, #0\n"    // tls
    "mov x4, #0\n"    // child_tidptr
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" (flags)
    // Clobbered registers
    : "x0", "x1", "x2", "x3", "x4", "x8"
  );
  return (uint32_t)rtn;
}

int32_t openat(int32_t fd, const char* filename, uint32_t flags, uint32_t mode) {
  long int rtn;
  asm volatile (
    // Assembly Instructions
    "mov x8, #56\n"  // Syscall number for 'openat' is 56 in AArch64
    "mov x0, %1\n"    // dir fd
    "mov x1, %2\n"    // file path
    "mov x2, %3\n"    // flags
    "mov x3, %4\n"    // mode
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" ((int64_t)fd), "r"(filename), "r"((int64_t)flags), "r"((int64_t)mode)
    // Clobbered registers
    : "x0", "x1", "x2", "x3", "x8"
  );
  return (int32_t)rtn;
}

int close(unsigned int fd){
  long int rtn;
  asm ( 
    "mov x0, %1\n"
    "mov x8, #57\n"
    "svc #0\n"
    "mov %0, x0\n"
    : "=r"(rtn)
    : "r" ((long)fd)
    : "x0", "x8"
  );
  return (int)rtn;
}

int fsync(unsigned int fd){
  long int rtn;
  asm ( 
    "mov x0, %1\n"
    "mov x8, #82\n"
    "svc #0\n"
    "mov %0, x0\n"
    : "=r"(rtn)
    : "r" ((long)fd)
    : "x0", "x8"
  );
  return (int)rtn;
}

int socket(int domain, int type, int protocol) {
  long int rtn;
  asm volatile (
    // Assembly Instructions
    "mov x8, #198\n"  // Syscall number for 'socket' is 198 in AArch64
    "mov x0, %1\n"    // domain
    "mov x1, %2\n"    // type
    "mov x2, %3\n"    // protocol
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" ((int64_t)domain), "r"((int64_t)type), "r"((int64_t)protocol)
    // Clobbered registers
    : "x0", "x1", "x2", "x8"
  );
  return (int32_t)rtn;
}

int setsockopt(int sockfd, int level, int optname, const void* optval, uint64_t optlen) {
  long int rtn;
  asm volatile (
    // Assembly Instructions
    "mov x8, #208\n"  // Syscall number for 'setsockopt' is 208 in AArch64
    "mov x0, %1\n"    // sockfd
    "mov x1, %2\n"    // level
    "mov x2, %3\n"    // optname
    "mov x3, %4\n"    // optval
    "mov x4, %5\n"    // optlen
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" ((int64_t)sockfd), "r"((int64_t)level), "r"((int64_t)optname), "r"(optval), "r"(optlen)
    // Clobbered registers
    : "x0", "x1", "x2", "x3", "x4", "x8"
  );
  return (int32_t)rtn;
}

int bind(int sockfd, const void* sockaddr, uint64_t addrlen) {
  long int rtn;
  asm volatile (
    // Assembly Instructions
    "mov x8, #200\n"  // Syscall number for 'bind' is 200 in AArch64
    "mov x0, %1\n"    // sockfd
    "mov x1, %2\n"    // sockaddr
    "mov x2, %3\n"    // addrlen
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" ((int64_t)sockfd), "r"(sockaddr), "r"(addrlen)
    // Clobbered registers
    : "x0", "x1", "x2", "x8"
  );
  return (int32_t)rtn;
}

int listen(int fd, int backlog) {
  long int rtn;
  asm volatile (
    // Assembly Instructions
    "mov x8, #201\n"  // Syscall number for 'listen' is 201 in AArch64
    "mov x0, %1\n"    // fd
    "mov x1, %2\n"    // backlog
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" ((int64_t)fd), "r"((int64_t)backlog)
    // Clobbered registers
    : "x0", "x1", "x8"
  );
  return (int32_t)rtn;
}

int accept(int sockfd, void* addr, uint64_t* addrlen) {
  long int rtn;
  asm volatile (
    // Assembly Instructions
    "mov x8, #202\n"  // Syscall number for 'accept' is 202 in AArch64
    "mov x0, %1\n"    // sockfd
    "mov x1, %2\n"    // addr
    "mov x2, %3\n"    // addrlen
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" ((int64_t)sockfd), "r"(addr), "r"(addrlen)
    // Clobbered registers
    : "x0", "x1", "x2", "x8"
  );
  return (int32_t)rtn;
}

int connect(int sockfd, void* addr, uint64_t addrlen) {
  long int rtn;
  asm volatile (
    // Assembly Instructions
    "mov x8, #203\n"  // Syscall number for 'connect' is 203 in AArch64
    "mov x0, %1\n"    // sockfd
    "mov x1, %2\n"    // addr
    "mov x2, %3\n"    // addrlen
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" ((int64_t)sockfd), "r"(addr), "r"(addrlen)
    // Clobbered registers
    : "x0", "x1", "x2", "x8"
  );
  return (int32_t)rtn;
}

int64_t sendto(int sockfd, const void* buf, uint64_t size, int flags, const void* sockaddr, uint64_t addrlen) {
  long int rtn;
  asm volatile (
    // Assembly Instructions
    "mov x8, #206\n"  // Syscall number for 'sendto' is 206 in AArch64
    "mov x0, %1\n"    // 
    "mov x1, %2\n"    // 
    "mov x2, %3\n"    // 
    "mov x3, %4\n"    // 
    "mov x4, %5\n"
    "mov x5, %6\n"
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" ((int64_t)sockfd), "r"(buf), "r"(size), "r"((int64_t)flags), "r"(sockaddr), "r"(addrlen)
    // Clobbered registers
    : "x0", "x1", "x2", "x3", "x4", "x5", "x8"
  );
  return rtn;
}

int64_t recvfrom(int sockfd, const void* buf, uint64_t size, int flags, const void* sockaddr, uint64_t addrlen) {
  long int rtn;
  asm volatile (
    // Assembly Instructions
    "mov x8, #207\n"  // Syscall number for 'recvfrom' is 207 in AArch64
    "mov x0, %1\n"    // 
    "mov x1, %2\n"    // 
    "mov x2, %3\n"    // 
    "mov x3, %4\n"    // 
    "mov x4, %5\n"
    "mov x5, %6\n"
    "svc #0\n"        // Make the syscall
    "mov %0, x0\n"    // save return value
    // Output operands
    : "=r" (rtn)
    // Input operand
    : "r" ((int64_t)sockfd), "r"(buf), "r"(size), "r"((int64_t)flags), "r"(sockaddr), "r"(addrlen)
    // Clobbered registers
    : "x0", "x1", "x2", "x3", "x4", "x5", "x8"
  );
  return rtn;
}

#endif