#include <stdint.h>
__attribute__((noinline)) uint64_t g(int x0, uint64_t x1, uint64_t x2, uint64_t x3,
  uint64_t x4, uint64_t x5) { return x0 + x1 + x2 + x3 + x4 + x5; }
uint64_t f() { return g(0, 0x0000000200000001ull, 0x0000000400000003ull,
                           0x0000000600000005ull, 0x0000000800000007ull,
                           0x0000000a00000009ull); }

#include <stdint.h>
__attribute__((noinline)) long double g(int x0, long double x1, int x2) {
 return x0 + x1 + x2; }
long double f() { return g(0, 0.0, 1); }

#include <stdint.h>
#include <stdarg.h>
uint64_t sum(int n, ...) {
  va_list ap;
  va_start(ap, n);
  uint64_t sum = 0;
  for (int i = 0; i < n; i ++) {
    sum += va_arg(ap, uint64_t);
  }
  va_end(ap);
 return sum;
}
uint64_t g1() { return sum(1, 0ull); }
uint64_t g2() { return sum(3, 1ull, 2ull, 3ull); }
uint64_t g3() { return sum(4, 10ull, 20ull, 30ull, 40ull); }

#include <stdio.h>
void hanoi(int n, char from, char to, char via) {
  if (n == 1) { printf("%c -> %c\n", from , to); }
  else {
    hanoi(n - 1, from, via, to);
    hanoi(1,     from, to,  via);
    hanoi(n - 1, via,  to,  from);
  }
}
int main() {
  hanoi(3, 'A', 'B', 'C');
  return 0;
}

void swap_data(long x, long y) {
  long temp; temp = x; x = y; y = temp;
}

void swap_pointer(long *x, long *y) {
  long *temp; temp = x; x = y; y = temp;
}

void swap_pointer_dereference(long *x, long *y) {
  long temp; temp = *x; *x = *y; *y = temp;
}

rv32gcc -ggdb3 -c a.c  # -ggdb3  生成调试信息
rvobjdump -S a.o  # -S  在反汇编结果中显示源代码

int fun(int ***p) {
  return *(*(*(p + 1) + 2) + 3) + 4;
}

rv32gcc -O1 -S a.c
rvobjdump -S a.o

int a[10];
void f(int *p, int b) {
  a[0] = 1;
  a[b] = 2;
  p[-1] = 3;    // ?
  4[a] = 5;     // ??
  (-2)[p] = 6;  // ???
  b[p] = 7;     // ????
}
void g() { f(&a[7], 2); }

#include <string.h>
void f(char *s) {
  char c[12];
  strcpy(c, s);
}
int main(int argc, char *argv[]) {
  f(argv[1]);
  return 0;
}

#include <stdio.h>
#include <stdint.h>
struct T { int x[10]; char y; } t;
#define offset(type, member) (uintptr_t)(&((type *)0ul)->member)

int main() {
  t.y = 'a';
  t.x[5] = 1;
  printf("offset(y) = %ld\n", offset(struct T, y));
  return 0;
}

#include <stdint.h>
typedef struct { uint16_t x; uint8_t y; } T;
__attribute__((noinline)) uint32_t g(T a) {
  return a.x + a.y;
}
uint32_t f() {
  T t = { .x = 1, .y = 2 };
  return g(t);
}

#include <stdio.h>
typedef struct { long x, y, z; } vec_t;
const vec_t a0 = {1, 2, 3}, b0 = {4, 5, 6};
__attribute__((noinline)) vec_t vadd(vec_t a, vec_t b) {
  vec_t c = { .x = a.x + b.x, .y = a.y + b.y, .z = a.z + b.z }; return c;
}
void f() {
  vec_t c = vadd(a0, b0);
  printf("c = (%ld, %ld, %ld)\n", c.x, c.y, c.z);
}

#include <stdio.h>
#include <stdint.h>
#define offset(type, member) (uintptr_t)(&((type *)0ul)->member)
struct T { int i; char c; double d; short si; } t;
int main () {
  printf("offset(i) = %ld\n", offset(struct T, i));
  printf("offset(c) = %ld\n", offset(struct T, c));
  printf("offset(d) = %ld\n", offset(struct T, d));
  printf("offset(si)= %ld\n", offset(struct T, si));
  printf("sizeof(t)= %ld\n", sizeof(t));
  printf("alignof(t)= %ld\n", _Alignof(t));
  return 0;
}

#include <stdio.h>
#include <stdint.h>
union T { int x[10]; char y; } t;
#define offset(type, member) (uintptr_t)(&((type *)0ul)->member)

int main() {
  t.y = 'a';
  printf("t.x[0] = %d\n", t.x[0]);
  printf("offset(y) = %ld\n", offset(union T, y));
  return 0;
}

typedef union node {
  struct { unsigned char data1[4]; long *ptr; } node1;
  struct { long data2; union node *next; } node2;
} node_t;  // 定义一个包含两种节点类型的链表
void f(node_t *p) {
  p->node2.next->node2.data2 = *(p->node2.next->node1.ptr) + p->node1.data1[2];
//  p->node2.next->node2.data2
//    =
//    *(p->node2.next->node1.ptr)
//    +
//    p->node1.data1[2];
}