user: What is the c source code of the assembly code below?

```asm
<main>:
  endbr64
  push   %rbp
  mov    $0x2,%edx
  mov    $0x3,%esi
  mov    %rsp,%rbp
  push   %r15
  lea    D9(%rip),%r15
  push   %r14
  lea    D255(%rip),%r14
  push   %r13
  lea    D120(%rip),%r13
  push   %r12
  lea    D369(%rip),%r12
  push   %rbx
  mov    %r12,%rdi
  lea    D232(%rip),%rbx
  sub    $0x48,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,-0x38(%rbp)
  xor    %eax,%eax
  call   <printf@plt>
  lea    D81(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x3,%esi
  call   <printf@plt>
  lea    D31(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x4,%esi
  call   <printf@plt>
  lea    D493(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x3,%esi
  call   <printf@plt>
  lea    D90(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x3,%esi
  call   <printf@plt>
  lea    D176(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x4,%esi
  call   <printf@plt>
  lea    D403(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x4,%esi
  lea    D193(%rip),%r12
  call   <printf@plt>
  lea    D343(%rip),%rdi
  call   <puts@plt>
  lea    D549(%rip),%rdi
  call   <puts@plt>
  lea    D170(%rip),%rdi
  call   <puts@plt>
  mov    %r12,%rcx
  mov    %r12,%rdx
  mov    %r13,%rdi
  lea    D518(%rip),%rsi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %r12,%rdx
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D227(%rip),%r9
  lea    D169(%rip),%rsi
  mov    %r9,%rcx
  call   <printf@plt>
  mov    %r15,%rdx
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D227(%rip),%r9
  lea    D88(%rip),%rsi
  mov    %r9,%rcx
  call   <printf@plt>
  xor    %eax,%eax
  lea    D266(%rip),%rdi
  call   <printf@plt>
  lea    D78(%rip),%rdi
  call   <puts@plt>
  lea    D58(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D117(%rip),%rdi
  call   <puts@plt>
  lea    D299(%rip),%rdi
  call   <puts@plt>
  lea    D414(%rip),%rdi
  call   <puts@plt>
  mov    %r12,%rcx
  mov    %r12,%rdx
  mov    %r14,%rsi
  mov    %r13,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %r15,%rcx
  mov    %r15,%rdx
  mov    %r13,%rdi
  lea    D122(%rip),%r8
  lea    D353(%rip),%r15
  xor    %eax,%eax
  mov    %r8,%rsi
  call   <printf@plt>
  mov    %r15,%rcx
  mov    %r15,%rdx
  mov    %r13,%rdi
  lea    D622(%rip),%rsi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D573(%rip),%rdi
  call   <puts@plt>
  lea    D457(%rip),%rdi
  call   <puts@plt>
  mov    %rbx,%rcx
  mov    %rbx,%rdx
  mov    %r13,%rdi
  lea    D122(%rip),%r8
  xor    %eax,%eax
  mov    %r8,%rsi
  call   <printf@plt>
  lea    D372(%rip),%rdi
  call   <puts@plt>
  lea    D39(%rip),%rdi
  call   <puts@plt>
  lea    D450(%rip),%rdi
  call   <puts@plt>
  lea    D477(%rip),%rdi
  call   <puts@plt>
  mov    %r12,%rcx
  mov    %r15,%rdx
  mov    %r14,%rsi
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D300(%rip),%r15
  call   <printf@plt>
  lea    D425(%rip),%rdi
  call   <puts@plt>
  mov    %r12,%rcx
  mov    %r12,%rdx
  mov    %r14,%rsi
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D635(%rip),%r12
  call   <printf@plt>
  lea    D649(%rip),%rdi
  lea    D541(%rip),%r14
  call   <puts@plt>
  lea    D328(%rip),%rdi
  call   <puts@plt>
  lea    D278(%rip),%rdi
  call   <puts@plt>
  lea    D258(%rip),%rdi
  call   <puts@plt>
  mov    %r15,%rcx
  mov    %r14,%rsi
  mov    $0x1,%edx
  mov    $0x2,%r8d
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D653(%rip),%rdi
  call   <puts@plt>
  mov    %r15,%rcx
  mov    %r14,%rsi
  mov    $0x1,%edx
  mov    $0x2,%r8d
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D317(%rip),%rdi
  call   <puts@plt>
  mov    %r15,%rcx
  mov    %r14,%rsi
  mov    $0x2,%edx
  mov    $0x1,%r8d
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D607(%rip),%rdi
  lea    D644(%rip),%r15
  call   <puts@plt>
  lea    D410(%rip),%rdi
  lea    D66(%rip),%r14
  call   <puts@plt>
  lea    D17(%rip),%r11
  xor    %eax,%eax
  mov    %r11,%rdi
  call   <printf@plt>
  mov    $0x1,%r8d
  mov    %r15,%rcx
  xor    %eax,%eax
  mov    $0x2,%edx
  mov    %r14,%rsi
  mov    %r12,%rdi
  call   <printf@plt>
  lea    D140(%rip),%r10
  xor    %eax,%eax
  mov    %r10,%rdi
  call   <printf@plt>
  mov    $0x1,%r8d
  mov    %r15,%rcx
  xor    %eax,%eax
  mov    $0x2,%edx
  mov    %r14,%rsi
  mov    %r12,%rdi
  call   <printf@plt>
  lea    D260(%rip),%rdi
  call   <puts@plt>
  lea    D17(%rip),%r11
  xor    %eax,%eax
  mov    %r11,%rdi
  call   <printf@plt>
  mov    $0x1,%r8d
  mov    %r15,%rcx
  xor    %eax,%eax
  mov    $0x2,%edx
  mov    %r14,%rsi
  mov    %r12,%rdi
  call   <printf@plt>
  lea    D140(%rip),%r10
  xor    %eax,%eax
  mov    %r10,%rdi
  call   <printf@plt>
  mov    $0x2,%r8d
  mov    %r15,%rcx
  xor    %eax,%eax
  mov    $0x1,%edx
  mov    %r14,%rsi
  mov    %r12,%rdi
  call   <printf@plt>
  lea    D624(%rip),%rdi
  call   <puts@plt>
  mov    %rbx,%rdx
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D227(%rip),%r9
  lea    D612(%rip),%rsi
  mov    %r9,%rcx
  call   <printf@plt>
  mov    $0x4,%edx
  xor    %eax,%eax
  movb   $0x0,-0x3e(%rbp)
  mov    $0x4,%esi
  lea    D479(%rip),%rdi
  movb   $0x0,-0x39(%rbp)
  movl   $0x20736f64,-0x42(%rbp)
  movl   $0x78756564,-0x3d(%rbp)
  call   <printf@plt>
  lea    -0x42(%rbp),%rax
  mov    %rax,%rdi
  mov    %rax,-0x68(%rbp)
  call   <strlen@plt>
  mov    %rsp,%rcx
  add    $0xf,%rax
  mov    %rax,%rdx
  and    $0xfffffffffffff000,%rax
  sub    %rax,%rcx
  and    $0xfffffffffffffff0,%rdx
  cmp    %rcx,%rsp
  je     L40
L60:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rcx,%rsp
  jne    L60
L40:
  and    $0xfff,%edx
  sub    %rdx,%rsp
  test   %rdx,%rdx
  jne    L68
L94:
  movzbl -0x42(%rbp),%eax
  lea    0x1(%rsp),%rbx
  lea    -0x41(%rbp),%r15
  mov    %al,(%rsp)
  test   %al,%al
  je     L11
  mov    $0x1,%r14d
  lea    D102(%rip),%r12
  sub    %ebx,%r14d
  mov    %r14d,-0x58(%rbp)
  nopl   (%rax)
L10:
  mov    -0x58(%rbp),%eax
  mov    %r12,%rdi
  add    $0x1,%r15
  lea    (%rax,%rbx,1),%r14d
  xor    %eax,%eax
  add    $0x1,%rbx
  mov    %r14d,%esi
  call   <printf@plt>
  movzbl -0x1(%r15),%eax
  mov    %al,-0x1(%rbx)
  test   %al,%al
  jne    L10
L71:
  movslq %r14d,%rdx
  lea    D674(%rip),%rdi
  not    %rdx
  add    %rdx,%r15
  lea    (%rbx,%rdx,1),%rax
  mov    %rax,-0x58(%rbp)
  mov    %r15,%rsi
  xor    %eax,%eax
  call   <printf@plt>
  movzbl -0x3d(%rbp),%eax
  lea    0x1(%r15),%rdx
  mov    %rdx,%rbx
  mov    %al,(%r15)
  lea    -0x3c(%rbp),%r15
  test   %al,%al
  je     L105
  mov    $0x1,%r14d
  lea    D102(%rip),%r12
  sub    %edx,%r14d
  mov    %r14d,-0x5c(%rbp)
  nopl   0x0(%rax,%rax,1)
L90:
  mov    -0x5c(%rbp),%eax
  mov    %r12,%rdi
  add    $0x1,%r15
  lea    (%rax,%rbx,1),%r14d
  xor    %eax,%eax
  add    $0x1,%rbx
  mov    %r14d,%esi
  call   <printf@plt>
  movzbl -0x1(%r15),%eax
  mov    %al,-0x1(%rbx)
  test   %al,%al
  jne    L90
L24:
  movslq %r14d,%rsi
  lea    D674(%rip),%rdi
  xor    %eax,%eax
  not    %rsi
  lea    (%r15,%rsi,1),%r12
  add    %rbx,%rsi
  call   <printf@plt>
  mov    -0x58(%rbp),%rax
  lea    0x1(%r12),%r15
  movzbl (%rax),%eax
  mov    %al,(%r12)
  test   %al,%al
  je     L58
  mov    $0x1,%r14d
  lea    D102(%rip),%r12
  nopl   0x0(%rax,%rax,1)
L116:
  mov    %r14d,%esi
  mov    %r12,%rdi
  xor    %eax,%eax
  add    $0x1,%r15
  call   <printf@plt>
  mov    -0x58(%rbp),%rax
  mov    %r14d,%ebx
  movzbl (%rax,%r14,1),%eax
  add    $0x1,%r14
  mov    %al,-0x1(%r15)
  test   %al,%al
  jne    L116
L89:
  movslq %ebx,%rdx
  lea    D618(%rip),%rdi
  xor    %eax,%eax
  not    %rdx
  lea    (%r15,%rdx,1),%rsi
  call   <printf@plt>
  mov    -0x68(%rbp),%rdx
  lea    -0x3d(%rbp),%rcx
  mov    %r13,%rdi
  lea    D195(%rip),%rsi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D591(%rip),%rdi
  call   <puts@plt>
  lea    D171(%rip),%rdi
  call   <puts@plt>
  mov    -0x38(%rbp),%rax
  sub    %fs:0x28,%rax
  jne    L114
  lea    -0x28(%rbp),%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  pop    %rbp
  ret
L68:
  orq    $0x0,-0x8(%rsp,%rdx,1)
  jmp    L94
L58:
  xor    %ebx,%ebx
  jmp    L89
L105:
  xor    %r14d,%r14d
  jmp    L24
L11:
  xor    %r14d,%r14d
  jmp    L71
L114:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: data_tag: D9
datatype: string
name: extract_symbolic_data
arguments: data_tag: D255
datatype: string
name: extract_symbolic_data
arguments: data_tag: D120
datatype: string
name: extract_symbolic_data
arguments: data_tag: D369
datatype: string
name: extract_symbolic_data
arguments: data_tag: D232
datatype: string
name: extract_symbolic_data
arguments: data_tag: D81
datatype: string
name: extract_symbolic_data
arguments: data_tag: D31
datatype: string
name: extract_symbolic_data
arguments: data_tag: D493
datatype: string
name: extract_symbolic_data
arguments: data_tag: D90
datatype: string
name: extract_symbolic_data
arguments: data_tag: D176
datatype: string
name: extract_symbolic_data
arguments: data_tag: D403
datatype: string
name: extract_symbolic_data
arguments: data_tag: D193
datatype: string
name: extract_symbolic_data
arguments: data_tag: D343
datatype: string
name: extract_symbolic_data
arguments: data_tag: D549
datatype: string
name: extract_symbolic_data
arguments: data_tag: D170
datatype: string
name: extract_symbolic_data
arguments: data_tag: D518
datatype: string
name: extract_symbolic_data
arguments: data_tag: D227
datatype: string
name: extract_symbolic_data
arguments: data_tag: D169
datatype: string
name: extract_symbolic_data
arguments: data_tag: D88
datatype: string
name: extract_symbolic_data
arguments: data_tag: D266
datatype: string
name: extract_symbolic_data
arguments: data_tag: D78
datatype: string
name: extract_symbolic_data
arguments: data_tag: D58
datatype: string
name: extract_symbolic_data
arguments: data_tag: D117
datatype: string
name: extract_symbolic_data
arguments: data_tag: D299
datatype: string
name: extract_symbolic_data
arguments: data_tag: D414
datatype: string
name: extract_symbolic_data
arguments: data_tag: D122
datatype: string
name: extract_symbolic_data
arguments: data_tag: D353
datatype: string
name: extract_symbolic_data
arguments: data_tag: D622
datatype: string
name: extract_symbolic_data
arguments: data_tag: D573
datatype: string
name: extract_symbolic_data
arguments: data_tag: D457
datatype: string
name: extract_symbolic_data
arguments: data_tag: D372
datatype: string
name: extract_symbolic_data
arguments: data_tag: D39
datatype: string
name: extract_symbolic_data
arguments: data_tag: D450
datatype: string
name: extract_symbolic_data
arguments: data_tag: D477
datatype: string
name: extract_symbolic_data
arguments: data_tag: D300
datatype: string
name: extract_symbolic_data
arguments: data_tag: D425
datatype: string
name: extract_symbolic_data
arguments: data_tag: D635
datatype: string
name: extract_symbolic_data
arguments: data_tag: D649
datatype: string
name: extract_symbolic_data
arguments: data_tag: D541
datatype: string
name: extract_symbolic_data
arguments: data_tag: D328
datatype: string
name: extract_symbolic_data
arguments: data_tag: D278
datatype: string
name: extract_symbolic_data
arguments: data_tag: D258
datatype: string
name: extract_symbolic_data
arguments: data_tag: D653
datatype: string
name: extract_symbolic_data
arguments: data_tag: D317
datatype: string
name: extract_symbolic_data
arguments: data_tag: D607
datatype: string
name: extract_symbolic_data
arguments: data_tag: D644
datatype: string
name: extract_symbolic_data
arguments: data_tag: D410
datatype: string
name: extract_symbolic_data
arguments: data_tag: D66
datatype: string
name: extract_symbolic_data
arguments: data_tag: D17
datatype: string
name: extract_symbolic_data
arguments: data_tag: D140
datatype: string
name: extract_symbolic_data
arguments: data_tag: D260
datatype: string
name: extract_symbolic_data
arguments: data_tag: D624
datatype: string
name: extract_symbolic_data
arguments: data_tag: D612
datatype: string
name: extract_symbolic_data
arguments: data_tag: D479
datatype: string
name: extract_symbolic_data
arguments: data_tag: D102
datatype: string
name: extract_symbolic_data
arguments: data_tag: D674
datatype: string
name: extract_symbolic_data
arguments: data_tag: D618
datatype: string
name: extract_symbolic_data
arguments: data_tag: D195
datatype: string
name: extract_symbolic_data
arguments: data_tag: D591
datatype: string
name: extract_symbolic_data
arguments: data_tag: D171
datatype: string

tool: D9: 2 

tool: D255: tabT[0],tabD[0]

tool: D120: %s : %s,%s


tool: D369: i : %d - j : %d


tool: D232: dos 

tool: D81: affichage pi et pj

tool: D31: changement de i vers 4 et affichage des pointeurs

tool: D493: cette fois *pi a 3

tool: D90: un pointeur tempo pt dans lequel je mets l'adresse *pi

tool: D176: je rechange i vers 4 et affiche *pt

tool: D403: on affiche *pi

tool: D193: un 

tool: D343: a present les pointeurs de pointeurs prenons *tabS[3] et *tabD[3]

tool: D549: tabD = 1 ,2 ,3  && tabS = un ,deux ,trois 

tool: D170: j'ai copie la valeur pointe par tabS dans tabD : *tabD = *tabS

tool: D518: tabD,tabS

tool: D227: deux

tool: D169: *tabD,*(tabS+1)

tool: D88: *(tabD+1),*(tabS+1)

tool: D266: la valeur 0 est bien copier mais pas les suivantes

tool: D78: il faut copier les elements du tableau 1 par 1

tool: D58: sachant que l'on peut naviguer d'une valeur a l'autre arithmetiquement (++), 

tool: D117: on doit pouvoir transmettre la valeur a une variable...

tool: D299: prenons char **tabT

tool: D414: essayons de le faire pointer sur tabD[0]

tool: D122: tabT[1],tabD[1]

tool: D353: 3 

tool: D622: tabT[2],tabD[2]

tool: D573: tabT = &tabD[0]; fonctionne

tool: D457: pour s'en assurer essayons de changer la valeur de tabT[1] en dos 

tool: D372: puisque tt cela fonctionne essayons a present d'incrementer tabD deux fois

tool: D39: puis d'assigner a tabD l'adresse de &tabD[-2]

tool: D450: oups pas possible car tabD est un tableau et ce genre de manip n'est possible qu'avec un pointeur...

tool: D477: faisons le avec tabT dans ce cas :-)

tool: D300: b

tool: D425: a presont assignons a tabT l'adresse tabT[-2]

tool: D635: %s : %d - %s : %d


tool: D649: OK je pense avoir compris ! passons a l'utilisation des pointeurs dans les fonctions

tool: D541: a

tool: D328: une fonction ech1(int a,int b) sans pointeur a=1 b=2

tool: D278: une fonction ech2(int *a,int *b) avec pointeur a=1 b=2

tool: D258: depart :

tool: D653: a present appellons la fonction ech1(a,b)

tool: D317: a present appellons la fonction ech2(&a,&b)

tool: D607: creons un pointeur a et b tel que pa et pb

tool: D644: *pb

tool: D410: a present appellons la fonction ech1(*pa,*pb)

tool: D66: *pa

tool: D17: avant : 

tool: D140: apres : 

tool: D260: a present appellons la fonction ech2(pa,pb)

tool: D624: pour finir on va inverser tabD et tabS par l'intermediaire de *pD et *pS

tool: D612: *pD,*pS

tool: D479: taille a : %d,taille b : %d

tool: D102: %d

tool: D674: int : %s 


tool: D618: fin : %s


tool: D195: n[]=dos,v[]=deux

tool: D591: on ne peut pas faire d'echange via pointeur...ou alors je ne sais pas le faire

tool: D171: il faut utiliser les tableaux...choc

assistant: ```c
int main() {
  int *pi;
  int i;
  int *pj;
  int *pt;
  int j;
  i = 3;
  j = 2;
  pi = &i;
  pj = &j;
  void affiche(int i, int j) { printf("i : %d - j : %d\n", i, j); }
  void affiche2(char f[], char *i, char *j) { printf("%s : %s,%s\n", f, i, j); }
  void affiche3(char *a, char *b, int i, int j) { printf("%s : %d - %s : %d\n", a, i, b, j); }
  affiche(i, j);
  printf("affichage pi et pj\n");
  affiche(*pi, *pj);
  printf("changement de i vers 4 et affichage des pointeurs\n");
  i = 4;
  affiche(*pi, *pj);
  printf("cette fois *pi a 3");
  *pi = 3;
  affiche(*pi, *pj);
  printf("un pointeur tempo pt dans lequel je mets l'adresse *pi\n");
  pt = pi;
  affiche(*pt, *pj);
  printf("je rechange i vers 4 et affiche *pt\n");
  i = 4;
  affiche(*pt, *pj);
  printf("on affiche *pi");
  affiche(*pi, *pj);
  printf("a present les pointeurs de pointeurs prenons *tabS[3] et *tabD[3]\n");
  char *tabS[3];
  char *tabD[3];
  char **tabT;
  *tabS = "un ";
  *(tabS + 1) = "deux";
  *(tabS + 2) = "trois";
  *tabD = "1 ";
  *(tabD + 1) = "2 ";
  *(tabD + 2) = "3 ";
  *tabD = *tabS;
  printf("tabD = 1 ,2 ,3  && tabS = un ,deux ,trois \n");
  printf("j'ai copie la valeur pointe par tabS dans tabD : *tabD = *tabS\n");
  affiche2("tabD,tabS", *tabD, *tabS);
  affiche2("*tabD,*(tabS+1)", *tabD, *(tabS + 1));
  affiche2("*(tabD+1),*(tabS+1)", *(tabD + 1), *(tabS + 1));
  printf("la valeur 0 est bien copier mais pas les suivantes");
  printf("il faut copier les elements du tableau 1 par 1\n");
  printf("sachant que l'on peut naviguer d'une valeur a l'autre arithmetiquement (++), ");
  printf("on doit pouvoir transmettre la valeur a une variable...\n");
  printf("prenons char **tabT\n");
  printf("essayons de le faire pointer sur tabD[0]\n");
  tabT = tabD;
  affiche2("tabT[0],tabD[0]", tabT[0], tabD[0]);
  affiche2("tabT[1],tabD[1]", tabT[1], tabD[1]);
  affiche2("tabT[2],tabD[2]", tabT[2], tabD[2]);
  printf("tabT = &tabD[0]; fonctionne\n");
  printf("pour s'en assurer essayons de changer la valeur de tabT[1] en dos \n");
  tabT[1] = "dos ";
  affiche2("tabT[1],tabD[1]", tabT[1], tabD[1]);
  printf("puisque tt cela fonctionne essayons a present d'incrementer tabD deux fois\n");
  printf("puis d'assigner a tabD l'adresse de &tabD[-2]\n");
  printf("oups pas possible car tabD est un tableau et ce genre de manip n'est possible qu'avec un pointeur...\n");
  printf("faisons le avec tabT dans ce cas :-)\n");
  tabT++;
  tabT++;
  affiche2("tabT[0],tabD[0]", tabT[0], tabD[0]);
  printf("a presont assignons a tabT l'adresse tabT[-2]\n");
  tabT = tabT - 2;
  affiche2("tabT[0],tabD[0]", tabT[0], tabD[0]);
  printf("OK je pense avoir compris ! passons a l'utilisation des pointeurs dans les fonctions\n");
  printf("une fonction ech1(int a,int b) sans pointeur a=1 b=2\n");
  void ech1(int a, int b) {
    int t;
    t = a;
    a = b;
    b = t;
  }
  printf("une fonction ech2(int *a,int *b) avec pointeur a=1 b=2\n");
  void ech2(int *a, int *b) {
    int t;
    t = *a;
    *a = *b;
    *b = t;
  }
  void ech3(char *a, char *b) {
    printf("taille a : %d,taille b : %d", strlen(a), strlen(b));
    int sc;
    sc = strlen(a);
    char c[sc];
    char *t;
    t = c;
    int i;
    i = 0;
    while (*t++ = *a++)
      printf("%d", ++i);
    a = (a - i - 1);
    t = (t - i - 1);
    printf("int : %s \n", a);
    i = 0;
    while (*a++ = *b++)
      printf("%d", ++i);
    a = (a - i - 1);
    b = (b - i - 1);
    printf("int : %s \n", a);
    i = 0;
    while (*b++ = *t++)
      printf("%d", ++i);
    b = (b - i - 1);
    t = (t - i - 1);
    printf("fin : %s\n", b);
  }
  int a, b;
  a = 1;
  b = 2;
  printf("depart :\n");
  affiche3("a", "b", a, b);
  printf("a present appellons la fonction ech1(a,b)\n");
  ech1(a, b);
  affiche3("a", "b", a, b);
  printf("a present appellons la fonction ech2(&a,&b)\n");
  ech2(&a, &b);
  affiche3("a", "b", a, b);
  printf("creons un pointeur a et b tel que pa et pb\n");
  int *pa;
  int *pb;
  pb = &b;
  pa = &a;
  printf("a present appellons la fonction ech1(*pa,*pb)\n");
  printf("avant : ");
  affiche3("*pa", "*pb", *pa, *pb);
  ech1(*pa, *pb);
  printf("apres : ");
  affiche3("*pa", "*pb", *pa, *pb);
  printf("a present appellons la fonction ech2(pa,pb)\n");
  printf("avant : ");
  affiche3("*pa", "*pb", *pa, *pb);
  ech2(pa, pb);
  printf("apres : ");
  affiche3("*pa", "*pb", *pa, *pb);
  printf("pour finir on va inverser tabD et tabS par l'intermediaire de *pD et *pS\n");
  char **pD;
  char **pS;
  pD = tabD;
  pS = tabS;
  affiche2("*pD,*pS", *(pD + 1), *(pS + 1));
  char n[] = "dos ";
  char v[] = "deux";
  ech3(n, v);
  affiche2("n[]=dos,v[]=deux", n, v);
  printf("on ne peut pas faire d'echange via pointeur...ou alors je ne sais pas le faire\n");
  printf("il faut utiliser les tableaux...choc\n");
}
```