user: Demonstrate the C code that generates the assembly output below:

```asm
<main>:
  endbr64
  push   %rbp
  mov    $0x2,%edx
  mov    $0x3,%esi
  mov    %rsp,%rbp
  push   %r15
  lea    D639(%rip),%r15
  push   %r14
  lea    D247(%rip),%r14
  push   %r13
  lea    D49(%rip),%r13
  push   %r12
  lea    D588(%rip),%r12
  push   %rbx
  mov    %r12,%rdi
  lea    D396(%rip),%rbx
  sub    $0x48,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,-0x38(%rbp)
  xor    %eax,%eax
  call   <printf@plt>
  lea    D148(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x3,%esi
  call   <printf@plt>
  lea    D430(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x4,%esi
  call   <printf@plt>
  lea    D387(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x3,%esi
  call   <printf@plt>
  lea    D309(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x3,%esi
  call   <printf@plt>
  lea    D379(%rip),%rdi
  call   <puts@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x4,%esi
  call   <printf@plt>
  lea    D298(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    $0x2,%edx
  mov    %r12,%rdi
  xor    %eax,%eax
  mov    $0x4,%esi
  lea    D84(%rip),%r12
  call   <printf@plt>
  lea    D56(%rip),%rdi
  call   <puts@plt>
  lea    D488(%rip),%rdi
  call   <puts@plt>
  lea    D230(%rip),%rdi
  call   <puts@plt>
  mov    %r12,%rcx
  mov    %r12,%rdx
  mov    %r13,%rdi
  lea    D428(%rip),%rsi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %r12,%rdx
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D389(%rip),%r9
  lea    D191(%rip),%rsi
  mov    %r9,%rcx
  call   <printf@plt>
  mov    %r15,%rdx
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D389(%rip),%r9
  lea    D171(%rip),%rsi
  mov    %r9,%rcx
  call   <printf@plt>
  xor    %eax,%eax
  lea    D3(%rip),%rdi
  call   <printf@plt>
  lea    D350(%rip),%rdi
  call   <puts@plt>
  lea    D195(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D640(%rip),%rdi
  call   <puts@plt>
  lea    D591(%rip),%rdi
  call   <puts@plt>
  lea    D334(%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    D275(%rip),%r8
  lea    D212(%rip),%r15
  xor    %eax,%eax
  mov    %r8,%rsi
  call   <printf@plt>
  mov    %r15,%rcx
  mov    %r15,%rdx
  mov    %r13,%rdi
  lea    D270(%rip),%rsi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D484(%rip),%rdi
  call   <puts@plt>
  lea    D224(%rip),%rdi
  call   <puts@plt>
  mov    %rbx,%rcx
  mov    %rbx,%rdx
  mov    %r13,%rdi
  lea    D275(%rip),%r8
  xor    %eax,%eax
  mov    %r8,%rsi
  call   <printf@plt>
  lea    D464(%rip),%rdi
  call   <puts@plt>
  lea    D383(%rip),%rdi
  call   <puts@plt>
  lea    D139(%rip),%rdi
  call   <puts@plt>
  lea    D467(%rip),%rdi
  call   <puts@plt>
  mov    %r12,%rcx
  mov    %r15,%rdx
  mov    %r14,%rsi
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D219(%rip),%r15
  call   <printf@plt>
  lea    D621(%rip),%rdi
  call   <puts@plt>
  mov    %r12,%rcx
  mov    %r12,%rdx
  mov    %r14,%rsi
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D485(%rip),%r12
  call   <printf@plt>
  lea    D246(%rip),%rdi
  lea    D364(%rip),%r14
  call   <puts@plt>
  lea    D619(%rip),%rdi
  call   <puts@plt>
  lea    D156(%rip),%rdi
  call   <puts@plt>
  lea    D333(%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    D134(%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    D64(%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    D210(%rip),%rdi
  lea    D662(%rip),%r15
  call   <puts@plt>
  lea    D116(%rip),%rdi
  lea    D331(%rip),%r14
  call   <puts@plt>
  lea    D48(%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    D57(%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    D145(%rip),%rdi
  call   <puts@plt>
  lea    D48(%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    D57(%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    D357(%rip),%rdi
  call   <puts@plt>
  mov    %rbx,%rdx
  mov    %r13,%rdi
  xor    %eax,%eax
  lea    D389(%rip),%r9
  lea    D271(%rip),%rsi
  mov    %r9,%rcx
  call   <printf@plt>
  mov    $0x4,%edx
  xor    %eax,%eax
  movb   $0x0,-0x3e(%rbp)
  mov    $0x4,%esi
  lea    D123(%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     L59
L11:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rcx,%rsp
  jne    L11
L59:
  and    $0xfff,%edx
  sub    %rdx,%rsp
  test   %rdx,%rdx
  jne    L16
L123:
  movzbl -0x42(%rbp),%eax
  lea    0x1(%rsp),%rbx
  lea    -0x41(%rbp),%r15
  mov    %al,(%rsp)
  test   %al,%al
  je     L1
  mov    $0x1,%r14d
  lea    D71(%rip),%r12
  sub    %ebx,%r14d
  mov    %r14d,-0x58(%rbp)
  nopl   (%rax)
L77:
  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    L77
L57:
  movslq %r14d,%rdx
  lea    D512(%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     L87
  mov    $0x1,%r14d
  lea    D71(%rip),%r12
  sub    %edx,%r14d
  mov    %r14d,-0x5c(%rbp)
  nopl   0x0(%rax,%rax,1)
L125:
  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    L125
L34:
  movslq %r14d,%rsi
  lea    D512(%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     L113
  mov    $0x1,%r14d
  lea    D71(%rip),%r12
  nopl   0x0(%rax,%rax,1)
L21:
  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    L21
L103:
  movslq %ebx,%rdx
  lea    D413(%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    D513(%rip),%rsi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D169(%rip),%rdi
  call   <puts@plt>
  lea    D244(%rip),%rdi
  call   <puts@plt>
  mov    -0x38(%rbp),%rax
  sub    %fs:0x28,%rax
  jne    L48
  lea    -0x28(%rbp),%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  pop    %rbp
  ret
L16:
  orq    $0x0,-0x8(%rsp,%rdx,1)
  jmp    L123
L113:
  xor    %ebx,%ebx
  jmp    L103
L87:
  xor    %r14d,%r14d
  jmp    L34
L1:
  xor    %r14d,%r14d
  jmp    L57
L48:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: read_data
arguments: tag: D639
type_guessed: string
name: read_data
arguments: tag: D247
type_guessed: string
name: read_data
arguments: tag: D49
type_guessed: string
name: read_data
arguments: tag: D588
type_guessed: string
name: read_data
arguments: tag: D396
type_guessed: string
name: read_data
arguments: tag: D148
type_guessed: string
name: read_data
arguments: tag: D430
type_guessed: string
name: read_data
arguments: tag: D387
type_guessed: string
name: read_data
arguments: tag: D309
type_guessed: string
name: read_data
arguments: tag: D379
type_guessed: string
name: read_data
arguments: tag: D298
type_guessed: string
name: read_data
arguments: tag: D84
type_guessed: string
name: read_data
arguments: tag: D56
type_guessed: string
name: read_data
arguments: tag: D488
type_guessed: string
name: read_data
arguments: tag: D230
type_guessed: string
name: read_data
arguments: tag: D428
type_guessed: string
name: read_data
arguments: tag: D389
type_guessed: string
name: read_data
arguments: tag: D191
type_guessed: string
name: read_data
arguments: tag: D171
type_guessed: string
name: read_data
arguments: tag: D3
type_guessed: string
name: read_data
arguments: tag: D350
type_guessed: string
name: read_data
arguments: tag: D195
type_guessed: string
name: read_data
arguments: tag: D640
type_guessed: string
name: read_data
arguments: tag: D591
type_guessed: string
name: read_data
arguments: tag: D334
type_guessed: string
name: read_data
arguments: tag: D275
type_guessed: string
name: read_data
arguments: tag: D212
type_guessed: string
name: read_data
arguments: tag: D270
type_guessed: string
name: read_data
arguments: tag: D484
type_guessed: string
name: read_data
arguments: tag: D224
type_guessed: string
name: read_data
arguments: tag: D464
type_guessed: string
name: read_data
arguments: tag: D383
type_guessed: string
name: read_data
arguments: tag: D139
type_guessed: string
name: read_data
arguments: tag: D467
type_guessed: string
name: read_data
arguments: tag: D219
type_guessed: string
name: read_data
arguments: tag: D621
type_guessed: string
name: read_data
arguments: tag: D485
type_guessed: string
name: read_data
arguments: tag: D246
type_guessed: string
name: read_data
arguments: tag: D364
type_guessed: string
name: read_data
arguments: tag: D619
type_guessed: string
name: read_data
arguments: tag: D156
type_guessed: string
name: read_data
arguments: tag: D333
type_guessed: string
name: read_data
arguments: tag: D134
type_guessed: string
name: read_data
arguments: tag: D64
type_guessed: string
name: read_data
arguments: tag: D210
type_guessed: string
name: read_data
arguments: tag: D662
type_guessed: string
name: read_data
arguments: tag: D116
type_guessed: string
name: read_data
arguments: tag: D331
type_guessed: string
name: read_data
arguments: tag: D48
type_guessed: string
name: read_data
arguments: tag: D57
type_guessed: string
name: read_data
arguments: tag: D145
type_guessed: string
name: read_data
arguments: tag: D357
type_guessed: string
name: read_data
arguments: tag: D271
type_guessed: string
name: read_data
arguments: tag: D123
type_guessed: string
name: read_data
arguments: tag: D71
type_guessed: string
name: read_data
arguments: tag: D512
type_guessed: string
name: read_data
arguments: tag: D413
type_guessed: string
name: read_data
arguments: tag: D513
type_guessed: string
name: read_data
arguments: tag: D169
type_guessed: string
name: read_data
arguments: tag: D244
type_guessed: string

tool: D639: 2 

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

tool: D49: %s : %s,%s


tool: D588: i : %d - j : %d


tool: D396: dos 

tool: D148: affichage pi et pj

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

tool: D387: cette fois *pi a 3

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

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

tool: D298: on affiche *pi

tool: D84: un 

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

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

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

tool: D428: tabD,tabS

tool: D389: deux

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

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

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

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

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

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

tool: D591: prenons char **tabT

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

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

tool: D212: 3 

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

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

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

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

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

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

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

tool: D219: b

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

tool: D485: %s : %d - %s : %d


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

tool: D364: a

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

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

tool: D333: depart :

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

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

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

tool: D662: *pb

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

tool: D331: *pa

tool: D48: avant : 

tool: D57: apres : 

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

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

tool: D271: *pD,*pS

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

tool: D71: %d

tool: D512: int : %s 


tool: D413: fin : %s


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

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

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