user: 请显示与下面列出的汇编代码相匹配的C语言实现:

```asm
<main>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  sub    $0xb0,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,-0x8(%rbp)
  xor    %eax,%eax
  lea    0x10(%rbp),%rax
  mov    %rax,-0x98(%rbp)
  movl   $0x3,-0xa8(%rbp)
  movl   $0x2,-0xa4(%rbp)
  lea    -0xa8(%rbp),%rax
  mov    %rax,-0x90(%rbp)
  lea    -0xa4(%rbp),%rax
  mov    %rax,-0x88(%rbp)
  mov    -0xa4(%rbp),%edx
  mov    -0xa8(%rbp),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%esi
  mov    %eax,%edi
  call   <affiche.0>
  lea    D415(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    -0x88(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x90(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%esi
  mov    %eax,%edi
  call   <affiche.0>
  lea    D164(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  movl   $0x4,-0xa8(%rbp)
  mov    -0x88(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x90(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%esi
  mov    %eax,%edi
  call   <affiche.0>
  lea    D480(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x90(%rbp),%rax
  movl   $0x3,(%rax)
  mov    -0x88(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x90(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%esi
  mov    %eax,%edi
  call   <affiche.0>
  lea    D195(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    -0x90(%rbp),%rax
  mov    %rax,-0x80(%rbp)
  mov    -0x88(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x80(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%esi
  mov    %eax,%edi
  call   <affiche.0>
  lea    D692(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  movl   $0x4,-0xa8(%rbp)
  mov    -0x88(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x80(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%esi
  mov    %eax,%edi
  call   <affiche.0>
  lea    D513(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x88(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x90(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%esi
  mov    %eax,%edi
  call   <affiche.0>
  lea    D148(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D41(%rip),%rax
  mov    %rax,-0x50(%rbp)
  lea    D320(%rip),%rax
  mov    %rax,-0x48(%rbp)
  lea    D316(%rip),%rax
  mov    %rax,-0x40(%rbp)
  lea    D411(%rip),%rax
  mov    %rax,-0x30(%rbp)
  lea    D652(%rip),%rax
  mov    %rax,-0x28(%rbp)
  lea    D607(%rip),%rax
  mov    %rax,-0x20(%rbp)
  mov    -0x50(%rbp),%rax
  mov    %rax,-0x30(%rbp)
  lea    D509(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D279(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    -0x50(%rbp),%rdx
  mov    -0x30(%rbp),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D423(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  mov    -0x48(%rbp),%rdx
  mov    -0x30(%rbp),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D399(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  mov    -0x48(%rbp),%rdx
  mov    -0x28(%rbp),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D527(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  lea    D158(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D23(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D262(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D522(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D420(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D46(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x30(%rbp),%rax
  mov    %rax,-0x78(%rbp)
  mov    -0x30(%rbp),%rdx
  mov    -0x78(%rbp),%rax
  mov    (%rax),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D668(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  mov    -0x28(%rbp),%rdx
  mov    -0x78(%rbp),%rax
  add    $0x8,%rax
  mov    (%rax),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D472(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  mov    -0x20(%rbp),%rdx
  mov    -0x78(%rbp),%rax
  add    $0x10,%rax
  mov    (%rax),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D678(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  lea    D519(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D338(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    -0x78(%rbp),%rax
  add    $0x8,%rax
  lea    D370(%rip),%rdx
  mov    %rdx,(%rax)
  mov    -0x28(%rbp),%rdx
  mov    -0x78(%rbp),%rax
  add    $0x8,%rax
  mov    (%rax),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D472(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  lea    D493(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D165(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D272(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D529(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  addq   $0x8,-0x78(%rbp)
  addq   $0x8,-0x78(%rbp)
  mov    -0x30(%rbp),%rdx
  mov    -0x78(%rbp),%rax
  mov    (%rax),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D668(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  lea    D691(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  subq   $0x10,-0x78(%rbp)
  mov    -0x30(%rbp),%rdx
  mov    -0x78(%rbp),%rax
  mov    (%rax),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D668(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  lea    D321(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D557(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D180(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  movl   $0x1,-0xa0(%rbp)
  movl   $0x2,-0x9c(%rbp)
  lea    D492(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    -0x9c(%rbp),%edx
  mov    -0xa0(%rbp),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%ecx
  mov    %eax,%edx
  lea    D137(%rip),%rax
  mov    %rax,%rsi
  lea    D346(%rip),%rax
  mov    %rax,%rdi
  call   <affiche3.3>
  lea    D348(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    -0x9c(%rbp),%edx
  mov    -0xa0(%rbp),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%esi
  mov    %eax,%edi
  call   <ech1.1>
  mov    -0x9c(%rbp),%edx
  mov    -0xa0(%rbp),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%ecx
  mov    %eax,%edx
  lea    D137(%rip),%rax
  mov    %rax,%rsi
  lea    D346(%rip),%rax
  mov    %rax,%rdi
  call   <affiche3.3>
  lea    D276(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x9c(%rbp),%rdx
  lea    -0xa0(%rbp),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <ech2.2>
  mov    -0x9c(%rbp),%edx
  mov    -0xa0(%rbp),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%ecx
  mov    %eax,%edx
  lea    D137(%rip),%rax
  mov    %rax,%rsi
  lea    D346(%rip),%rax
  mov    %rax,%rdi
  call   <affiche3.3>
  lea    D340(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x9c(%rbp),%rax
  mov    %rax,-0x70(%rbp)
  lea    -0xa0(%rbp),%rax
  mov    %rax,-0x68(%rbp)
  lea    D136(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D222(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x70(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x68(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%ecx
  mov    %eax,%edx
  lea    D94(%rip),%rax
  mov    %rax,%rsi
  lea    D297(%rip),%rax
  mov    %rax,%rdi
  call   <affiche3.3>
  mov    -0x70(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x68(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%esi
  mov    %eax,%edi
  call   <ech1.1>
  lea    D140(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x70(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x68(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%ecx
  mov    %eax,%edx
  lea    D94(%rip),%rax
  mov    %rax,%rsi
  lea    D297(%rip),%rax
  mov    %rax,%rdi
  call   <affiche3.3>
  lea    D613(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D222(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x70(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x68(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%ecx
  mov    %eax,%edx
  lea    D94(%rip),%rax
  mov    %rax,%rsi
  lea    D297(%rip),%rax
  mov    %rax,%rdi
  call   <affiche3.3>
  mov    -0x70(%rbp),%rdx
  mov    -0x68(%rbp),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <ech2.2>
  lea    D140(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    -0x70(%rbp),%rax
  mov    (%rax),%edx
  mov    -0x68(%rbp),%rax
  mov    (%rax),%eax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %edx,%ecx
  mov    %eax,%edx
  lea    D94(%rip),%rax
  mov    %rax,%rsi
  lea    D297(%rip),%rax
  mov    %rax,%rdi
  call   <affiche3.3>
  lea    D559(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x30(%rbp),%rax
  mov    %rax,-0x60(%rbp)
  lea    -0x50(%rbp),%rax
  mov    %rax,-0x58(%rbp)
  mov    -0x58(%rbp),%rax
  add    $0x8,%rax
  mov    (%rax),%rdx
  mov    -0x60(%rbp),%rax
  add    $0x8,%rax
  mov    (%rax),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D391(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  movl   $0x20736f64,-0x12(%rbp)
  movb   $0x0,-0xe(%rbp)
  movl   $0x78756564,-0xd(%rbp)
  movb   $0x0,-0x9(%rbp)
  lea    -0xd(%rbp),%rdx
  lea    -0x12(%rbp),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <ech3.4>
  lea    -0xd(%rbp),%rdx
  lea    -0x12(%rbp),%rax
  lea    -0x98(%rbp),%rcx
  mov    %rcx,%r10
  mov    %rax,%rsi
  lea    D590(%rip),%rax
  mov    %rax,%rdi
  call   <affiche2.5>
  lea    D125(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D567(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  mov    $0x0,%eax
  mov    -0x8(%rbp),%rdx
  sub    %fs:0x28,%rdx
  je     L5
  call   <__stack_chk_fail@plt>
L5:
  leave
  ret
```

tool_calls: name: extract_symbolic_data
arguments: data_label: D415
data_type: string
name: extract_symbolic_data
arguments: data_label: D164
data_type: string
name: extract_symbolic_data
arguments: data_label: D480
data_type: string
name: extract_symbolic_data
arguments: data_label: D195
data_type: string
name: extract_symbolic_data
arguments: data_label: D692
data_type: string
name: extract_symbolic_data
arguments: data_label: D513
data_type: string
name: extract_symbolic_data
arguments: data_label: D148
data_type: string
name: extract_symbolic_data
arguments: data_label: D41
data_type: string
name: extract_symbolic_data
arguments: data_label: D320
data_type: string
name: extract_symbolic_data
arguments: data_label: D316
data_type: string
name: extract_symbolic_data
arguments: data_label: D411
data_type: string
name: extract_symbolic_data
arguments: data_label: D652
data_type: string
name: extract_symbolic_data
arguments: data_label: D607
data_type: string
name: extract_symbolic_data
arguments: data_label: D509
data_type: string
name: extract_symbolic_data
arguments: data_label: D279
data_type: string
name: extract_symbolic_data
arguments: data_label: D423
data_type: string
name: extract_symbolic_data
arguments: data_label: D399
data_type: string
name: extract_symbolic_data
arguments: data_label: D527
data_type: string
name: extract_symbolic_data
arguments: data_label: D158
data_type: string
name: extract_symbolic_data
arguments: data_label: D23
data_type: string
name: extract_symbolic_data
arguments: data_label: D262
data_type: string
name: extract_symbolic_data
arguments: data_label: D522
data_type: string
name: extract_symbolic_data
arguments: data_label: D420
data_type: string
name: extract_symbolic_data
arguments: data_label: D46
data_type: string
name: extract_symbolic_data
arguments: data_label: D668
data_type: string
name: extract_symbolic_data
arguments: data_label: D472
data_type: string
name: extract_symbolic_data
arguments: data_label: D678
data_type: string
name: extract_symbolic_data
arguments: data_label: D519
data_type: string
name: extract_symbolic_data
arguments: data_label: D338
data_type: string
name: extract_symbolic_data
arguments: data_label: D370
data_type: string
name: extract_symbolic_data
arguments: data_label: D493
data_type: string
name: extract_symbolic_data
arguments: data_label: D165
data_type: string
name: extract_symbolic_data
arguments: data_label: D272
data_type: string
name: extract_symbolic_data
arguments: data_label: D529
data_type: string
name: extract_symbolic_data
arguments: data_label: D691
data_type: string
name: extract_symbolic_data
arguments: data_label: D321
data_type: string
name: extract_symbolic_data
arguments: data_label: D557
data_type: string
name: extract_symbolic_data
arguments: data_label: D180
data_type: string
name: extract_symbolic_data
arguments: data_label: D492
data_type: string
name: extract_symbolic_data
arguments: data_label: D137
data_type: string
name: extract_symbolic_data
arguments: data_label: D346
data_type: string
name: extract_symbolic_data
arguments: data_label: D348
data_type: string
name: extract_symbolic_data
arguments: data_label: D276
data_type: string
name: extract_symbolic_data
arguments: data_label: D340
data_type: string
name: extract_symbolic_data
arguments: data_label: D136
data_type: string
name: extract_symbolic_data
arguments: data_label: D222
data_type: string
name: extract_symbolic_data
arguments: data_label: D94
data_type: string
name: extract_symbolic_data
arguments: data_label: D297
data_type: string
name: extract_symbolic_data
arguments: data_label: D140
data_type: string
name: extract_symbolic_data
arguments: data_label: D613
data_type: string
name: extract_symbolic_data
arguments: data_label: D559
data_type: string
name: extract_symbolic_data
arguments: data_label: D391
data_type: string
name: extract_symbolic_data
arguments: data_label: D590
data_type: string
name: extract_symbolic_data
arguments: data_label: D125
data_type: string
name: extract_symbolic_data
arguments: data_label: D567
data_type: string

tool: D415: affichage pi et pj

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

tool: D480: cette fois *pi a 3

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

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

tool: D513: on affiche *pi

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

tool: D41: un 

tool: D320: deux

tool: D316: trois

tool: D411: 1 

tool: D652: 2 

tool: D607: 3 

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

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

tool: D423: tabD,tabS

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

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

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

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

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

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

tool: D420: prenons char **tabT

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

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

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

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

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

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

tool: D370: dos 

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

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

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

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

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

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

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

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

tool: D492: depart :

tool: D137: b

tool: D346: a

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

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

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

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

tool: D222: avant : 

tool: D94: *pb

tool: D297: *pa

tool: D140: apres : 

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

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

tool: D391: *pD,*pS

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

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

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