user: Please show me the C implementation that matches the assembly code listed below:

```asm
<main>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbx
  sub    $0x38,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,-0x38(%rbp)
  xor    %eax,%eax
  mov    $0x2,%edx
  mov    $0x3,%esi
  lea    D514(%rip),%rbx
  mov    %rbx,%rdi
  call   <printf@plt>
  lea    D435(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    $0x3,%esi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D82(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    $0x4,%esi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D354(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x2,%edx
  mov    $0x3,%esi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D121(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    $0x3,%esi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D260(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    $0x4,%esi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D11(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x2,%edx
  mov    $0x4,%esi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D455(%rip),%rdi
  call   <puts@plt>
  lea    D526(%rip),%rdi
  call   <puts@plt>
  lea    D25(%rip),%rdi
  call   <puts@plt>
  lea    D88(%rip),%rbx
  mov    %rbx,%rdx
  mov    %rbx,%rsi
  lea    D642(%rip),%rdi
  call   <affiche2.5>
  lea    D308(%rip),%r13
  mov    %r13,%rdx
  mov    %rbx,%rsi
  lea    D127(%rip),%rdi
  call   <affiche2.5>
  mov    %r13,%rdx
  lea    D24(%rip),%r12
  mov    %r12,%rsi
  lea    D174(%rip),%rdi
  call   <affiche2.5>
  lea    D557(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D214(%rip),%rdi
  call   <puts@plt>
  lea    D238(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D217(%rip),%rdi
  call   <puts@plt>
  lea    D580(%rip),%rdi
  call   <puts@plt>
  lea    D520(%rip),%rdi
  call   <puts@plt>
  mov    %rbx,%rdx
  mov    %rbx,%rsi
  lea    D154(%rip),%r14
  mov    %r14,%rdi
  call   <affiche2.5>
  mov    %r12,%rdx
  mov    %r12,%rsi
  lea    D644(%rip),%rdi
  call   <affiche2.5>
  lea    D568(%rip),%r15
  mov    %r15,%rdx
  mov    %r15,%rsi
  lea    D403(%rip),%rdi
  call   <affiche2.5>
  lea    D241(%rip),%rdi
  call   <puts@plt>
  lea    D341(%rip),%rdi
  call   <puts@plt>
  lea    D273(%rip),%r12
  mov    %r12,%rdx
  mov    %r12,%rsi
  lea    D644(%rip),%rdi
  call   <affiche2.5>
  lea    D71(%rip),%rdi
  call   <puts@plt>
  lea    D6(%rip),%rdi
  call   <puts@plt>
  lea    D299(%rip),%rdi
  call   <puts@plt>
  lea    D626(%rip),%rdi
  call   <puts@plt>
  mov    %rbx,%rdx
  mov    %r15,%rsi
  mov    %r14,%rdi
  call   <affiche2.5>
  lea    D643(%rip),%rdi
  call   <puts@plt>
  mov    %rbx,%rdx
  mov    %rbx,%rsi
  mov    %r14,%rdi
  call   <affiche2.5>
  lea    D326(%rip),%rdi
  call   <puts@plt>
  lea    D27(%rip),%rdi
  call   <puts@plt>
  lea    D482(%rip),%rdi
  call   <puts@plt>
  lea    D105(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%r8d
  lea    D620(%rip),%r15
  mov    %r15,%rcx
  mov    $0x1,%edx
  lea    D10(%rip),%r14
  mov    %r14,%rsi
  lea    D588(%rip),%rbx
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D59(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%r8d
  mov    %r15,%rcx
  mov    $0x1,%edx
  mov    %r14,%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D640(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%r8d
  mov    %r15,%rcx
  mov    $0x2,%edx
  mov    %r14,%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D47(%rip),%rdi
  call   <puts@plt>
  lea    D412(%rip),%rdi
  call   <puts@plt>
  lea    D14(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%r8d
  lea    D200(%rip),%r15
  mov    %r15,%rcx
  mov    $0x2,%edx
  lea    D483(%rip),%r14
  mov    %r14,%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D55(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%r8d
  mov    %r15,%rcx
  mov    $0x2,%edx
  mov    %r14,%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D530(%rip),%rdi
  call   <puts@plt>
  lea    D14(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x1,%r8d
  mov    %r15,%rcx
  mov    $0x2,%edx
  mov    %r14,%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D55(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    $0x2,%r8d
  mov    %r15,%rcx
  mov    $0x1,%edx
  mov    %r14,%rsi
  mov    %rbx,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D515(%rip),%rdi
  call   <puts@plt>
  mov    %r13,%rdx
  mov    %r12,%rsi
  lea    D208(%rip),%rdi
  call   <affiche2.5>
  movl   $0x20736f64,-0x42(%rbp)
  movb   $0x0,-0x3e(%rbp)
  movl   $0x78756564,-0x3d(%rbp)
  movb   $0x0,-0x39(%rbp)
  mov    %rsp,-0x60(%rbp)
  lea    -0x3d(%rbp),%rdi
  call   <strlen@plt>
  mov    %rax,%rbx
  lea    -0x42(%rbp),%r12
  mov    %r12,%rdi
  call   <strlen@plt>
  mov    %rax,%rsi
  mov    %rbx,%rdx
  lea    D529(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %r12,%rdi
  call   <strlen@plt>
  cltq
  add    $0xf,%rax
  mov    %rax,%rcx
  and    $0xfffffffffffffff0,%rcx
  and    $0xfffffffffffff000,%rax
  mov    %rsp,%rdx
  sub    %rax,%rdx
L89:
  cmp    %rdx,%rsp
  je     L37
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  jmp    L89
L37:
  mov    %rcx,%rax
  and    $0xfff,%eax
  sub    %rax,%rsp
  test   %rax,%rax
  je     L85
  orq    $0x0,-0x8(%rsp,%rax,1)
L85:
  lea    0x1(%rsp),%rax
  movzbl -0x42(%rbp),%edx
  mov    %dl,(%rsp)
  test   %dl,%dl
  je     L111
  mov    %rax,%rbx
  lea    -0x41(%rbp),%r12
  mov    $0x1,%r14d
  sub    %eax,%r14d
  lea    D348(%rip),%r15
L80:
  lea    (%r14,%rbx,1),%r13d
  mov    %r13d,%esi
  mov    %r15,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  add    $0x1,%r12
  add    $0x1,%rbx
  movzbl -0x1(%r12),%eax
  mov    %al,-0x1(%rbx)
  test   %al,%al
  jne    L80
L15:
  movslq %r13d,%r13
  not    %r13
  add    %r13,%r12
  add    %r13,%rbx
  mov    %r12,%rsi
  lea    D349(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    0x1(%r12),%rdx
  movzbl -0x3d(%rbp),%eax
  mov    %al,(%r12)
  test   %al,%al
  je     L1
  mov    %rdx,%r12
  lea    -0x3c(%rbp),%r13
  mov    $0x1,%eax
  sub    %edx,%eax
  mov    %eax,-0x54(%rbp)
  lea    D348(%rip),%r15
L60:
  mov    -0x54(%rbp),%eax
  lea    (%rax,%r12,1),%r14d
  mov    %r14d,%esi
  mov    %r15,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  add    $0x1,%r13
  add    $0x1,%r12
  movzbl -0x1(%r13),%eax
  mov    %al,-0x1(%r12)
  test   %al,%al
  jne    L60
L67:
  movslq %r14d,%r14
  not    %r14
  add    %r14,%r13
  lea    (%r12,%r14,1),%rsi
  lea    D349(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    0x1(%r13),%r14
  movzbl (%rbx),%eax
  mov    %al,0x0(%r13)
  test   %al,%al
  je     L128
  mov    $0x1,%r12d
  lea    D348(%rip),%r15
L75:
  mov    %r12d,%r13d
  mov    %r12d,%esi
  mov    %r15,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  add    $0x1,%r14
  movzbl (%rbx,%r12,1),%eax
  mov    %al,-0x1(%r14)
  add    $0x1,%r12
  test   %al,%al
  jne    L75
L48:
  movslq %r13d,%r13
  not    %r13
  lea    (%r14,%r13,1),%rsi
  lea    D256(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x60(%rbp),%rsp
  lea    -0x3d(%rbp),%rdx
  lea    -0x42(%rbp),%rsi
  lea    D9(%rip),%rdi
  call   <affiche2.5>
  lea    D553(%rip),%rdi
  call   <puts@plt>
  lea    D163(%rip),%rdi
  call   <puts@plt>
  mov    -0x38(%rbp),%rax
  sub    %fs:0x28,%rax
  jne    L99
  mov    $0x0,%eax
  lea    -0x28(%rbp),%rsp
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  pop    %rbp
  ret
L111:
  mov    %rax,%rbx
  lea    -0x41(%rbp),%r12
  mov    $0x0,%r13d
  jmp    L15
L1:
  mov    %rdx,%r12
  lea    -0x3c(%rbp),%r13
  mov    $0x0,%r14d
  jmp    L67
L128:
  mov    $0x0,%r13d
  jmp    L48
L99:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: disassemble_data
arguments: label: D514
type_infered: string
name: disassemble_data
arguments: label: D435
type_infered: string
name: disassemble_data
arguments: label: D82
type_infered: string
name: disassemble_data
arguments: label: D354
type_infered: string
name: disassemble_data
arguments: label: D121
type_infered: string
name: disassemble_data
arguments: label: D260
type_infered: string
name: disassemble_data
arguments: label: D11
type_infered: string
name: disassemble_data
arguments: label: D455
type_infered: string
name: disassemble_data
arguments: label: D526
type_infered: string
name: disassemble_data
arguments: label: D25
type_infered: string
name: disassemble_data
arguments: label: D88
type_infered: string
name: disassemble_data
arguments: label: D642
type_infered: string
name: disassemble_data
arguments: label: D308
type_infered: string
name: disassemble_data
arguments: label: D127
type_infered: string
name: disassemble_data
arguments: label: D24
type_infered: string
name: disassemble_data
arguments: label: D174
type_infered: string
name: disassemble_data
arguments: label: D557
type_infered: string
name: disassemble_data
arguments: label: D214
type_infered: string
name: disassemble_data
arguments: label: D238
type_infered: string
name: disassemble_data
arguments: label: D217
type_infered: string
name: disassemble_data
arguments: label: D580
type_infered: string
name: disassemble_data
arguments: label: D520
type_infered: string
name: disassemble_data
arguments: label: D154
type_infered: string
name: disassemble_data
arguments: label: D644
type_infered: string
name: disassemble_data
arguments: label: D568
type_infered: string
name: disassemble_data
arguments: label: D403
type_infered: string
name: disassemble_data
arguments: label: D241
type_infered: string
name: disassemble_data
arguments: label: D341
type_infered: string
name: disassemble_data
arguments: label: D273
type_infered: string
name: disassemble_data
arguments: label: D71
type_infered: string
name: disassemble_data
arguments: label: D6
type_infered: string
name: disassemble_data
arguments: label: D299
type_infered: string
name: disassemble_data
arguments: label: D626
type_infered: string
name: disassemble_data
arguments: label: D643
type_infered: string
name: disassemble_data
arguments: label: D326
type_infered: string
name: disassemble_data
arguments: label: D27
type_infered: string
name: disassemble_data
arguments: label: D482
type_infered: string
name: disassemble_data
arguments: label: D105
type_infered: string
name: disassemble_data
arguments: label: D620
type_infered: string
name: disassemble_data
arguments: label: D10
type_infered: string
name: disassemble_data
arguments: label: D588
type_infered: string
name: disassemble_data
arguments: label: D59
type_infered: string
name: disassemble_data
arguments: label: D640
type_infered: string
name: disassemble_data
arguments: label: D47
type_infered: string
name: disassemble_data
arguments: label: D412
type_infered: string
name: disassemble_data
arguments: label: D14
type_infered: string
name: disassemble_data
arguments: label: D200
type_infered: string
name: disassemble_data
arguments: label: D483
type_infered: string
name: disassemble_data
arguments: label: D55
type_infered: string
name: disassemble_data
arguments: label: D530
type_infered: string
name: disassemble_data
arguments: label: D515
type_infered: string
name: disassemble_data
arguments: label: D208
type_infered: string
name: disassemble_data
arguments: label: D529
type_infered: string
name: disassemble_data
arguments: label: D348
type_infered: string
name: disassemble_data
arguments: label: D349
type_infered: string
name: disassemble_data
arguments: label: D256
type_infered: string
name: disassemble_data
arguments: label: D9
type_infered: string
name: disassemble_data
arguments: label: D553
type_infered: string
name: disassemble_data
arguments: label: D163
type_infered: string

tool: D514: i : %d - j : %d


tool: D435: affichage pi et pj

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

tool: D354: cette fois *pi a 3

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

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

tool: D11: on affiche *pi

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

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

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

tool: D88: un 

tool: D642: tabD,tabS

tool: D308: deux

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

tool: D24: 2 

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

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

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

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

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

tool: D580: prenons char **tabT

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

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

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

tool: D568: 3 

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

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

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

tool: D273: dos 

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

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

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

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

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

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

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

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

tool: D105: depart :

tool: D620: b

tool: D10: a

tool: D588: %s : %d - %s : %d


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

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

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

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

tool: D14: avant : 

tool: D200: *pb

tool: D483: *pa

tool: D55: apres : 

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

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

tool: D208: *pD,*pS

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

tool: D348: %d

tool: D349: int : %s 


tool: D256: fin : %s


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

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

tool: D163: 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");
}
```