Je n'arrive pas a quitter depuis une SDL_ShowSimpleMessageBox.

**Luke spywoker** · 14/09/2016, 17h15

Salut les SDL,

je développe en ce moment un jeu qui se joue a la manette et donc au démarrage il y a un test qui vérifie si un joystick (une manette) est branché ou non.

Et donc cela donne en pseudo code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
int main(void) {
 
  initialisation :
 
  // initialisation of SDL2.
 
  if (not paddle_is_connect) {
 
    std::string msg{"No paddle nor joystick detected.\nPlease connect a paddle or\nany instrument used to control a video game please."}
 
    SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_WARNING, "No paddle nor joystick detected !", msg.c_str(), NULL);
 
    SDL_Quit() ; // Necessary call for the jump.
 
    goto initialisation ;
 
  }
 
}

Et mon problème est que j'aimerai pouvoir donner a l'utilisateur la possibilité de quitter le jeu pendant l'affichage du message, seulement la SDL2 ne prévoit qu'un seule bouton activer par un appuie sur RETURN ou ESCAPE.

Car si vous regardez le code de plus près vous verrez, sans nul doutes, que cela est impossible et que l'utilisateur revient constamment au message lui demandant de plugger une manette...

Je pourrai bien sur quitter le jeu simplement si aucune manette n'est détecter mais ce n'est pas dans mes intentions.

J'ai bien sur fait des essaies infructueux d'appuis sur des touches du clavier ou sur la souris mais cela n'a rien donner.

Vous seriez sympa de bien vouloir m'aider si vous le pouvez.

Je vous remercie pour vos réponses éclairées.

PS: Apparemment il y a une probable solution içi.

**Mat.M** · 14/09/2016, 17h32

houlala il y a une grosse erreur dans ton code: tu utilises d'une part un goto on évite le plus possible les goto ( c'est une instruction qui était valable du temps du basic )
Ensuite s'il n'y a pas de joystick tu appelles SDL_Quit qui désalloue toutes les SDL_Surfaces bref les objets graphiques en mémoire vidéo ( ou RAM tout court )
Mais ce n'est pas SDL_Quit qui met fin au programme et tu boucles toujours..

Envoyé par Luke spywoker

Et mon problème est que j'aimerai pouvoir donner a l'utilisateur la possibilité de quitter le jeu pendant l'affichage du message,

Je pourrai bien sur quitter le jeu simplement si aucune manette n'est détecter mais ce n'est pas dans mes intentions.

je ne comprends absolument rien à ce que tu veux faire : un coup tu veux que l'utilisateur puisse quitter le programme un autre tu veux pas...
est-ce que c'est possible de détailler par étapes et de manière méthodique 1)je fais ceci 2)je fais cela 3)...

**Luke spywoker** · 15/09/2016, 07h51

C'est pas grave c'est régler grâce a cet example.

Le sujet est clos.

Par contre j'utilise goto si je veut jump quelque part (goto a quand même une utilité, non ?).

Et comme avant de faire le test il n'y a que des instructions d'initialisation de la SDL2

il faut appeler les fonctions de *_Quit() des différents modules de la SDL2 que j'utilise sauf SDL_Quit() bien sur, comme je jump au début, cela est une erreur de ma part dans ce poste, désolé.

Merci.

**LittleWhite** · 15/09/2016, 13h46

Bonjour,

Le goto est un mot clé à bannir dans 99% des utilisations. La seule utilisation correcte dont je me rappelle (et on pourra retrouver ce conseil sur le forum) c'est lors du traitement des cas d'erreurs et où il est nécessaire de faire du nettoyage/libération de ressource et cela, uniquement en C.
Dans votre cas, un while semble suffire

**Luke spywoker** · 16/09/2016, 12h19

Comme je dois déinitialiser tous les modules comme SDL_ttf, SDL_image, etc... par ttf_Quit(), etc...

J'utilise goto pour revenir au début du programme.

Et goto sous peine que ce soit une vieille instruction n'est point a bannir du tout je pense.

Je pense au contraire que goto est nécessaire là il faut faire un jump locale.

D'ailleurs j'utilise goto plusieurs fois dans mon programme.

Et en plus goto me rappelle l'assembleur et est indispensable dans la programmation kernel driver.

Donc vous voyez je ne suis pas de votre avis concernant goto.

Rien de personnel, seulement des opinions divergentes.

Luke Spywoker.

PS: Et en plus j'aime les switch quand ils peuvent remplacer avantageusement des if, else if, else.

**yildiz-online** · 16/09/2016, 13h30

C'est très bien d'avoir des opinions divergentes, encore faut elle qu'elles soient supportées par des arguments.

Un des soucis majeur de goto est le fait qu'il permet de voyager dans le code de manière déstructurée, ce qui peut conduire à se retrouver dans une partie du code alors que l'état du programme n'est pas en adéquation, et ça va forcément mal finir.

Pour imager ça, on peut dire que goto c'est passer par la fenêtre au lieu d'utiliser la porte, tout va bien mais on finira toujours par casser un vase un jour ou l'autre.

Envoyé par Luke spywoker

(goto a quand même une utilité, non ?)

Les boules puantes ont une utilité, ce n'est pas pour autant que c'est une bonne idée d'en utiliser.

**LittleWhite** · 16/09/2016, 16h14

Envoyé par Luke spywoker

Comme je dois déinitialiser tous les modules comme SDL_ttf, SDL_image, etc... par ttf_Quit(), etc...

Oui, enfin comme tout le monde et vous êtes la première personne à utiliser goto pour cela. Généralement, moi c'est :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
SDL_Init();
while(tant_que_pas_de_gameover)
{
   joue();
}
SDL_Quit();

Envoyé par Luke spywoker

J'utilise goto pour revenir au début du programme.

Une boucle while fait exactement pareil (revenir au début). Une boucle for aussi

[QUOTE=Luke spywoker;8743357]Et goto sous peine que ce soit une vieille instruction n'est point a bannir du tout je pense.[/code]
Ce n'est pas ce que j'ai dit. Je vais expliciter le cas utiliser, notamment dans les programmes pur C, bas niveau (kernel, par exemple) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
{
init1();
if (test1)
    goto fail1;
 
init2();
if (test2)
    goto fail2;
 
init3()
if (test3)
    goto fail3;
 
job();
 
fail3:
free3();
fail2:
free2();
fail1:
free1();

Pour vous prouver que goto est adéquat ici : tentez d'écrire le code sans aucun goto et d'assurer que toutes les ressources sont bien libérées, dans le bonne ordre et correctement. Spoiler : le code contiendra des redondances et est pénible (et donc pénible à maintenir).

D'ailleurs j'utilise goto plusieurs fois dans mon programme.

Ce n'est pas un argument. On peut bien faire des choses mauvaises plusieurs fois.

... et est indispensable dans la programmation kernel driver.

Dans des cas très réglementés.
(et pour l'assembleur, soit, mais ici, vous faites du C

donc il faut observer une méthodologie différente.

Rien de personnel, seulement des opinions divergentes.

Idem

**Luke spywoker** · 17/09/2016, 16h14

Bon, pour yildiz-online

Un des soucis majeur de goto est le fait qu'il permet de voyager dans le code de manière déstructurée, ...

Pour faire un saut locale il n'y a pas d'autre solution que goto ! Pour aller d'un point A à un point C sans passer par B comment fait tu sans goto ou le contraire ?

Car tu dit que goto "il permet de voyager dans le code de manière déstructurée".

Ton argument a aucune valeur a mes yeux car en assembleur, qui est la base, et bien goto ou l'équivalent assembleur (et oui c'est une instruction de bas niveau, ha !) permet de structuré du code assembleur.

Un des soucis majeur de goto est le fait qu'il permet de voyager dans le code de manière déstructurée, ...

Et bien c'est a cela que sert l'instruction goto

et puis

j'en ai marre des moutons a qui l'on a dit une fois de pas utiliser goto (trop souvent sûrement, pas strictement) et du coup le déconseille a d'autre personnes, car on leur a rabâcher, et non pas par expérience personnel.
Si tu n'essaie pas tu n'y arrivera jamais, c'est sur !

Désolé pour le ton, sans vouloir t'offenser, mes tes propos m'énervent a vouloir m'interdire une instruction très utile, car mes propos sont basé sur mes expérience et non sur les dire d'un plouc.

ce qui peut conduire à se retrouver dans une partie du code alors que l'état du programme n'est pas en adéquation, et ça va forcément mal finir.

Et bien si tu ne sais pas ce que tu fait ne le fait pas !

J'ai remarquer ce concept aussi en C++ qui consiste a se protéger de soit même: par exemple les smart pointer...

Si tu ne sais pas qu'il faut libérer un pointeur après l'avoir utiliser utilise un objet capsule pour le pointeur afin que les memory leaks ne te touche pas.

Mais en utilisant ces capsules tu va grandement perdre de la puissance du concept des pointeurs: un accès a une zone mémoire de façon très rapide.

Il est vrai qu'ont peut oublier par accident car personne n'est parfait mais ajouter une surcouche au cas ou tu soit trop bête est vraiment dommage en termes de performances et taille du code source, par manquer de rigueur et de manque de confiance en soit, en son code et en son œuvre.

Notion qu'on tend a oublier avec nos grosse bécane actuelles, car python le fait fait bien non ?

Pour imager ça, on peut dire que goto c'est passer par la fenêtre au lieu d'utiliser la porte, tout va bien mais on finira toujours par casser un vase un jour ou l'autre.

Et bien un chat étant un chat je sais passer par la fenêtre sans risquer de casser quelque chose: car je sais ce que je fait !

Pour finir:

Dans mon programme:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
int main(void) {
 
  begin :
 
  // Initialisation de la SDL2
 
  if (not joystick) {
 
    // Affcher fenètre avec message.
 
   // Déinitaliser SDL2 (ceux-ci est obligatoire pour plugger un joytstick si SDL2 est initiliasé). 
 
   switch (response) {
 
     case plug_joystick :
 
        goto begin ;
 
    case choice_to_exit :
 
      exit(EXIT_SUCCESS) ;
   }      
 
 }

Bien sur, tu peut toujours te retaper l'initilisation de la SDL2 dans le case plug_joystick.

Mais ça serai du code inutile de plus et est un programme surcharger de code inutiles que je qualifierai de mal-structuré.

Alors dans ce cas goto a une utilité, est tu d'accord ou pas ?

---

Bonjours LittleWhite,

Tu n'a visiblement pas compris mon problème nie la manière dont j'utilise goto, je fait l'éffort de répéter:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
int main(void) {
 
  begin :
 
  // Initialisation de la SDL2
 
  if (not joystick) {
 
    // Affcher fenètre avec message.
 
   // Déinitaliser SDL2 (ceux-ci est nécessaire dans mon code). 
 
   goto begin ;  
 
 }

C'est tout merci.

**LittleWhite** · 17/09/2016, 16h45

Même dans l'exemple que vous m'adressez, un while suffit

:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
int main(void) {
 
while(1)
 
  // Initialisation de la SDL2
 
  if (not joystick) {
 
    // Affcher fenètre avec message.
 
   // Déinitaliser SDL2 (ceux-ci est nécessaire dans mon code). 
 
}
 
 }

Et dans ce cas, l'initialisation + déinitialisation de la SDL est superflue, mais soit.
Pour la protection contre le développeur, elle est utile, car le développeur ne veut pas toujours s'occuper de mille petite choses, alors qu'il est entrain de construire une super grosse application du style de LibreOffice. Si à chaque fois, il devait gérer tous les pointeurs (sachant qu'il va passer les pointeurs en paramètre) et ainsi de suite, alors les risques de ne plus savoir qui est propriétaire de la ressource sont énormes et donc, ne plus savoir qui doit faire la libération et à quelle moment. Il est évident que sur des petites applications (moins de 25 000 lignes) gérer ses pointeurs c'est totalement faisable, mais après. Et un smart pointer n'empêche pas l'accès raw à la mémoire.
Et puis, quand est t-il de la libération de ressources (pas juste pointeur, mais fichier, socket et autre) dans un cas où on utilise les goto ? Cela demande sûrement plus de réflexion que précédemment.

**Luke spywoker** · 19/09/2016, 07h45

Bonjours LittleWhite,

NON, NON et NON !!!

Il est impossible de brancher un joystick, selon mon expérience si tu fait cela il ne marchera pas, si la SDL2 est déjà initialiser, ou alors c'est mon Input_Handle qui ne le permet pas.

Il est strictement impossible de brancher un joystick si la SDL2 est déjà initialiser (je me répète), ton joystick ne fonctionnera pas:

Il faut Initialiser la SDL2 avec le joystick branché.

Si un joystick n'est pas branché alors que la SDL2 est initialiser ce n'est pas possible.

Point barre !

Tu crois que j'ai pas fait mes essaies ?

Ou

tu me prends pour une âne qui ne sait pas ce qu'il dit ?

Concernant ton while c'est une solution de remplacement mais je préfère faire un saut dans mon code (goto) plutôt que d'ajouter une boucle qui n'est pas forcément utile. Tu comprends: pas besoin d'ajouter du code, si un saut suffit.

De toute façon les 2 solutions ont le même effet revenir en avant dans le code.

---

Quand aux smart pointer, je m'en sert dans mon programme mais j'appelle toujours .reset() quand il faut les libérer (autant utiliser des raw-pointer !).

Quand aux programmeurs de grosse libraries ou applications, vaut mieux les écrire en C, si elle sont si grosse surtout dans un domaine ou la performance est de rigueur.

Mais se protéger contre soi même (pas uniquement les smart pointer) c'est ridicules sauf si l'on travaille en gros nombre et que personne ne sait ce qu'il fait au programme quand il écrit du code,

bref la protection contre soit-même je n'y voit pas d'utilité...

---

Pour récapituler:

Je sais ce que dit et fait, si tu me crois pas c'est un manque de respect envers moi.

Mais je reste ouvert car tout le monde peut se tromper, alors si vous désirez vous protéger contre vous même c'est votre problème.

---

Désolé d'être un peu rustre envers vous mais je ne vais pas bien en ce moment et suis sous pression actuellement,

je vous serez reconnaissant de bien vouloir me pardonner ma ferveur de la défense de mes idées et de mes convictions (acquis par expérience) envers ceux qui:

1. M'interdise d'utiliser goto.

2. Me prenne pour une âne concernant la prise en charge du joystick par la SDL2 (théoriquement tu a peut-être raison mais dans la pratique c'est autre chose).

Encore désolé pour le ton dans les 2 derniers postes, avec mes excuses les plus sincères,

Luke Spywoker (qui n'est plus si petit que ça maintenant).

**LittleWhite** · 19/09/2016, 13h21

Il est strictement impossible de brancher un joystick si la SDL2 est déjà initialiser (je me répète), ton joystick ne fonctionnera pas:

Désolé, mais je suis "obligé" de dire que vous vous trompez. Et je ne dis pas cela car je vous prend pour un âne, cela n'est jamais arrivé. Je dis juste cela, car je viens de tester à nouveau aujourd'hui, avec le code que je fournis ici : http://alexandre-laurent.developpez....ents/#LIII-C-4

J'ai lancé le programme. Il ne captait que la souris. Je branche le joystick et hop, il est reconnu et les entrées du joysticks capturées.

Quand aux smart pointer, je m'en sert dans mon programme mais j'appelle toujours .reset() quand il faut les libérer (autant utiliser des raw-pointer !).

Oui, mais dans un tel cas, on ne peux rien y faire. Ils ne sont pas conçus pour que l'utilisateur fasse des reset(), mais pour que la libération se fasse automatiquement lors que leur vie est finie.

Quand aux programmeurs de grosse libraries ou applications, vaut mieux les écrire en C, si elle sont si grosse surtout dans un domaine ou la performance est de rigueur.

C'est votre avis, mais il ne semble pas être partagé par les développeurs des robots de la NASA ou même des développeurs de jeux vidéos -> http://cpp.developpez.com/videos/

bref la protection contre soit-même je n'y voit pas d'utilité...

Alors, je ne peux que conclure que vous faites des codes parfaits

(j'aimerai aussi avoir ce don (ou cette intelligence, je ne sais pas comment l'appeler)).

Je n'ai pas interdit le goto, j'ai conseillé de ne pas l'utiliser (et j'ai présenté mes arguments). Une fois ce débat clos, moi, je n'ai pas à y revenir, c'est simplement un conseil.

**Guntha** · 21/09/2016, 10h53

Envoyé par Luke spywoker

Pour faire un saut locale il n'y a pas d'autre solution que goto ! Pour aller d'un point A à un point C sans passer par B comment fait tu sans goto ou le contraire ?

C'est tout merci.

Bah... Avec un if?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int main()
{
    //A
 
    //Si tu ne veux pas aller au point B, tu fais en sorte que "machin" soit false avant ce point
    if(machin)
    {
        //B
    }
 
    //C
}

Et même en assembleur aujourd'hui, je ne vois plus tellement de goto, plutôt des jmp/jne/jle/jge etc... qui sont l'équivalent... du test dans un if() :p

Tiens, pour la petite histoire avant d'écrire ce post, j'ai compilé le projet que j'ai fait pour le dernier week-end de développement, sur Visual Studio, en release (donc avec optimisations activées, donc à priori le compilo ne se gène pas pour faire des trucs bien crades), et désassemblé: le voilà: Régale-toi dans ta recherche des goto :p (par contre, des jump, on en trouve un paquet).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
2182
2183
2184
2185
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
2239
2240
2241
2242
2243
2244
2245
2246
2247
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
2271
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
2282
2283
2284
2285
2286
2287
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299
2300
max_count = 6, min_count = 3;
00007FF7CE14FAE5  add         ebp,ebx  
        } else {
00007FF7CE14FAE7  or          dword ptr [rbx+4],edi  
            max_count = 7, min_count = 4;
00007FF7CE14FAED  lea         r11d,[rbx+3]  
 
    for (n = 0; n <= max_code; n++) {
00007FF7CE14FAF1  add         rdx,4  
00007FF7CE14FAF5  sub         r8,1  
00007FF7CE14FAF9  jne         scan_tree+60h (07FF7CE14FA70h)  
        }
    }
}
00007FF7CE14FAFF  mov         rbx,qword ptr [rsp+8]  
00007FF7CE14FB04  mov         rsi,qword ptr [rsp+10h]  
00007FF7CE14FB09  mov         rdi,qword ptr [rsp+18h]  
00007FF7CE14FB0E  ret  
00007FF7CE14FB0F  int         3  
 
/* ===========================================================================
 * Send a literal or distance tree in compressed form, using the codes in
 * bl_tree.
 */
local void send_tree (s, tree, max_code)
    deflate_state *s;
    ct_data *tree; /* the tree to be scanned */
    int max_code;       /* and its largest code of non zero frequency */
{
00007FF7CE14FB10  push        rbx  
00007FF7CE14FB12  push        rbp  
    int n;                     /* iterates over all tree elements */
    int prevlen = -1;          /* last emitted length */
    int curlen;                /* length of current code */
    int nextlen = tree[0].Len; /* length of next code */
00007FF7CE14FB13  movzx       ebp,word ptr [rdx+2]  
00007FF7CE14FB17  or          r11d,0FFFFFFFFh  
    int count = 0;             /* repeat count of the current code */
00007FF7CE14FB1B  xor         r10d,r10d  
00007FF7CE14FB1E  mov         rax,rcx  
00007FF7CE14FB21  mov         rbx,rdx  
    int max_count = 7;         /* max repeat count */
00007FF7CE14FB24  lea         ecx,[r11+8]  
    int min_count = 4;         /* min repeat count */
00007FF7CE14FB28  lea         r9d,[r11+5]  
 
    /* tree[max_code+1].Len = -1; */  /* guard already set */
    if (nextlen == 0) max_count = 138, min_count = 3;
00007FF7CE14FB2C  test        ebp,ebp  
00007FF7CE14FB2E  jne         send_tree+29h (07FF7CE14FB39h)  
00007FF7CE14FB30  mov         ecx,8Ah  
00007FF7CE14FB35  lea         r9d,[r11+4]  
 
    for (n = 0; n <= max_code; n++) {
00007FF7CE14FB39  movsxd      rdx,r8d  
00007FF7CE14FB3C  test        r8d,r8d  
00007FF7CE14FB3F  js          send_tree+57Eh (07FF7CE15008Eh)  
00007FF7CE14FB45  mov         qword ptr [rsp+18h],rsi  
00007FF7CE14FB4A  mov         qword ptr [rsp+20h],rdi  
00007FF7CE14FB4F  mov         qword ptr [rsp+28h],r14  
00007FF7CE14FB54  lea         r14,[rbx+6]  
00007FF7CE14FB58  mov         qword ptr [rsp+30h],r15  
00007FF7CE14FB5D  lea         r15,[rdx+1]  
        curlen = nextlen; nextlen = tree[n+1].Len;
        if (++count < max_count && curlen == nextlen) {
00007FF7CE14FB61  inc         r10d  
00007FF7CE14FB64  movsxd      rdi,ebp  
00007FF7CE14FB67  movzx       ebp,word ptr [r14]  
00007FF7CE14FB6B  cmp         r10d,ecx  
00007FF7CE14FB6E  jge         send_tree+68h (07FF7CE14FB78h)  
        curlen = nextlen; nextlen = tree[n+1].Len;
        if (++count < max_count && curlen == nextlen) {
00007FF7CE14FB70  cmp         edi,ebp  
00007FF7CE14FB72  je          send_tree+55Ch (07FF7CE15006Ch)  
            continue;
        } else if (count < min_count) {
00007FF7CE14FB78  cmp         r10d,r9d  
00007FF7CE14FB7B  jge         send_tree+128h (07FF7CE14FC38h)  
00007FF7CE14FB81  lea         rsi,[rax+rdi*4]  
00007FF7CE14FB85  lea         rbx,[rax+rdi*4]  
00007FF7CE14FB89  nop         dword ptr [rax]  
            do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
00007FF7CE14FB90  movzx       r11d,word ptr [rsi+0AA6h]  
00007FF7CE14FB98  mov         edx,10h  
00007FF7CE14FB9D  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE14FBA3  sub         edx,r11d  
00007FF7CE14FBA6  cmp         ecx,edx  
00007FF7CE14FBA8  jle         send_tree+0FFh (07FF7CE14FC0Fh)  
00007FF7CE14FBAA  movzx       r9d,word ptr [rbx+0AA4h]  
00007FF7CE14FBB2  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FBB6  movzx       edx,r9w  
00007FF7CE14FBBA  shl         dx,cl  
00007FF7CE14FBBD  or          word ptr [rax+1710h],dx  
00007FF7CE14FBC4  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE14FBCB  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FBCF  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FBD3  inc         dword ptr [rax+28h]  
00007FF7CE14FBD6  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE14FBDD  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FBE1  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FBE5  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FBE9  mov         ecx,10h  
00007FF7CE14FBEE  sub         cl,byte ptr [rax+1714h]  
00007FF7CE14FBF4  inc         dword ptr [rax+28h]  
00007FF7CE14FBF7  shr         r9w,cl  
00007FF7CE14FBFB  lea         ecx,[r11-10h]  
00007FF7CE14FBFF  add         dword ptr [rax+1714h],ecx  
00007FF7CE14FC05  mov         word ptr [rax+1710h],r9w  
00007FF7CE14FC0D  jmp         send_tree+119h (07FF7CE14FC29h)  
00007FF7CE14FC0F  movzx       edx,word ptr [rbx+0AA4h]  
00007FF7CE14FC16  shl         dx,cl  
00007FF7CE14FC19  or          word ptr [rax+1710h],dx  
00007FF7CE14FC20  add         ecx,r11d  
            do { send_code(s, curlen, s->bl_tree); } while (--count != 0);
00007FF7CE14FC23  mov         dword ptr [rax+1714h],ecx  
00007FF7CE14FC29  sub         r10d,1  
00007FF7CE14FC2D  jne         send_tree+80h (07FF7CE14FB90h)  
 
        } else if (curlen != 0) {
00007FF7CE14FC33  jmp         send_tree+52Fh (07FF7CE15003Fh)  
00007FF7CE14FC38  test        edi,edi  
00007FF7CE14FC3A  je          send_tree+2F6h (07FF7CE14FE06h)  
            if (curlen != prevlen) {
00007FF7CE14FC40  cmp         edi,r11d  
00007FF7CE14FC43  je          send_tree+1D8h (07FF7CE14FCE8h)  
                send_code(s, curlen, s->bl_tree); count--;
00007FF7CE14FC49  movzx       r11d,word ptr [rax+rdi*4+0AA6h]  
00007FF7CE14FC52  mov         edx,10h  
00007FF7CE14FC57  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE14FC5D  sub         edx,r11d  
00007FF7CE14FC60  cmp         ecx,edx  
00007FF7CE14FC62  jle         send_tree+1BAh (07FF7CE14FCCAh)  
00007FF7CE14FC64  movzx       r9d,word ptr [rax+rdi*4+0AA4h]  
00007FF7CE14FC6D  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FC71  movzx       edx,r9w  
00007FF7CE14FC75  shl         dx,cl  
00007FF7CE14FC78  or          word ptr [rax+1710h],dx  
00007FF7CE14FC7F  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE14FC86  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FC8A  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FC8E  inc         dword ptr [rax+28h]  
00007FF7CE14FC91  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE14FC98  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FC9C  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FCA0  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FCA4  mov         ecx,10h  
00007FF7CE14FCA9  sub         cl,byte ptr [rax+1714h]  
00007FF7CE14FCAF  inc         dword ptr [rax+28h]  
00007FF7CE14FCB2  shr         r9w,cl  
00007FF7CE14FCB6  lea         ecx,[r11-10h]  
00007FF7CE14FCBA  add         dword ptr [rax+1714h],ecx  
00007FF7CE14FCC0  mov         word ptr [rax+1710h],r9w  
00007FF7CE14FCC8  jmp         send_tree+1D5h (07FF7CE14FCE5h)  
00007FF7CE14FCCA  movzx       edx,word ptr [rax+rdi*4+0AA4h]  
00007FF7CE14FCD2  shl         dx,cl  
00007FF7CE14FCD5  or          word ptr [rax+1710h],dx  
                send_code(s, curlen, s->bl_tree); count--;
00007FF7CE14FCDC  add         ecx,r11d  
00007FF7CE14FCDF  mov         dword ptr [rax+1714h],ecx  
00007FF7CE14FCE5  dec         r10d  
            }
            Assert(count >= 3 && count <= 6, " 3_6?");
            send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
00007FF7CE14FCE8  movzx       r11d,word ptr [rax+0AE6h]  
00007FF7CE14FCF0  mov         edx,10h  
00007FF7CE14FCF5  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE14FCFB  sub         edx,r11d  
00007FF7CE14FCFE  cmp         ecx,edx  
00007FF7CE14FD00  jle         send_tree+257h (07FF7CE14FD67h)  
00007FF7CE14FD02  movzx       r9d,word ptr [rax+0AE4h]  
00007FF7CE14FD0A  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FD0E  movzx       edx,r9w  
00007FF7CE14FD12  shl         dx,cl  
00007FF7CE14FD15  or          word ptr [rax+1710h],dx  
00007FF7CE14FD1C  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE14FD23  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FD27  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FD2B  inc         dword ptr [rax+28h]  
00007FF7CE14FD2E  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE14FD35  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FD39  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FD3D  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FD41  mov         ecx,10h  
00007FF7CE14FD46  sub         cl,byte ptr [rax+1714h]  
00007FF7CE14FD4C  inc         dword ptr [rax+28h]  
00007FF7CE14FD4F  shr         r9w,cl  
00007FF7CE14FD53  lea         ecx,[r11-10h]  
00007FF7CE14FD57  add         dword ptr [rax+1714h],ecx  
00007FF7CE14FD5D  mov         word ptr [rax+1710h],r9w  
00007FF7CE14FD65  jmp         send_tree+271h (07FF7CE14FD81h)  
00007FF7CE14FD67  movzx       edx,word ptr [rax+0AE4h]  
00007FF7CE14FD6E  shl         dx,cl  
00007FF7CE14FD71  or          word ptr [rax+1710h],dx  
00007FF7CE14FD78  add         ecx,r11d  
00007FF7CE14FD7B  mov         dword ptr [rax+1714h],ecx  
00007FF7CE14FD81  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE14FD87  cmp         ecx,0Eh  
00007FF7CE14FD8A  jle         send_tree+2DDh (07FF7CE14FDEDh)  
            }
            Assert(count >= 3 && count <= 6, " 3_6?");
            send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2);
00007FF7CE14FD8C  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FD90  lea         r9d,[r10-3]  
00007FF7CE14FD94  movzx       edx,r9w  
00007FF7CE14FD98  shl         dx,cl  
00007FF7CE14FD9B  or          word ptr [rax+1710h],dx  
00007FF7CE14FDA2  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE14FDA9  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FDAD  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FDB1  inc         dword ptr [rax+28h]  
00007FF7CE14FDB4  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE14FDBB  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FDBF  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FDC3  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FDC7  mov         ecx,10h  
00007FF7CE14FDCC  sub         cl,byte ptr [rax+1714h]  
00007FF7CE14FDD2  inc         dword ptr [rax+28h]  
00007FF7CE14FDD5  shr         r9w,cl  
00007FF7CE14FDD9  add         dword ptr [rax+1714h],0FFFFFFF2h  
00007FF7CE14FDE0  mov         word ptr [rax+1710h],r9w  
00007FF7CE14FDE8  jmp         send_tree+52Fh (07FF7CE15003Fh)  
00007FF7CE14FDED  sub         r10w,3  
00007FF7CE14FDF2  shl         r10w,cl  
00007FF7CE14FDF6  or          word ptr [rax+1710h],r10w  
00007FF7CE14FDFE  add         ecx,2  
00007FF7CE14FE01  jmp         send_tree+529h (07FF7CE150039h)  
 
        } else if (count <= 10) {
            send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
00007FF7CE14FE06  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE14FE0C  mov         edx,10h  
00007FF7CE14FE11  cmp         r10d,0Ah  
00007FF7CE14FE15  jg          send_tree+41Eh (07FF7CE14FF2Eh)  
00007FF7CE14FE1B  movzx       r11d,word ptr [rax+0AEAh]  
00007FF7CE14FE23  sub         edx,r11d  
00007FF7CE14FE26  cmp         ecx,edx  
00007FF7CE14FE28  jle         send_tree+37Fh (07FF7CE14FE8Fh)  
00007FF7CE14FE2A  movzx       r9d,word ptr [rax+0AE8h]  
00007FF7CE14FE32  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FE36  movzx       edx,r9w  
00007FF7CE14FE3A  shl         dx,cl  
00007FF7CE14FE3D  or          word ptr [rax+1710h],dx  
 
        } else if (count <= 10) {
            send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
00007FF7CE14FE44  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE14FE4B  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FE4F  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FE53  inc         dword ptr [rax+28h]  
00007FF7CE14FE56  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE14FE5D  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FE61  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FE65  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FE69  mov         ecx,10h  
00007FF7CE14FE6E  sub         cl,byte ptr [rax+1714h]  
00007FF7CE14FE74  inc         dword ptr [rax+28h]  
00007FF7CE14FE77  shr         r9w,cl  
00007FF7CE14FE7B  lea         ecx,[r11-10h]  
00007FF7CE14FE7F  add         dword ptr [rax+1714h],ecx  
00007FF7CE14FE85  mov         word ptr [rax+1710h],r9w  
00007FF7CE14FE8D  jmp         send_tree+399h (07FF7CE14FEA9h)  
00007FF7CE14FE8F  movzx       edx,word ptr [rax+0AE8h]  
00007FF7CE14FE96  shl         dx,cl  
00007FF7CE14FE99  or          word ptr [rax+1710h],dx  
00007FF7CE14FEA0  add         ecx,r11d  
00007FF7CE14FEA3  mov         dword ptr [rax+1714h],ecx  
00007FF7CE14FEA9  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE14FEAF  cmp         ecx,0Dh  
00007FF7CE14FEB2  jle         send_tree+405h (07FF7CE14FF15h)  
00007FF7CE14FEB4  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FEB8  lea         r9d,[r10-3]  
00007FF7CE14FEBC  movzx       edx,r9w  
00007FF7CE14FEC0  shl         dx,cl  
00007FF7CE14FEC3  or          word ptr [rax+1710h],dx  
00007FF7CE14FECA  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE14FED1  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FED5  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FED9  inc         dword ptr [rax+28h]  
00007FF7CE14FEDC  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE14FEE3  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FEE7  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FEEB  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FEEF  mov         ecx,10h  
 
        } else if (count <= 10) {
            send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3);
00007FF7CE14FEF4  sub         cl,byte ptr [rax+1714h]  
00007FF7CE14FEFA  inc         dword ptr [rax+28h]  
00007FF7CE14FEFD  shr         r9w,cl  
00007FF7CE14FF01  add         dword ptr [rax+1714h],0FFFFFFF3h  
00007FF7CE14FF08  mov         word ptr [rax+1710h],r9w  
00007FF7CE14FF10  jmp         send_tree+52Fh (07FF7CE15003Fh)  
00007FF7CE14FF15  sub         r10w,3  
00007FF7CE14FF1A  shl         r10w,cl  
00007FF7CE14FF1E  or          word ptr [rax+1710h],r10w  
00007FF7CE14FF26  add         ecx,3  
 
        } else {
00007FF7CE14FF29  jmp         send_tree+529h (07FF7CE150039h)  
            send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7);
00007FF7CE14FF2E  movzx       r11d,word ptr [rax+0AEEh]  
00007FF7CE14FF36  sub         edx,r11d  
00007FF7CE14FF39  cmp         ecx,edx  
00007FF7CE14FF3B  jle         send_tree+492h (07FF7CE14FFA2h)  
00007FF7CE14FF3D  movzx       r9d,word ptr [rax+0AECh]  
00007FF7CE14FF45  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FF49  movzx       edx,r9w  
00007FF7CE14FF4D  shl         dx,cl  
00007FF7CE14FF50  or          word ptr [rax+1710h],dx  
00007FF7CE14FF57  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE14FF5E  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FF62  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FF66  inc         dword ptr [rax+28h]  
00007FF7CE14FF69  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE14FF70  mov         r8d,dword ptr [rax+28h]  
00007FF7CE14FF74  mov         rdx,qword ptr [rax+10h]  
00007FF7CE14FF78  mov         byte ptr [r8+rdx],cl  
00007FF7CE14FF7C  mov         ecx,10h  
00007FF7CE14FF81  sub         cl,byte ptr [rax+1714h]  
00007FF7CE14FF87  inc         dword ptr [rax+28h]  
00007FF7CE14FF8A  shr         r9w,cl  
00007FF7CE14FF8E  lea         ecx,[r11-10h]  
00007FF7CE14FF92  add         dword ptr [rax+1714h],ecx  
00007FF7CE14FF98  mov         word ptr [rax+1710h],r9w  
00007FF7CE14FFA0  jmp         send_tree+4ACh (07FF7CE14FFBCh)  
00007FF7CE14FFA2  movzx       edx,word ptr [rax+0AECh]  
00007FF7CE14FFA9  shl         dx,cl  
00007FF7CE14FFAC  ?? ?? 
00007FF7CE14FFAD  ?? ?? 
00007FF7CE14FFAE  ?? ?? 
00007FF7CE14FFAF  ?? ?? 
00007FF7CE14FFB0  ?? ?? 
00007FF7CE14FFB1  ?? ?? 
00007FF7CE14FFB2  ?? ?? 
00007FF7CE14FFB3  ?? ?? 
00007FF7CE14FFB4  ?? ?? 
00007FF7CE14FFB5  ?? ?? 
00007FF7CE14FFB6  ?? ?? 
00007FF7CE14FFB7  ?? ?? 
00007FF7CE14FFB8  ?? ?? 
00007FF7CE14FFB9  ?? ?? 
00007FF7CE14FFBA  ?? ?? 
00007FF7CE14FFBB  ?? ?? 
00007FF7CE14FFBC  ?? ?? 
00007FF7CE14FFBD  ?? ?? 
00007FF7CE14FFBE  ?? ?? 
00007FF7CE14FFBF  ?? ?? 
00007FF7CE14FFC0  ?? ?? 
00007FF7CE14FFC1  ?? ?? 
00007FF7CE14FFC2  ?? ?? 
00007FF7CE14FFC3  ?? ?? 
00007FF7CE14FFC4  ?? ?? 
00007FF7CE14FFC5  ?? ?? 
00007FF7CE14FFC6  ?? ?? 
00007FF7CE14FFC7  ?? ?? 
00007FF7CE14FFC8  ?? ?? 
00007FF7CE14FFC9  ?? ?? 
00007FF7CE14FFCA  ?? ?? 
00007FF7CE14FFCB  ?? ?? 
00007FF7CE14FFCC  ?? ?? 
00007FF7CE14FFCD  ?? ?? 
00007FF7CE14FFCE  ?? ?? 
00007FF7CE14FFCF  ?? ?? 
00007FF7CE14FFD0  ?? ?? 
00007FF7CE14FFD1  ?? ?? 
00007FF7CE14FFD2  ?? ?? 
00007FF7CE14FFD3  ?? ?? 
00007FF7CE14FFD4  ?? ?? 
00007FF7CE14FFD5  ?? ?? 
00007FF7CE14FFD6  ?? ?? 
00007FF7CE14FFD7  ?? ?? 
00007FF7CE14FFD8  ?? ?? 
00007FF7CE14FFD9  ?? ?? 
00007FF7CE14FFDA  ?? ?? 
00007FF7CE14FFDB  ?? ?? 
00007FF7CE14FFDC  ?? ?? 
00007FF7CE14FFDD  ?? ?? 
00007FF7CE14FFDE  ?? ?? 
00007FF7CE14FFDF  ?? ?? 
00007FF7CE14FFE0  ?? ?? 
00007FF7CE14FFE1  ?? ?? 
00007FF7CE14FFE2  ?? ?? 
00007FF7CE14FFE3  ?? ?? 
00007FF7CE14FFE4  ?? ?? 
00007FF7CE14FFE5  ?? ?? 
00007FF7CE14FFE6  ?? ?? 
00007FF7CE14FFE7  ?? ?? 
00007FF7CE14FFE8  ?? ?? 
00007FF7CE14FFE9  ?? ?? 
00007FF7CE14FFEA  ?? ?? 
00007FF7CE14FFEB  ?? ?? 
00007FF7CE14FFEC  ?? ?? 
00007FF7CE14FFED  ?? ?? 
00007FF7CE14FFEE  ?? ?? 
00007FF7CE14FFEF  ?? ?? 
00007FF7CE14FFF0  ?? ?? 
00007FF7CE14FFF1  ?? ?? 
00007FF7CE14FFF2  ?? ?? 
00007FF7CE14FFF3  ?? ?? 
00007FF7CE14FFF4  ?? ?? 
00007FF7CE14FFF5  ?? ?? 
00007FF7CE14FFF6  ?? ?? 
00007FF7CE14FFF7  ?? ?? 
00007FF7CE14FFF8  ?? ?? 
00007FF7CE14FFF9  ?? ?? 
00007FF7CE14FFFA  ?? ?? 
00007FF7CE14FFFB  ?? ?? 
00007FF7CE14FFFC  ?? ?? 
00007FF7CE14FFFD  ?? ?? 
00007FF7CE14FFFE  ?? ?? 
00007FF7CE14FFFF  ?? ?? 
00007FF7CE150000  ?? ?? 
00007FF7CE150001  ?? ?? 
00007FF7CE150002  ?? ?? 
00007FF7CE150003  ?? ?? 
00007FF7CE150004  ?? ?? 
00007FF7CE150005  ?? ?? 
00007FF7CE150006  ?? ?? 
00007FF7CE150007  ?? ?? 
00007FF7CE150008  ?? ?? 
00007FF7CE150009  ?? ?? 
00007FF7CE15000A  ?? ?? 
00007FF7CE15000B  ?? ?? 
00007FF7CE15000C  ?? ?? 
00007FF7CE15000D  ?? ?? 
00007FF7CE15000E  ?? ?? 
00007FF7CE15000F  ?? ?? 
00007FF7CE150010  ?? ?? 
00007FF7CE150011  ?? ?? 
00007FF7CE150012  ?? ?? 
00007FF7CE150013  ?? ?? 
00007FF7CE150014  ?? ?? 
00007FF7CE150015  ?? ?? 
00007FF7CE150016  ?? ?? 
00007FF7CE150017  ?? ?? 
00007FF7CE150018  ?? ?? 
00007FF7CE150019  ?? ?? 
00007FF7CE15001A  ?? ?? 
00007FF7CE15001B  ?? ?? 
00007FF7CE15001C  ?? ?? 
00007FF7CE15001D  ?? ?? 
00007FF7CE15001E  ?? ?? 
00007FF7CE15001F  ?? ?? 
00007FF7CE150020  ?? ?? 
00007FF7CE150021  ?? ?? 
00007FF7CE150022  ?? ?? 
00007FF7CE150023  ?? ?? 
00007FF7CE150024  ?? ?? 
00007FF7CE150025  ?? ?? 
00007FF7CE150026  ?? ?? 
00007FF7CE150027  ?? ?? 
00007FF7CE150028  ?? ?? 
00007FF7CE150029  ?? ?? 
00007FF7CE15002A  ?? ?? 
00007FF7CE15002B  ?? ?? 
00007FF7CE15002C  ?? ?? 
00007FF7CE15002D  ?? ?? 
00007FF7CE15002E  ?? ?? 
00007FF7CE15002F  ?? ?? 
00007FF7CE150030  ?? ?? 
00007FF7CE150031  ?? ?? 
00007FF7CE150032  ?? ?? 
00007FF7CE150033  ?? ?? 
00007FF7CE150034  ?? ?? 
00007FF7CE150035  ?? ?? 
00007FF7CE150036  ?? ?? 
00007FF7CE150037  ?? ?? 
00007FF7CE150038  ?? ?? 
00007FF7CE150039  ?? ?? 
00007FF7CE15003A  ?? ?? 
00007FF7CE15003B  ?? ?? 
00007FF7CE15003C  ?? ?? 
00007FF7CE15003D  ?? ?? 
00007FF7CE15003E  ?? ?? 
00007FF7CE15003F  ?? ?? 
00007FF7CE150040  ?? ?? 
00007FF7CE150041  ?? ?? 
00007FF7CE150042  ?? ?? 
00007FF7CE150043  ?? ?? 
        }
        count = 0; prevlen = curlen;
00007FF7CE150044  fild        word ptr [rbp-46F48A13h]  
            max_count = 138, min_count = 3;
00007FF7CE15004A  mov         al,byte ptr [rax]  
00007FF7CE15004C  add         byte ptr [rax],al  
00007FF7CE15004E  lea         r9d,[r10+3]  
00007FF7CE150052  jmp         send_tree+55Ch (07FF7CE15006Ch)  
        } else if (curlen == nextlen) {
00007FF7CE150054  cmp         edi,ebp  
00007FF7CE150056  jne         send_tree+553h (07FF7CE150063h)  
            max_count = 6, min_count = 3;
00007FF7CE150058  mov         ecx,6  
00007FF7CE15005D  lea         r9d,[rcx-3]  
        } else {
00007FF7CE150061  jmp         send_tree+55Ch (07FF7CE15006Ch)  
            max_count = 7, min_count = 4;
00007FF7CE150063  mov         ecx,7  
00007FF7CE150068  lea         r9d,[rcx-3]  
 
    for (n = 0; n <= max_code; n++) {
00007FF7CE15006C  add         r14,4  
00007FF7CE150070  sub         r15,1  
00007FF7CE150074  jne         send_tree+51h (07FF7CE14FB61h)  
00007FF7CE15007A  mov         r15,qword ptr [rsp+30h]  
00007FF7CE15007F  mov         r14,qword ptr [rsp+28h]  
00007FF7CE150084  mov         rdi,qword ptr [rsp+20h]  
00007FF7CE150089  mov         rsi,qword ptr [rsp+18h]  
        }
    }
}
00007FF7CE15008E  pop         rbp  
00007FF7CE15008F  pop         rbx  
00007FF7CE150090  ret  
00007FF7CE150091  int         3  
00007FF7CE150092  int         3  
00007FF7CE150093  int         3  
00007FF7CE150094  int         3  
00007FF7CE150095  int         3  
00007FF7CE150096  int         3  
00007FF7CE150097  int         3  
00007FF7CE150098  int         3  
00007FF7CE150099  int         3  
00007FF7CE15009A  int         3  
00007FF7CE15009B  int         3  
00007FF7CE15009C  int         3  
00007FF7CE15009D  int         3  
00007FF7CE15009E  int         3  
00007FF7CE15009F  int         3  
 
/* ===========================================================================
 * Construct the Huffman tree for the bit lengths and return the index in
 * bl_order of the last bit length code to send.
 */
local int build_bl_tree(s)
    deflate_state *s;
{
00007FF7CE1500A0  push        rbx  
 
/* ===========================================================================
 * Construct the Huffman tree for the bit lengths and return the index in
 * bl_order of the last bit length code to send.
 */
local int build_bl_tree(s)
    deflate_state *s;
{
00007FF7CE1500A2  sub         rsp,20h  
    int max_blindex;  /* index of last bit length code of non zero freq */
 
    /* Determine the bit length frequencies for literal and distance trees */
    scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
00007FF7CE1500A6  mov         r8d,dword ptr [rcx+0B48h]  
00007FF7CE1500AD  lea         rdx,[rcx+0BCh]  
00007FF7CE1500B4  mov         rbx,rcx  
00007FF7CE1500B7  call        scan_tree (07FF7CE14FA10h)  
    scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);
00007FF7CE1500BC  mov         r8d,dword ptr [rbx+0B60h]  
00007FF7CE1500C3  lea         rdx,[rbx+9B0h]  
00007FF7CE1500CA  mov         rcx,rbx  
00007FF7CE1500CD  call        scan_tree (07FF7CE14FA10h)  
 
    /* Build the bit length tree: */
    build_tree(s, (tree_desc *)(&(s->bl_desc)));
00007FF7CE1500D2  lea         rdx,[rbx+0B70h]  
00007FF7CE1500D9  mov         rcx,rbx  
00007FF7CE1500DC  call        build_tree (07FF7CE14F740h)  
    /* opt_len now includes the length of the tree representations, except
     * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
     */
 
    /* Determine the number of bit length codes to send. The pkzip format
     * requires that at least 4 bit length codes be sent. (appnote.txt says
     * 3 but the actual value used is 4.)
     */
    for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
00007FF7CE1500E1  mov         edx,12h  
00007FF7CE1500E6  lea         r8,[bl_order (07FF7CE178818h)]  
00007FF7CE1500ED  mov         eax,edx  
00007FF7CE1500EF  nop  
        if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
00007FF7CE1500F0  movzx       ecx,byte ptr [rax+r8]  
00007FF7CE1500F5  cmp         word ptr [rbx+rcx*4+0AA6h],0  
00007FF7CE1500FE  jne         build_bl_tree+0AEh (07FF7CE15014Eh)  
00007FF7CE150100  movzx       ecx,byte ptr [rax+r8-1]  
00007FF7CE150106  cmp         word ptr [rbx+rcx*4+0AA6h],0  
00007FF7CE15010F  jne         build_bl_tree+0ACh (07FF7CE15014Ch)  
00007FF7CE150111  movzx       ecx,byte ptr [rax+r8-2]  
00007FF7CE150117  cmp         word ptr [rbx+rcx*4+0AA6h],0  
00007FF7CE150120  jne         build_bl_tree+0A7h (07FF7CE150147h)  
00007FF7CE150122  movzx       ecx,byte ptr [rax+r8-3]  
00007FF7CE150128  cmp         word ptr [rbx+rcx*4+0AA6h],0  
00007FF7CE150131  jne         build_bl_tree+0A2h (07FF7CE150142h)  
    /* opt_len now includes the length of the tree representations, except
     * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
     */
 
    /* Determine the number of bit length codes to send. The pkzip format
     * requires that at least 4 bit length codes be sent. (appnote.txt says
     * 3 but the actual value used is 4.)
     */
    for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
00007FF7CE150133  sub         rax,4  
00007FF7CE150137  sub         edx,4  
00007FF7CE15013A  cmp         rax,3  
00007FF7CE15013E  jge         build_bl_tree+50h (07FF7CE1500F0h)  
00007FF7CE150140  jmp         build_bl_tree+0AEh (07FF7CE15014Eh)  
        if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
00007FF7CE150142  sub         edx,3  
00007FF7CE150145  jmp         build_bl_tree+0AEh (07FF7CE15014Eh)  
00007FF7CE150147  sub         edx,2  
    /* opt_len now includes the length of the tree representations, except
     * the lengths of the bit lengths codes and the 5+5+4 bits for the counts.
     */
 
    /* Determine the number of bit length codes to send. The pkzip format
     * requires that at least 4 bit length codes be sent. (appnote.txt says
     * 3 but the actual value used is 4.)
     */
    for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
00007FF7CE15014A  jmp         build_bl_tree+0AEh (07FF7CE15014Eh)  
        if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
00007FF7CE15014C  dec         edx  
    }
    /* Update opt_len to include the bit length tree and counts */
    s->opt_len += 3*(max_blindex+1) + 5+5+4;
00007FF7CE15014E  lea         ecx,[rdx*2+11h]  
    Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
            s->opt_len, s->static_len));
 
    return max_blindex;
00007FF7CE150155  mov         eax,edx  
00007FF7CE150157  add         ecx,edx  
00007FF7CE150159  add         dword ptr [rbx+1700h],ecx  
}
00007FF7CE15015F  add         rsp,20h  
00007FF7CE150163  pop         rbx  
00007FF7CE150164  ret  
00007FF7CE150165  int         3  
00007FF7CE150166  int         3  
00007FF7CE150167  int         3  
00007FF7CE150168  int         3  
00007FF7CE150169  int         3  
00007FF7CE15016A  int         3  
00007FF7CE15016B  int         3  
00007FF7CE15016C  int         3  
00007FF7CE15016D  int         3  
00007FF7CE15016E  int         3  
00007FF7CE15016F  int         3  
 
/* ===========================================================================
 * Send the header for a block using dynamic Huffman trees: the counts, the
 * lengths of the bit length codes, the literal tree and the distance tree.
 * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4.
 */
local void send_all_trees(s, lcodes, dcodes, blcodes)
    deflate_state *s;
    int lcodes, dcodes, blcodes; /* number of codes for each tree */
{
00007FF7CE150170  mov         qword ptr [rsp+8],rbx  
00007FF7CE150175  mov         qword ptr [rsp+10h],rsi  
00007FF7CE15017A  push        rdi  
00007FF7CE15017B  sub         rsp,20h  
00007FF7CE15017F  mov         rbx,rcx  
00007FF7CE150182  mov         r11d,r9d  
    int rank;                    /* index in bl_order */
 
    Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
    Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
            "too many codes");
    Tracev((stderr, "\nbl counts: "));
    send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
00007FF7CE150185  mov         ecx,dword ptr [rcx+1714h]  
00007FF7CE15018B  mov         edi,r8d  
00007FF7CE15018E  mov         esi,edx  
00007FF7CE150190  cmp         ecx,0Bh  
00007FF7CE150193  jle         send_all_trees+82h (07FF7CE1501F2h)  
00007FF7CE150195  lea         r10d,[rdx-101h]  
00007FF7CE15019C  mov         edx,dword ptr [rbx+28h]  
00007FF7CE15019F  movzx       eax,r10w  
00007FF7CE1501A3  shl         ax,cl  
00007FF7CE1501A6  or          word ptr [rbx+1710h],ax  
00007FF7CE1501AD  movzx       eax,byte ptr [rbx+1710h]  
00007FF7CE1501B4  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE1501B8  mov         byte ptr [rdx+rcx],al  
00007FF7CE1501BB  inc         dword ptr [rbx+28h]  
    int rank;                    /* index in bl_order */
 
    Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes");
    Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES,
            "too many codes");
    Tracev((stderr, "\nbl counts: "));
    send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */
00007FF7CE1501BE  mov         edx,dword ptr [rbx+28h]  
00007FF7CE1501C1  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE1501C5  movzx       eax,byte ptr [rbx+1711h]  
00007FF7CE1501CC  mov         byte ptr [rdx+rcx],al  
00007FF7CE1501CF  mov         ecx,10h  
00007FF7CE1501D4  sub         cl,byte ptr [rbx+1714h]  
00007FF7CE1501DA  inc         dword ptr [rbx+28h]  
00007FF7CE1501DD  shr         r10w,cl  
00007FF7CE1501E1  add         dword ptr [rbx+1714h],0FFFFFFF5h  
00007FF7CE1501E8  mov         word ptr [rbx+1710h],r10w  
00007FF7CE1501F0  jmp         send_all_trees+0A0h (07FF7CE150210h)  
00007FF7CE1501F2  movzx       eax,si  
00007FF7CE1501F5  mov         edx,101h  
00007FF7CE1501FA  sub         ax,dx  
00007FF7CE1501FD  shl         ax,cl  
00007FF7CE150200  or          word ptr [rbx+1710h],ax  
00007FF7CE150207  lea         eax,[rcx+5]  
00007FF7CE15020A  mov         dword ptr [rbx+1714h],eax  
    send_bits(s, dcodes-1,   5);
00007FF7CE150210  mov         ecx,dword ptr [rbx+1714h]  
00007FF7CE150216  cmp         ecx,0Bh  
00007FF7CE150219  jle         send_all_trees+104h (07FF7CE150274h)  
00007FF7CE15021B  mov         edx,dword ptr [rbx+28h]  
00007FF7CE15021E  dec         r8d  
00007FF7CE150221  movzx       eax,r8w  
00007FF7CE150225  shl         ax,cl  
00007FF7CE150228  or          word ptr [rbx+1710h],ax  
00007FF7CE15022F  movzx       eax,byte ptr [rbx+1710h]  
00007FF7CE150236  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE15023A  mov         byte ptr [rdx+rcx],al  
00007FF7CE15023D  inc         dword ptr [rbx+28h]  
00007FF7CE150240  mov         edx,dword ptr [rbx+28h]  
00007FF7CE150243  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE150247  movzx       eax,byte ptr [rbx+1711h]  
00007FF7CE15024E  mov         byte ptr [rdx+rcx],al  
00007FF7CE150251  mov         ecx,10h  
00007FF7CE150256  sub         cl,byte ptr [rbx+1714h]  
00007FF7CE15025C  inc         dword ptr [rbx+28h]  
00007FF7CE15025F  shr         r8w,cl  
    send_bits(s, dcodes-1,   5);
00007FF7CE150263  add         dword ptr [rbx+1714h],0FFFFFFF5h  
00007FF7CE15026A  mov         word ptr [rbx+1710h],r8w  
00007FF7CE150272  jmp         send_all_trees+11Bh (07FF7CE15028Bh)  
00007FF7CE150274  lea         eax,[r8-1]  
00007FF7CE150278  shl         ax,cl  
00007FF7CE15027B  or          word ptr [rbx+1710h],ax  
00007FF7CE150282  lea         eax,[rcx+5]  
00007FF7CE150285  mov         dword ptr [rbx+1714h],eax  
    send_bits(s, blcodes-4,  4); /* not -3 as stated in appnote.txt */
00007FF7CE15028B  mov         ecx,dword ptr [rbx+1714h]  
00007FF7CE150291  cmp         ecx,0Ch  
00007FF7CE150294  jle         send_all_trees+180h (07FF7CE1502F0h)  
00007FF7CE150296  mov         edx,dword ptr [rbx+28h]  
00007FF7CE150299  lea         r8d,[r11-4]  
00007FF7CE15029D  movzx       eax,r8w  
00007FF7CE1502A1  shl         ax,cl  
00007FF7CE1502A4  or          word ptr [rbx+1710h],ax  
00007FF7CE1502AB  movzx       eax,byte ptr [rbx+1710h]  
00007FF7CE1502B2  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE1502B6  mov         byte ptr [rdx+rcx],al  
00007FF7CE1502B9  inc         dword ptr [rbx+28h]  
00007FF7CE1502BC  mov         edx,dword ptr [rbx+28h]  
00007FF7CE1502BF  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE1502C3  movzx       eax,byte ptr [rbx+1711h]  
00007FF7CE1502CA  mov         byte ptr [rdx+rcx],al  
00007FF7CE1502CD  mov         ecx,10h  
00007FF7CE1502D2  sub         cl,byte ptr [rbx+1714h]  
00007FF7CE1502D8  inc         dword ptr [rbx+28h]  
00007FF7CE1502DB  shr         r8w,cl  
00007FF7CE1502DF  add         dword ptr [rbx+1714h],0FFFFFFF4h  
00007FF7CE1502E6  mov         word ptr [rbx+1710h],r8w  
00007FF7CE1502EE  jmp         send_all_trees+197h (07FF7CE150307h)  
00007FF7CE1502F0  lea         eax,[r11-4]  
00007FF7CE1502F4  shl         ax,cl  
00007FF7CE1502F7  or          word ptr [rbx+1710h],ax  
00007FF7CE1502FE  lea         eax,[rcx+4]  
00007FF7CE150301  mov         dword ptr [rbx+1714h],eax  
    for (rank = 0; rank < blcodes; rank++) {
00007FF7CE150307  test        r11d,r11d  
00007FF7CE15030A  jle         send_all_trees+246h (07FF7CE1503B6h)  
    for (rank = 0; rank < blcodes; rank++) {
00007FF7CE150310  lea         r9,[bl_order (07FF7CE178818h)]  
00007FF7CE150317  mov         r10,r11  
00007FF7CE15031A  nop         word ptr [rax+rax]  
        Tracev((stderr, "\nbl code %2d ", bl_order[rank]));
        send_bits(s, s->bl_tree[bl_order[rank]].Len, 3);
00007FF7CE150320  mov         ecx,dword ptr [rbx+1714h]  
00007FF7CE150326  movzx       eax,byte ptr [r9]  
00007FF7CE15032A  cmp         ecx,0Dh  
00007FF7CE15032D  jle         send_all_trees+21Eh (07FF7CE15038Eh)  
00007FF7CE15032F  movzx       r8d,word ptr [rbx+rax*4+0AA6h]  
00007FF7CE150338  mov         edx,dword ptr [rbx+28h]  
00007FF7CE15033B  movzx       eax,r8w  
00007FF7CE15033F  shl         ax,cl  
00007FF7CE150342  or          word ptr [rbx+1710h],ax  
00007FF7CE150349  movzx       eax,byte ptr [rbx+1710h]  
00007FF7CE150350  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE150354  mov         byte ptr [rdx+rcx],al  
00007FF7CE150357  inc         dword ptr [rbx+28h]  
00007FF7CE15035A  mov         edx,dword ptr [rbx+28h]  
00007FF7CE15035D  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE150361  movzx       eax,byte ptr [rbx+1711h]  
00007FF7CE150368  mov         byte ptr [rdx+rcx],al  
00007FF7CE15036B  mov         ecx,10h  
00007FF7CE150370  sub         cl,byte ptr [rbx+1714h]  
00007FF7CE150376  inc         dword ptr [rbx+28h]  
00007FF7CE150379  shr         r8w,cl  
00007FF7CE15037D  add         dword ptr [rbx+1714h],0FFFFFFF3h  
00007FF7CE150384  mov         word ptr [rbx+1710h],r8w  
00007FF7CE15038C  jmp         send_all_trees+239h (07FF7CE1503A9h)  
00007FF7CE15038E  movzx       edx,word ptr [rbx+rax*4+0AA6h]  
00007FF7CE150396  lea         eax,[rcx+3]  
00007FF7CE150399  shl         dx,cl  
00007FF7CE15039C  or          word ptr [rbx+1710h],dx  
00007FF7CE1503A3  mov         dword ptr [rbx+1714h],eax  
    for (rank = 0; rank < blcodes; rank++) {
00007FF7CE1503A9  inc         r9  
00007FF7CE1503AC  sub         r10,1  
00007FF7CE1503B0  jne         send_all_trees+1B0h (07FF7CE150320h)  
    }
    Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
 
    send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
00007FF7CE1503B6  lea         r8d,[rsi-1]  
00007FF7CE1503BA  mov         rcx,rbx  
00007FF7CE1503BD  lea         rdx,[rbx+0BCh]  
    }
    Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent));
 
    send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */
00007FF7CE1503C4  call        send_tree (07FF7CE14FB10h)  
    Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
 
    send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
00007FF7CE1503C9  lea         r8d,[rdi-1]  
00007FF7CE1503CD  mov         rcx,rbx  
00007FF7CE1503D0  lea         rdx,[rbx+9B0h]  
    Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent));
}
00007FF7CE1503D7  mov         rbx,qword ptr [rsp+30h]  
00007FF7CE1503DC  mov         rsi,qword ptr [rsp+38h]  
00007FF7CE1503E1  add         rsp,20h  
00007FF7CE1503E5  pop         rdi  
    Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent));
 
    send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */
00007FF7CE1503E6  jmp         send_tree (07FF7CE14FB10h)  
00007FF7CE1503EB  int         3  
00007FF7CE1503EC  int         3  
00007FF7CE1503ED  int         3  
00007FF7CE1503EE  int         3  
00007FF7CE1503EF  int         3  
 
/* ===========================================================================
 * Send a stored block
 */
void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last)
    deflate_state *s;
    charf *buf;       /* input block */
    ulg stored_len;   /* length of input block */
    int last;         /* one if this is the last block for a file */
{
00007FF7CE1503F0  mov         r10,rcx  
00007FF7CE1503F3  mov         r11,rdx  
    send_bits(s, (STORED_BLOCK<<1)+last, 3);    /* send block type */
00007FF7CE1503F6  mov         ecx,dword ptr [rcx+1714h]  
00007FF7CE1503FC  cmp         ecx,0Dh  
00007FF7CE1503FF  jle         _tr_stored_block+79h (07FF7CE150469h)  
00007FF7CE150401  mov         edx,dword ptr [r10+28h]  
00007FF7CE150405  movzx       eax,r9w  
00007FF7CE150409  shl         ax,cl  
00007FF7CE15040C  or          word ptr [r10+1710h],ax  
00007FF7CE150414  movzx       eax,byte ptr [r10+1710h]  
00007FF7CE15041C  mov         rcx,qword ptr [r10+10h]  
00007FF7CE150420  mov         byte ptr [rdx+rcx],al  
00007FF7CE150423  inc         dword ptr [r10+28h]  
00007FF7CE150427  mov         edx,dword ptr [r10+28h]  
00007FF7CE15042B  mov         rcx,qword ptr [r10+10h]  
00007FF7CE15042F  movzx       eax,byte ptr [r10+1711h]  
00007FF7CE150437  mov         byte ptr [rdx+rcx],al  
00007FF7CE15043A  mov         ecx,10h  
00007FF7CE15043F  sub         cl,byte ptr [r10+1714h]  
#ifdef DEBUG
    s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
    s->compressed_len += (stored_len + 4) << 3;
#endif
    copy_block(s, buf, (unsigned)stored_len, 1); /* with header */
00007FF7CE150446  mov         rdx,r11  
00007FF7CE150449  inc         dword ptr [r10+28h]  
00007FF7CE15044D  add         dword ptr [r10+1714h],0FFFFFFF3h  
00007FF7CE150455  shr         r9w,cl  
00007FF7CE150459  mov         rcx,r10  
00007FF7CE15045C  ?? ?? 
00007FF7CE15045D  ?? ?? 
00007FF7CE15045E  ?? ?? 
00007FF7CE15045F  ?? ?? 
00007FF7CE150460  ?? ?? 
00007FF7CE150461  ?? ?? 
00007FF7CE150462  ?? ?? 
00007FF7CE150463  ?? ?? 
00007FF7CE150464  ?? ?? 
00007FF7CE150465  ?? ?? 
00007FF7CE150466  ?? ?? 
00007FF7CE150467  ?? ?? 
00007FF7CE150468  ?? ?? 
00007FF7CE150469  ?? ?? 
00007FF7CE15046A  ?? ?? 
00007FF7CE15046B  ?? ?? 
00007FF7CE15046C  ?? ?? 
00007FF7CE15046D  ?? ?? 
00007FF7CE15046E  ?? ?? 
00007FF7CE15046F  ?? ?? 
00007FF7CE150470  ?? ?? 
00007FF7CE150471  ?? ?? 
00007FF7CE150472  ?? ?? 
00007FF7CE150473  ?? ?? 
00007FF7CE150474  ?? ?? 
00007FF7CE150475  ?? ?? 
00007FF7CE150476  ?? ?? 
00007FF7CE150477  ?? ?? 
00007FF7CE150478  ?? ?? 
00007FF7CE150479  ?? ?? 
00007FF7CE15047A  ?? ?? 
00007FF7CE15047B  ?? ?? 
00007FF7CE15047C  ?? ?? 
00007FF7CE15047D  ?? ?? 
00007FF7CE15047E  ?? ?? 
00007FF7CE15047F  ?? ?? 
00007FF7CE150480  ?? ?? 
00007FF7CE150481  adc         al,17h  
00007FF7CE150483  ?? ?? 
00007FF7CE150484  ?? ?? 
00007FF7CE150485  ?? ?? 
00007FF7CE150486  ?? ?? 
00007FF7CE150487  ?? ?? 
00007FF7CE150488  ?? ?? 
00007FF7CE150489  ?? ?? 
00007FF7CE15048A  ?? ?? 
00007FF7CE15048B  ?? ?? 
00007FF7CE15048C  ?? ?? 
00007FF7CE15048D  ?? ?? 
00007FF7CE15048E  ?? ?? 
00007FF7CE15048F  ?? ?? 
00007FF7CE150490  ?? ?? 
00007FF7CE150491  ?? ?? 
00007FF7CE150492  ?? ?? 
00007FF7CE150493  ?? ?? 
00007FF7CE150494  ?? ?? 
00007FF7CE150495  ?? ?? 
00007FF7CE150496  ?? ?? 
00007FF7CE150497  ?? ?? 
00007FF7CE150498  ?? ?? 
00007FF7CE150499  ?? ?? 
00007FF7CE15049A  ?? ?? 
00007FF7CE15049B  ?? ?? 
00007FF7CE15049C  ?? ?? 
00007FF7CE15049D  ?? ?? 
00007FF7CE15049E  ?? ?? 
00007FF7CE15049F  ?? ?? 
00007FF7CE1504A0  ?? ?? 
00007FF7CE1504A1  ?? ?? 
00007FF7CE1504A2  ?? ?? 
00007FF7CE1504A3  ?? ?? 
00007FF7CE1504A4  ?? ?? 
00007FF7CE1504A5  ?? ?? 
00007FF7CE1504A6  ?? ?? 
00007FF7CE1504A7  ?? ?? 
}
 
/* ===========================================================================
 * Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
 */
void ZLIB_INTERNAL _tr_flush_bits(s)
    deflate_state *s;
{
    bi_flush(s);
}
 
/* ===========================================================================
 * Send one empty static block to give enough lookahead for inflate.
 * This takes 10 bits, of which 7 may remain in the bit buffer.
 */
void ZLIB_INTERNAL _tr_align(s)
    deflate_state *s;
{
    send_bits(s, STATIC_TREES<<1, 3);
    send_code(s, END_BLOCK, static_ltree);
#ifdef DEBUG
    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
#endif
    bi_flush(s);
}
 
/* ===========================================================================
 * Determine the best encoding for the current block: dynamic trees, static
 * trees or store, and output the encoded block to the zip file.
 */
void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
    deflate_state *s;
    charf *buf;       /* input block, or NULL if too old */
    ulg stored_len;   /* length of input block */
    int last;         /* one if this is the last block for a file */
{
00007FF7CE1504A8  in          al,dx  
}
 
/* ===========================================================================
 * Flush the bits in the bit buffer to pending output (leaves at most 7 bits)
 */
void ZLIB_INTERNAL _tr_flush_bits(s)
    deflate_state *s;
{
    bi_flush(s);
}
 
/* ===========================================================================
 * Send one empty static block to give enough lookahead for inflate.
 * This takes 10 bits, of which 7 may remain in the bit buffer.
 */
void ZLIB_INTERNAL _tr_align(s)
    deflate_state *s;
{
    send_bits(s, STATIC_TREES<<1, 3);
    send_code(s, END_BLOCK, static_ltree);
#ifdef DEBUG
    s->compressed_len += 10L; /* 3 for block type, 7 for EOB */
#endif
    bi_flush(s);
}
 
/* ===========================================================================
 * Determine the best encoding for the current block: dynamic trees, static
 * trees or store, and output the encoded block to the zip file.
 */
void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last)
    deflate_state *s;
    charf *buf;       /* input block, or NULL if too old */
    ulg stored_len;   /* length of input block */
    int last;         /* one if this is the last block for a file */
{
00007FF7CE1504A9  and         byte ptr [rbp+33h],al  
    ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */
    int max_blindex = 0;  /* index of last bit length code of non zero freq */
00007FF7CE1504AC  test        byte ptr [rcx-75h],0F9h  
00007FF7CE1504B0  mov         esi,r8d  
00007FF7CE1504B3  mov         rbp,rdx  
00007FF7CE1504B6  mov         rbx,rcx  
00007FF7CE1504B9  mov         r9d,r14d  
 
    /* Build the Huffman trees unless a stored block is forced */
    if (s->level > 0) {
00007FF7CE1504BC  cmp         dword ptr [rcx+0ACh],r14d  
00007FF7CE1504C3  jle         _tr_flush_block+8Fh (07FF7CE15051Fh)  
 
        /* Check if the file is binary or text */
        if (s->strm->data_type == Z_UNKNOWN)
00007FF7CE1504C5  mov         r10,qword ptr [rcx]  
00007FF7CE1504C8  cmp         dword ptr [r10+48h],2  
00007FF7CE1504CD  jne         _tr_flush_block+48h (07FF7CE1504D8h)  
            s->strm->data_type = detect_data_type(s);
00007FF7CE1504CF  call        detect_data_type (07FF7CE150B60h)  
00007FF7CE1504D4  mov         dword ptr [r10+48h],eax  
 
        /* Construct the literal and distance trees */
        build_tree(s, (tree_desc *)(&(s->l_desc)));
00007FF7CE1504D8  lea         rdx,[rbx+0B40h]  
00007FF7CE1504DF  mov         rcx,rbx  
00007FF7CE1504E2  call        build_tree (07FF7CE14F740h)  
        Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len,
                s->static_len));
 
        build_tree(s, (tree_desc *)(&(s->d_desc)));
00007FF7CE1504E7  lea         rdx,[rbx+0B58h]  
00007FF7CE1504EE  mov         rcx,rbx  
00007FF7CE1504F1  call        build_tree (07FF7CE14F740h)  
        Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len,
                s->static_len));
        /* At this point, opt_len and static_len are the total bit lengths of
         * the compressed block data, excluding the tree representations.
         */
 
        /* Build the bit length tree for the above two trees, and get the index
         * in bl_order of the last bit length code to send.
         */
        max_blindex = build_bl_tree(s);
00007FF7CE1504F6  mov         rcx,rbx  
00007FF7CE1504F9  call        build_bl_tree (07FF7CE1500A0h)  
 
        /* Determine the best encoding. Compute the block lengths in bytes. */
        opt_lenb = (s->opt_len+3+7)>>3;
00007FF7CE1504FE  mov         ecx,dword ptr [rbx+1700h]  
00007FF7CE150504  mov         r9d,eax  
        static_lenb = (s->static_len+3+7)>>3;
00007FF7CE150507  mov         edx,dword ptr [rbx+1704h]  
00007FF7CE15050D  add         ecx,0Ah  
00007FF7CE150510  add         edx,0Ah  
00007FF7CE150513  shr         ecx,3  
00007FF7CE150516  shr         edx,3  
 
        Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ",
                opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len,
                s->last_lit));
 
        if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
00007FF7CE150519  cmp         edx,ecx  
00007FF7CE15051B  ja          _tr_flush_block+95h (07FF7CE150525h)  
 
    } else {
00007FF7CE15051D  jmp         _tr_flush_block+93h (07FF7CE150523h)  
        Assert(buf != (char*)0, "lost buf");
        opt_lenb = static_lenb = stored_len + 5; /* force a stored block */
00007FF7CE15051F  lea         edx,[r8+5]  
00007FF7CE150523  mov         ecx,edx  
    }
 
#ifdef FORCE_STORED
    if (buf != (char*)0) { /* force stored block */
#else
    if (stored_len+4 <= opt_lenb && buf != (char*)0) {
00007FF7CE150525  lea         eax,[rsi+4]  
00007FF7CE150528  cmp         eax,ecx  
00007FF7CE15052A  ja          _tr_flush_block+0B7h (07FF7CE150547h)  
00007FF7CE15052C  test        rbp,rbp  
00007FF7CE15052F  je          _tr_flush_block+0B7h (07FF7CE150547h)  
                       /* 4: two words for the lengths */
#endif
        /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
         * Otherwise we can't have processed more than WSIZE input bytes since
         * the last block flush, because compression would have been
         * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
         * transform a block into a stored block.
         */
        _tr_stored_block(s, buf, stored_len, last);
00007FF7CE150531  mov         r9d,edi  
                       /* 4: two words for the lengths */
#endif
        /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE.
         * Otherwise we can't have processed more than WSIZE input bytes since
         * the last block flush, because compression would have been
         * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to
         * transform a block into a stored block.
         */
        _tr_stored_block(s, buf, stored_len, last);
00007FF7CE150534  mov         r8d,esi  
00007FF7CE150537  mov         rdx,rbp  
00007FF7CE15053A  mov         rcx,rbx  
00007FF7CE15053D  call        _tr_stored_block (07FF7CE1503F0h)  
00007FF7CE150542  jmp         _tr_flush_block+208h (07FF7CE150698h)  
 
#ifdef FORCE_STATIC
    } else if (static_lenb >= 0) { /* force static trees */
#else
    } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) {
00007FF7CE150547  cmp         dword ptr [rbx+0B0h],4  
00007FF7CE15054E  je          _tr_flush_block+177h (07FF7CE150607h)  
00007FF7CE150554  cmp         edx,ecx  
00007FF7CE150556  je          _tr_flush_block+177h (07FF7CE150607h)  
                       (const ct_data *)static_dtree);
#ifdef DEBUG
        s->compressed_len += 3 + s->static_len;
#endif
    } else {
        send_bits(s, (DYN_TREES<<1)+last, 3);
00007FF7CE15055C  mov         ecx,dword ptr [rbx+1714h]  
00007FF7CE150562  cmp         ecx,0Dh  
00007FF7CE150565  jle         _tr_flush_block+131h (07FF7CE1505C1h)  
00007FF7CE150567  mov         edx,dword ptr [rbx+28h]  
00007FF7CE15056A  lea         r8d,[rdi+4]  
00007FF7CE15056E  movzx       eax,r8w  
00007FF7CE150572  shl         ax,cl  
00007FF7CE150575  or          word ptr [rbx+1710h],ax  
00007FF7CE15057C  movzx       eax,byte ptr [rbx+1710h]  
00007FF7CE150583  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE150587  mov         byte ptr [rdx+rcx],al  
00007FF7CE15058A  inc         dword ptr [rbx+28h]  
00007FF7CE15058D  mov         edx,dword ptr [rbx+28h]  
00007FF7CE150590  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE150594  movzx       eax,byte ptr [rbx+1711h]  
00007FF7CE15059B  mov         byte ptr [rdx+rcx],al  
00007FF7CE15059E  mov         ecx,10h  
00007FF7CE1505A3  sub         cl,byte ptr [rbx+1714h]  
00007FF7CE1505A9  inc         dword ptr [rbx+28h]  
00007FF7CE1505AC  shr         r8w,cl  
00007FF7CE1505B0  add         dword ptr [rbx+1714h],0FFFFFFF3h  
00007FF7CE1505B7  mov         word ptr [rbx+1710h],r8w  
00007FF7CE1505BF  jmp         _tr_flush_block+147h (07FF7CE1505D7h)  
00007FF7CE1505C1  lea         eax,[rdi+4]  
00007FF7CE1505C4  shl         ax,cl  
00007FF7CE1505C7  or          word ptr [rbx+1710h],ax  
00007FF7CE1505CE  lea         eax,[rcx+3]  
00007FF7CE1505D1  mov         dword ptr [rbx+1714h],eax  
        send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
00007FF7CE1505D7  mov         r8d,dword ptr [rbx+0B60h]  
        send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1,
00007FF7CE1505DE  inc         r9d  
00007FF7CE1505E1  mov         edx,dword ptr [rbx+0B48h]  
00007FF7CE1505E7  inc         r8d  
00007FF7CE1505EA  inc         edx  
00007FF7CE1505EC  mov         rcx,rbx  
00007FF7CE1505EF  call        send_all_trees (07FF7CE150170h)  
                       max_blindex+1);
        compress_block(s, (const ct_data *)s->dyn_ltree,
00007FF7CE1505F4  lea         r8,[rbx+9B0h]  
00007FF7CE1505FB  lea         rdx,[rbx+0BCh]  
00007FF7CE150602  jmp         _tr_flush_block+200h (07FF7CE150690h)  
#endif
        send_bits(s, (STATIC_TREES<<1)+last, 3);
00007FF7CE150607  mov         ecx,dword ptr [rbx+1714h]  
00007FF7CE15060D  cmp         ecx,0Dh  
00007FF7CE150610  jle         _tr_flush_block+1DCh (07FF7CE15066Ch)  
00007FF7CE150612  mov         edx,dword ptr [rbx+28h]  
00007FF7CE150615  lea         r8d,[rdi+2]  
00007FF7CE150619  movzx       eax,r8w  
00007FF7CE15061D  shl         ax,cl  
00007FF7CE150620  or          word ptr [rbx+1710h],ax  
00007FF7CE150627  movzx       eax,byte ptr [rbx+1710h]  
00007FF7CE15062E  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE150632  mov         byte ptr [rdx+rcx],al  
00007FF7CE150635  inc         dword ptr [rbx+28h]  
00007FF7CE150638  mov         edx,dword ptr [rbx+28h]  
00007FF7CE15063B  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE15063F  movzx       eax,byte ptr [rbx+1711h]  
00007FF7CE150646  mov         byte ptr [rdx+rcx],al  
00007FF7CE150649  mov         ecx,10h  
00007FF7CE15064E  sub         cl,byte ptr [rbx+1714h]  
00007FF7CE150654  inc         dword ptr [rbx+28h]  
00007FF7CE150657  shr         r8w,cl  
00007FF7CE15065B  add         dword ptr [rbx+1714h],0FFFFFFF3h  
00007FF7CE150662  mov         word ptr [rbx+1710h],r8w  
00007FF7CE15066A  jmp         _tr_flush_block+1F2h (07FF7CE150682h)  
00007FF7CE15066C  lea         eax,[rdi+2]  
00007FF7CE15066F  shl         ax,cl  
00007FF7CE150672  or          word ptr [rbx+1710h],ax  
00007FF7CE150679  lea         eax,[rcx+3]  
00007FF7CE15067C  mov         dword ptr [rbx+1714h],eax  
        compress_block(s, (const ct_data *)static_ltree,
00007FF7CE150682  lea         r8,[static_dtree (07FF7CE1787A0h)]  
        compress_block(s, (const ct_data *)static_ltree,
00007FF7CE150689  lea         rdx,[static_ltree (07FF7CE178A80h)]  
00007FF7CE150690  mov         rcx,rbx  
00007FF7CE150693  call        compress_block (07FF7CE150710h)  
                       (const ct_data *)s->dyn_dtree);
#ifdef DEBUG
        s->compressed_len += 3 + s->opt_len;
#endif
    }
    Assert (s->compressed_len == s->bits_sent, "bad compressed size");
    /* The above check is made mod 2^32, for files larger than 512 MB
     * and uLong implemented on 32 bits.
     */
    init_block(s);
00007FF7CE150698  mov         rcx,rbx  
00007FF7CE15069B  call        init_block (07FF7CE14F3A0h)  
 
    if (last) {
00007FF7CE1506A0  test        edi,edi  
00007FF7CE1506A2  je          _tr_flush_block+263h (07FF7CE1506F3h)  
        bi_windup(s);
00007FF7CE1506A4  mov         eax,dword ptr [rbx+1714h]  
00007FF7CE1506AA  cmp         eax,8  
00007FF7CE1506AD  jle         _tr_flush_block+23Ch (07FF7CE1506CCh)  
00007FF7CE1506AF  mov         edx,dword ptr [rbx+28h]  
00007FF7CE1506B2  movzx       eax,byte ptr [rbx+1710h]  
00007FF7CE1506B9  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE1506BD  mov         byte ptr [rdx+rcx],al  
00007FF7CE1506C0  inc         dword ptr [rbx+28h]  
00007FF7CE1506C3  movzx       eax,byte ptr [rbx+1711h]  
00007FF7CE1506CA  jmp         _tr_flush_block+247h (07FF7CE1506D7h)  
00007FF7CE1506CC  test        eax,eax  
00007FF7CE1506CE  jle         _tr_flush_block+254h (07FF7CE1506E4h)  
00007FF7CE1506D0  movzx       eax,byte ptr [rbx+1710h]  
00007FF7CE1506D7  mov         edx,dword ptr [rbx+28h]  
00007FF7CE1506DA  mov         rcx,qword ptr [rbx+10h]  
00007FF7CE1506DE  mov         byte ptr [rdx+rcx],al  
00007FF7CE1506E1  inc         dword ptr [rbx+28h]  
00007FF7CE1506E4  mov         word ptr [rbx+1710h],r14w  
00007FF7CE1506EC  mov         dword ptr [rbx+1714h],r14d  
#ifdef DEBUG
        s->compressed_len += 7;  /* align on byte boundary */
#endif
    }
    Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3,
           s->compressed_len-7*last));
}
00007FF7CE1506F3  mov         rbx,qword ptr [rsp+30h]  
00007FF7CE1506F8  mov         rbp,qword ptr [rsp+38h]  
00007FF7CE1506FD  mov         rsi,qword ptr [rsp+40h]  
00007FF7CE150702  mov         rdi,qword ptr [rsp+48h]  
00007FF7CE150707  add         rsp,20h  
00007FF7CE15070B  pop         r14  
00007FF7CE15070D  ret  
00007FF7CE15070E  int         3  
00007FF7CE15070F  int         3  
 
/* ===========================================================================
 * Save the match info and tally the frequency counts. Return true if
 * the current block must be flushed.
 */
int ZLIB_INTERNAL _tr_tally (s, dist, lc)
    deflate_state *s;
    unsigned dist;  /* distance of matched string */
    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
{
    s->d_buf[s->last_lit] = (ush)dist;
    s->l_buf[s->last_lit++] = (uch)lc;
    if (dist == 0) {
        /* lc is the unmatched char */
        s->dyn_ltree[lc].Freq++;
    } else {
        s->matches++;
        /* Here, lc is the match length - MIN_MATCH */
        dist--;             /* dist = match distance - 1 */
        Assert((ush)dist < (ush)MAX_DIST(s) &&
               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
               (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
 
        s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
        s->dyn_dtree[d_code(dist)].Freq++;
    }
 
#ifdef TRUNCATE_BLOCK
    /* Try to guess if it is profitable to stop the current block here */
    if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
        /* Compute an upper bound for the compressed length */
        ulg out_length = (ulg)s->last_lit*8L;
        ulg in_length = (ulg)((long)s->strstart - s->block_start);
        int dcode;
        for (dcode = 0; dcode < D_CODES; dcode++) {
            out_length += (ulg)s->dyn_dtree[d_code].Freq *
                (5L+extra_dbits[d_code]);
        }
        out_length >>= 3;
        Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
               s->last_lit, in_length, out_length,
               100L - out_length*100L/in_length));
        if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
    }
#endif
    return (s->last_lit == s->lit_bufsize-1);
    /* We avoid equality with lit_bufsize because of wraparound at 64K
     * on 16 bit machines and because stored blocks are restricted to
     * 64K-1 bytes.
     */
}
 
/* ===========================================================================
 * Send the block data compressed using the given Huffman trees
 */
local void compress_block(s, ltree, dtree)
    deflate_state *s;
    const ct_data *ltree; /* literal tree */
    const ct_data *dtree; /* distance tree */
{
00007FF7CE150710  push        rbx  
00007FF7CE150712  push        r14  
 
/* ===========================================================================
 * Save the match info and tally the frequency counts. Return true if
 * the current block must be flushed.
 */
int ZLIB_INTERNAL _tr_tally (s, dist, lc)
    deflate_state *s;
    unsigned dist;  /* distance of matched string */
    unsigned lc;    /* match length-MIN_MATCH or unmatched char (if dist==0) */
{
    s->d_buf[s->last_lit] = (ush)dist;
    s->l_buf[s->last_lit++] = (uch)lc;
    if (dist == 0) {
        /* lc is the unmatched char */
        s->dyn_ltree[lc].Freq++;
    } else {
        s->matches++;
        /* Here, lc is the match length - MIN_MATCH */
        dist--;             /* dist = match distance - 1 */
        Assert((ush)dist < (ush)MAX_DIST(s) &&
               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
               (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");
 
        s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++;
        s->dyn_dtree[d_code(dist)].Freq++;
    }
 
#ifdef TRUNCATE_BLOCK
    /* Try to guess if it is profitable to stop the current block here */
    if ((s->last_lit & 0x1fff) == 0 && s->level > 2) {
        /* Compute an upper bound for the compressed length */
        ulg out_length = (ulg)s->last_lit*8L;
        ulg in_length = (ulg)((long)s->strstart - s->block_start);
        int dcode;
        for (dcode = 0; dcode < D_CODES; dcode++) {
            out_length += (ulg)s->dyn_dtree[d_code].Freq *
                (5L+extra_dbits[d_code]);
        }
        out_length >>= 3;
        Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ",
               s->last_lit, in_length, out_length,
               100L - out_length*100L/in_length));
        if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1;
    }
#endif
    return (s->last_lit == s->lit_bufsize-1);
    /* We avoid equality with lit_bufsize because of wraparound at 64K
     * on 16 bit machines and because stored blocks are restricted to
     * 64K-1 bytes.
     */
}
 
/* ===========================================================================
 * Send the block data compressed using the given Huffman trees
 */
local void compress_block(s, ltree, dtree)
    deflate_state *s;
    const ct_data *ltree; /* literal tree */
    const ct_data *dtree; /* distance tree */
{
00007FF7CE150714  sub         rsp,8  
00007FF7CE150718  mov         qword ptr [rsp+20h],rbp  
00007FF7CE15071D  mov         r14,rdx  
    unsigned dist;      /* distance of matched string */
    int lc;             /* match length or unmatched char (if dist == 0) */
    unsigned lx = 0;    /* running index in l_buf */
00007FF7CE150720  xor         ebp,ebp  
00007FF7CE150722  mov         qword ptr [rsp],r15  
00007FF7CE150726  mov         r15,r8  
00007FF7CE150729  mov         rax,rcx  
    unsigned code;      /* the code to send */
    int extra;          /* number of extra bits to send */
 
    if (s->last_lit != 0) do {
00007FF7CE15072C  lea         ebx,[rbp+10h]  
00007FF7CE15072F  cmp         dword ptr [rcx+16F4h],ebp  
00007FF7CE150735  je          compress_block+396h (07FF7CE150AA6h)  
00007FF7CE15073B  mov         qword ptr [rsp+38h],r12  
00007FF7CE150740  lea         r12,[`__local_stdio_scanf_options'::`2'::_OptionsStorage (07FF7CE130000h)]  
00007FF7CE150747  mov         qword ptr [rsp+28h],rsi  
00007FF7CE15074C  mov         qword ptr [rsp+30h],rdi  
        dist = s->d_buf[lx];
00007FF7CE150751  mov         rcx,qword ptr [rax+16F8h]  
        lc = s->l_buf[lx++];
        if (dist == 0) {
            send_code(s, lc, ltree); /* send a literal byte */
00007FF7CE150758  mov         edx,ebx  
00007FF7CE15075A  movzx       r10d,word ptr [rcx+rbp*2]  
00007FF7CE15075F  mov         rcx,qword ptr [rax+16E8h]  
00007FF7CE150766  movzx       r11d,byte ptr [rbp+rcx]  
00007FF7CE15076C  inc         ebp  
00007FF7CE15076E  test        r10d,r10d  
00007FF7CE150771  jne         compress_block+0F8h (07FF7CE150808h)  
00007FF7CE150777  movsxd      rcx,r11d  
00007FF7CE15077A  movzx       r10d,word ptr [r14+rcx*4+2]  
00007FF7CE150780  lea         r8,[r14+rcx*4]  
00007FF7CE150784  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE15078A  sub         edx,r10d  
00007FF7CE15078D  cmp         ecx,edx  
00007FF7CE15078F  jle         compress_block+0E2h (07FF7CE1507F2h)  
00007FF7CE150791  movzx       r9d,word ptr [r8]  
00007FF7CE150795  mov         r8d,dword ptr [rax+28h]  
00007FF7CE150799  movzx       edx,r9w  
00007FF7CE15079D  shl         dx,cl  
00007FF7CE1507A0  or          word ptr [rax+1710h],dx  
00007FF7CE1507A7  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE1507AE  mov         rdx,qword ptr [rax+10h]  
00007FF7CE1507B2  mov         byte ptr [r8+rdx],cl  
00007FF7CE1507B6  inc         dword ptr [rax+28h]  
        lc = s->l_buf[lx++];
        if (dist == 0) {
            send_code(s, lc, ltree); /* send a literal byte */
00007FF7CE1507B9  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE1507C0  mov         r8d,dword ptr [rax+28h]  
00007FF7CE1507C4  mov         rdx,qword ptr [rax+10h]  
00007FF7CE1507C8  mov         byte ptr [r8+rdx],cl  
00007FF7CE1507CC  mov         ecx,ebx  
00007FF7CE1507CE  sub         cl,byte ptr [rax+1714h]  
00007FF7CE1507D4  inc         dword ptr [rax+28h]  
00007FF7CE1507D7  shr         r9w,cl  
00007FF7CE1507DB  lea         ecx,[r10-10h]  
00007FF7CE1507DF  add         dword ptr [rax+1714h],ecx  
00007FF7CE1507E5  mov         word ptr [rax+1710h],r9w  
00007FF7CE1507ED  jmp         compress_block+37Bh (07FF7CE150A8Bh)  
00007FF7CE1507F2  movzx       edx,word ptr [r8]  
00007FF7CE1507F6  shl         dx,cl  
00007FF7CE1507F9  or          word ptr [rax+1710h],dx  
00007FF7CE150800  add         ecx,r10d  
            Tracecv(isgraph(lc), (stderr," '%c' ", lc));
        } else {
00007FF7CE150803  jmp         compress_block+375h (07FF7CE150A85h)  
            /* Here, lc is the match length - MIN_MATCH */
            code = _length_code[lc];
00007FF7CE150808  movzx       esi,byte ptr [r11+r12+484A0h]  
            send_code(s, code+LITERALS+1, ltree); /* send the length code */
00007FF7CE150811  lea         ecx,[rsi+101h]  
00007FF7CE150817  movzx       edi,word ptr [r14+rcx*4+2]  
00007FF7CE15081D  lea         r8,[r14+rcx*4]  
00007FF7CE150821  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE150827  sub         edx,edi  
00007FF7CE150829  cmp         ecx,edx  
00007FF7CE15082B  jle         compress_block+17Ah (07FF7CE15088Ah)  
00007FF7CE15082D  movzx       r9d,word ptr [r8]  
00007FF7CE150831  mov         r8d,dword ptr [rax+28h]  
00007FF7CE150835  movzx       edx,r9w  
00007FF7CE150839  shl         dx,cl  
00007FF7CE15083C  or          word ptr [rax+1710h],dx  
00007FF7CE150843  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE15084A  mov         rdx,qword ptr [rax+10h]  
00007FF7CE15084E  mov         byte ptr [r8+rdx],cl  
00007FF7CE150852  inc         dword ptr [rax+28h]  
00007FF7CE150855  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE15085C  mov         r8d,dword ptr [rax+28h]  
00007FF7CE150860  mov         rdx,qword ptr [rax+10h]  
00007FF7CE150864  mov         byte ptr [r8+rdx],cl  
            send_code(s, code+LITERALS+1, ltree); /* send the length code */
00007FF7CE150868  mov         ecx,ebx  
00007FF7CE15086A  sub         cl,byte ptr [rax+1714h]  
00007FF7CE150870  inc         dword ptr [rax+28h]  
00007FF7CE150873  shr         r9w,cl  
00007FF7CE150877  lea         ecx,[rdi-10h]  
00007FF7CE15087A  add         dword ptr [rax+1714h],ecx  
00007FF7CE150880  mov         word ptr [rax+1710h],r9w  
00007FF7CE150888  jmp         compress_block+190h (07FF7CE1508A0h)  
00007FF7CE15088A  movzx       edx,word ptr [r8]  
00007FF7CE15088E  shl         dx,cl  
00007FF7CE150891  or          word ptr [rax+1710h],dx  
00007FF7CE150898  add         ecx,edi  
00007FF7CE15089A  mov         dword ptr [rax+1714h],ecx  
            extra = extra_lbits[_code];
00007FF7CE1508A0  mov         r9d,dword ptr [r12+rsi*4+48830h]  
            if (extra != 0) {
00007FF7CE1508A8  test        r9d,r9d  
00007FF7CE1508AB  je          compress_block+227h (07FF7CE150937h)  
                lc -= base_length[_code];
00007FF7CE1508B1  sub         r11d,dword ptr [r12+rsi*4+48980h]  
                send_bits(s, lc, extra);       /* send the extra length bits */
00007FF7CE1508B9  mov         edx,ebx  
00007FF7CE1508BB  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE1508C1  sub         edx,r9d  
00007FF7CE1508C4  cmp         ecx,edx  
00007FF7CE1508C6  jle         compress_block+212h (07FF7CE150922h)  
00007FF7CE1508C8  mov         r8d,dword ptr [rax+28h]  
00007FF7CE1508CC  movzx       edx,r11w  
00007FF7CE1508D0  shl         dx,cl  
00007FF7CE1508D3  or          word ptr [rax+1710h],dx  
00007FF7CE1508DA  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE1508E1  mov         rdx,qword ptr [rax+10h]  
00007FF7CE1508E5  mov         byte ptr [r8+rdx],cl  
00007FF7CE1508E9  inc         dword ptr [rax+28h]  
00007FF7CE1508EC  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE1508F3  mov         r8d,dword ptr [rax+28h]  
00007FF7CE1508F7  mov         rdx,qword ptr [rax+10h]  
00007FF7CE1508FB  mov         byte ptr [r8+rdx],cl  
00007FF7CE1508FF  mov         ecx,ebx  
00007FF7CE150901  sub         cl,byte ptr [rax+1714h]  
00007FF7CE150907  inc         dword ptr [rax+28h]  
00007FF7CE15090A  shr         r11w,cl  
                send_bits(s, lc, extra);       /* send the extra length bits */
00007FF7CE15090E  lea         ecx,[r9-10h]  
00007FF7CE150912  add         dword ptr [rax+1714h],ecx  
00007FF7CE150918  mov         word ptr [rax+1710h],r11w  
00007FF7CE150920  jmp         compress_block+227h (07FF7CE150937h)  
00007FF7CE150922  shl         r11w,cl  
00007FF7CE150926  or          word ptr [rax+1710h],r11w  
00007FF7CE15092E  add         ecx,r9d  
00007FF7CE150931  mov         dword ptr [rax+1714h],ecx  
            }
            dist--; /* dist is now the match distance - 1 */
00007FF7CE150937  dec         r10d  
            code = d_code(dist);
00007FF7CE15093A  cmp         r10d,100h  
00007FF7CE150941  jae         compress_block+23Eh (07FF7CE15094Eh)  
00007FF7CE150943  movzx       edx,byte ptr [r10+r12+485A0h]  
00007FF7CE15094C  jmp         compress_block+253h (07FF7CE150963h)  
00007FF7CE15094E  mov         ecx,r10d  
00007FF7CE150951  shr         ecx,7  
00007FF7CE150954  add         ecx,100h  
00007FF7CE15095A  movzx       edx,byte ptr [rcx+r12+485A0h]  
            Assert (code < D_CODES, "bad d_code");
 
            send_code(s, code, dtree);       /* send the distance code */
00007FF7CE150963  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE150969  lea         r11,[rdx*4]  
00007FF7CE150971  movzx       edi,word ptr [r11+r15+2]  
00007FF7CE150977  mov         edx,ebx  
00007FF7CE150979  sub         edx,edi  
00007FF7CE15097B  cmp         ecx,edx  
00007FF7CE15097D  jle         compress_block+2CDh (07FF7CE1509DDh)  
00007FF7CE15097F  movzx       r9d,word ptr [r11+r15]  
00007FF7CE150984  mov         r8d,dword ptr [rax+28h]  
00007FF7CE150988  movzx       edx,r9w  
00007FF7CE15098C  shl         dx,cl  
00007FF7CE15098F  or          word ptr [rax+1710h],dx  
00007FF7CE150996  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE15099D  mov         rdx,qword ptr [rax+10h]  
00007FF7CE1509A1  mov         byte ptr [r8+rdx],cl  
00007FF7CE1509A5  inc         dword ptr [rax+28h]  
00007FF7CE1509A8  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE1509AF  mov         r8d,dword ptr [rax+28h]  
00007FF7CE1509B3  mov         rdx,qword ptr [rax+10h]  
00007FF7CE1509B7  mov         byte ptr [r8+rdx],cl  
00007FF7CE1509BB  mov         ecx,ebx  
00007FF7CE1509BD  ?? ?? 
00007FF7CE1509BE  ?? ?? 
00007FF7CE1509BF  ?? ?? 
00007FF7CE1509C0  ?? ?? 
00007FF7CE1509C1  ?? ?? 
00007FF7CE1509C2  ?? ?? 
00007FF7CE1509C3  ?? ?? 
00007FF7CE1509C4  ?? ?? 
00007FF7CE1509C5  ?? ?? 
00007FF7CE1509C6  ?? ?? 
00007FF7CE1509C7  ?? ?? 
00007FF7CE1509C8  ?? ?? 
00007FF7CE1509C9  ?? ?? 
00007FF7CE1509CA  ?? ?? 
00007FF7CE1509CB  ?? ?? 
00007FF7CE1509CC  ?? ?? 
00007FF7CE1509CD  ?? ?? 
00007FF7CE1509CE  ?? ?? 
00007FF7CE1509CF  ?? ?? 
00007FF7CE1509D0  ?? ?? 
00007FF7CE1509D1  ?? ?? 
00007FF7CE1509D2  ?? ?? 
00007FF7CE1509D3  ?? ?? 
00007FF7CE1509D4  ?? ?? 
00007FF7CE1509D5  ?? ?? 
00007FF7CE1509D6  ?? ?? 
00007FF7CE1509D7  ?? ?? 
00007FF7CE1509D8  ?? ?? 
00007FF7CE1509D9  ?? ?? 
00007FF7CE1509DA  ?? ?? 
00007FF7CE1509DB  ?? ?? 
00007FF7CE1509DC  ?? ?? 
00007FF7CE1509DD  ?? ?? 
00007FF7CE1509DE  ?? ?? 
00007FF7CE1509DF  ?? ?? 
00007FF7CE1509E0  ?? ?? 
00007FF7CE1509E1  ?? ?? 
00007FF7CE1509E2  ?? ?? 
00007FF7CE1509E3  ?? ?? 
00007FF7CE1509E4  ?? ?? 
00007FF7CE1509E5  ?? ?? 
00007FF7CE1509E6  ?? ?? 
00007FF7CE1509E7  ?? ?? 
00007FF7CE1509E8  ?? ?? 
00007FF7CE1509E9  ?? ?? 
00007FF7CE1509EA  ?? ?? 
00007FF7CE1509EB  ?? ?? 
00007FF7CE1509EC  ?? ?? 
00007FF7CE1509ED  ?? ?? 
00007FF7CE1509EE  ?? ?? 
00007FF7CE1509EF  ?? ?? 
00007FF7CE1509F0  ?? ?? 
00007FF7CE1509F1  ?? ?? 
00007FF7CE1509F2  ?? ?? 
00007FF7CE1509F3  ?? ?? 
00007FF7CE1509F4  ?? ?? 
00007FF7CE1509F5  ?? ?? 
00007FF7CE1509F6  ?? ?? 
00007FF7CE1509F7  ?? ?? 
00007FF7CE1509F8  ?? ?? 
00007FF7CE1509F9  ?? ?? 
00007FF7CE1509FA  ?? ?? 
00007FF7CE1509FB  ?? ?? 
00007FF7CE1509FC  ?? ?? 
00007FF7CE1509FD  ?? ?? 
00007FF7CE1509FE  ?? ?? 
00007FF7CE1509FF  ?? ?? 
00007FF7CE150A00  ?? ?? 
00007FF7CE150A01  ?? ?? 
00007FF7CE150A02  ?? ?? 
00007FF7CE150A03  ?? ?? 
00007FF7CE150A04  ?? ?? 
00007FF7CE150A05  ?? ?? 
00007FF7CE150A06  ?? ?? 
00007FF7CE150A07  ?? ?? 
00007FF7CE150A08  ?? ?? 
                dist -= base_dist[_code];
00007FF7CE150A09  add         byte ptr [rcx-2C74FFFCh],cl  
                send_bits(s, dist, extra);   /* send the extra distance bits */
00007FF7CE150A0F  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE150A15  sub         edx,r9d  
00007FF7CE150A18  cmp         ecx,edx  
00007FF7CE150A1A  jle         compress_block+366h (07FF7CE150A76h)  
00007FF7CE150A1C  mov         r8d,dword ptr [rax+28h]  
00007FF7CE150A20  movzx       edx,r10w  
00007FF7CE150A24  shl         dx,cl  
00007FF7CE150A27  or          word ptr [rax+1710h],dx  
00007FF7CE150A2E  movzx       ecx,byte ptr [rax+1710h]  
00007FF7CE150A35  mov         rdx,qword ptr [rax+10h]  
00007FF7CE150A39  mov         byte ptr [r8+rdx],cl  
00007FF7CE150A3D  inc         dword ptr [rax+28h]  
00007FF7CE150A40  movzx       ecx,byte ptr [rax+1711h]  
00007FF7CE150A47  mov         r8d,dword ptr [rax+28h]  
00007FF7CE150A4B  mov         rdx,qword ptr [rax+10h]  
00007FF7CE150A4F  mov         byte ptr [r8+rdx],cl  
00007FF7CE150A53  mov         ecx,ebx  
00007FF7CE150A55  sub         cl,byte ptr [rax+1714h]  
00007FF7CE150A5B  inc         dword ptr [rax+28h]  
00007FF7CE150A5E  shr         r10w,cl  
00007FF7CE150A62  lea         ecx,[r9-10h]  
00007FF7CE150A66  add         dword ptr [rax+1714h],ecx  
00007FF7CE150A6C  mov         word ptr [rax+1710h],r10w  
00007FF7CE150A74  jmp         compress_block+37Bh (07FF7CE150A8Bh)  
00007FF7CE150A76  shl         r10w,cl  
00007FF7CE150A7A  or          word ptr [rax+1710h],r10w  
00007FF7CE150A82  add         ecx,r9d  
00007FF7CE150A85  mov         dword ptr [rax+1714h],ecx  
            }
        } /* literal or match pair ? */
 
        /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */
        Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx,
               "pendingBuf overflow");
 
    } while (lx < s->last_lit);
00007FF7CE150A8B  cmp         ebp,dword ptr [rax+16F4h]  
00007FF7CE150A91  jb          compress_block+41h (07FF7CE150751h)  
00007FF7CE150A97  mov         r12,qword ptr [rsp+38h]  
00007FF7CE150A9C  mov         rdi,qword ptr [rsp+30h]  
00007FF7CE150AA1  mov         rsi,qword ptr [rsp+28h]  
 
    send_code(s, END_BLOCK, ltree);
00007FF7CE150AA6  movzx       r11d,word ptr [r14+402h]  
00007FF7CE150AAE  mov         edx,ebx  
00007FF7CE150AB0  mov         ecx,dword ptr [rax+1714h]  
00007FF7CE150AB6  sub         edx,r11d  
 
    send_code(s, END_BLOCK, ltree);
00007FF7CE150AB9  mov         r15,qword ptr [rsp]  
00007FF7CE150ABD  mov         rbp,qword ptr [rsp+20h]  
00007FF7CE150AC2  cmp         ecx,edx  
00007FF7CE150AC4  jle         compress_block+41Fh (07FF7CE150B2Fh)  
00007FF7CE150AC6  movzx       r10d,word ptr [r14+400h]  
00007FF7CE150ACE  mov         r9d,dword ptr [rax+28h]  
00007FF7CE150AD2  movzx       edx,r10w  
00007FF7CE150AD6  mov         r8,qword ptr [rax+10h]  
00007FF7CE150ADA  shl         dx,cl  
00007FF7CE150ADD  or          word ptr [rax+1710h],dx  
00007FF7CE150AE4  movzx       edx,byte ptr [rax+1710h]  
00007FF7CE150AEB  mov         byte ptr [r9+r8],dl  
00007FF7CE150AEF  inc         dword ptr [rax+28h]  
00007FF7CE150AF2  mov         r9d,dword ptr [rax+28h]  
00007FF7CE150AF6  movzx       edx,byte ptr [rax+1711h]  
00007FF7CE150AFD  mov         r8,qword ptr [rax+10h]  
00007FF7CE150B01  mov         byte ptr [r9+r8],dl  
00007FF7CE150B05  sub         bl,byte ptr [rax+1714h]  
00007FF7CE150B0B  inc         dword ptr [rax+28h]  
00007FF7CE150B0E  movzx       ecx,bl  
00007FF7CE150B11  shr         r10w,cl  
00007FF7CE150B15  lea         ecx,[r11-10h]  
00007FF7CE150B19  add         dword ptr [rax+1714h],ecx  
00007FF7CE150B1F  mov         word ptr [rax+1710h],r10w  
}
00007FF7CE150B27  add         rsp,8  
00007FF7CE150B2B  pop         r14  
00007FF7CE150B2D  pop         rbx  
00007FF7CE150B2E  ret  
 
    send_code(s, END_BLOCK, ltree);
00007FF7CE150B2F  movzx       edx,word ptr [r14+400h]  
00007FF7CE150B37  shl         dx,cl  
00007FF7CE150B3A  or          word ptr [rax+1710h],dx  
00007FF7CE150B41  add         ecx,r11d  
00007FF7CE150B44  mov         dword ptr [rax+1714h],ecx  
}
00007FF7CE150B4A  add         rsp,8  
00007FF7CE150B4E  pop         r14  
00007FF7CE150B50  pop         rbx  
00007FF7CE150B51  ret  
00007FF7CE150B52  int         3  
00007FF7CE150B53  int         3  
00007FF7CE150B54  int         3  
00007FF7CE150B55  int         3  
00007FF7CE150B56  int         3  
00007FF7CE150B57  int         3  
00007FF7CE150B58  int         3  
00007FF7CE150B59  int         3  
00007FF7CE150B5A  int         3  
00007FF7CE150B5B  int         3  
00007FF7CE150B5C  int         3  
00007FF7CE150B5D  int         3  
00007FF7CE150B5E  int         3  
00007FF7CE150B5F  int         3  
 
/* ===========================================================================
 * Check if the data type is TEXT or BINARY, using the following algorithm:
 * - TEXT if the two conditions below are satisfied:
 *    a) There are no non-portable control characters belonging to the
 *       "black list" (0..6, 14..25, 28..31).
 *    b) There is at least one printable character belonging to the
 *       "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255).
 * - BINARY otherwise.
 * - The following partially-portable control characters form a
 *   "gray list" that is ignored in this detection algorithm:
 *   (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}).
 * IN assertion: the fields Freq of dyn_ltree are set.
 */
local int detect_data_type(s)
    deflate_state *s;
{
00007FF7CE150B60  mov         r9,rcx  
    /* black_mask is the bit mask of black-listed bytes
     * set bits 0..6, 14..25, and 28..31
     * 0xf3ffc07f = binary 11110011111111111100000001111111
     */
    unsigned long black_mask = 0xf3ffc07fUL;
00007FF7CE150B63  lea         rax,[rcx+0BCh]  
    int n;
 
    /* Check for non-textual ("black-listed") bytes. */
    for (n = 0; n <= 31; n++, black_mask >>= 1)
00007FF7CE150B6A  xor         edx,edx  
00007FF7CE150B6C  mov         r8d,0F3FFC07Fh  
        if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0))
00007FF7CE150B72  test        r8b,1  
00007FF7CE150B76  je          detect_data_type+1Eh (07FF7CE150B7Eh)  
00007FF7CE150B78  cmp         word ptr [rax],0  
00007FF7CE150B7C  jne         detect_data_type+6Eh (07FF7CE150BCEh)  
    int n;
 
    /* Check for non-textual ("black-listed") bytes. */
    for (n = 0; n <= 31; n++, black_mask >>= 1)
00007FF7CE150B7E  inc         rdx  
00007FF7CE150B81  shr         r8d,1  
00007FF7CE150B84  add         rax,4  
00007FF7CE150B88  cmp         rdx,1Fh  
00007FF7CE150B8C  jle         detect_data_type+12h (07FF7CE150B72h)  
            return Z_BINARY;
 
    /* Check for textual ("white-listed") bytes. */
    if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
            || s->dyn_ltree[13].Freq != 0)
00007FF7CE150B8E  cmp         word ptr [rcx+0E0h],0  
00007FF7CE150B96  jne         detect_data_type+71h (07FF7CE150BD1h)  
00007FF7CE150B98  cmp         word ptr [rcx+0E4h],0  
00007FF7CE150BA0  jne         detect_data_type+71h (07FF7CE150BD1h)  
00007FF7CE150BA2  cmp         word ptr [rcx+0F0h],0  
00007FF7CE150BAA  jne         detect_data_type+71h (07FF7CE150BD1h)  
    for (n = 32; n < LITERALS; n++)
00007FF7CE150BAC  mov         ecx,20h  
00007FF7CE150BB1  lea         rax,[r9+13Ch]  
        if (s->dyn_ltree[n].Freq != 0)
00007FF7CE150BB8  cmp         word ptr [rax],0  
00007FF7CE150BBC  jne         detect_data_type+71h (07FF7CE150BD1h)  
    for (n = 32; n < LITERALS; n++)
00007FF7CE150BBE  inc         rcx  
00007FF7CE150BC1  add         rax,4  
00007FF7CE150BC5  ?? ?? 
00007FF7CE150BC6  ?? ?? 
00007FF7CE150BC7  ?? ?? 
00007FF7CE150BC8  ?? ?? 
00007FF7CE150BC9  ?? ?? 
00007FF7CE150BCA  ?? ?? 
00007FF7CE150BCB  ?? ?? 
00007FF7CE150BCC  ?? ?? 
00007FF7CE150BCD  ?? ?? 
00007FF7CE150BCE  ?? ?? 
00007FF7CE150BCF  ?? ?? 
00007FF7CE150BD0  ?? ?? 
00007FF7CE150BD1  ?? ?? 
00007FF7CE150BD2  ?? ?? 
00007FF7CE150BD3  ?? ?? 
00007FF7CE150BD4  ?? ?? 
00007FF7CE150BD5  ?? ?? 
00007FF7CE150BD6  ?? ?? 
00007FF7CE150BD7  ?? ?? 
00007FF7CE150BD8  ?? ?? 
00007FF7CE150BD9  ?? ?? 
00007FF7CE150BDA  ?? ?? 
00007FF7CE150BDB  ?? ?? 
00007FF7CE150BDC  ?? ?? 
00007FF7CE150BDD  ?? ?? 
00007FF7CE150BDE  ?? ?? 
00007FF7CE150BDF  ?? ?? 
00007FF7CE150BE0  ?? ?? 
00007FF7CE150BE1  ?? ?? 
00007FF7CE150BE2  ?? ?? 
00007FF7CE150BE3  ?? ?? 
00007FF7CE150BE4  ?? ?? 
00007FF7CE150BE5  ?? ?? 
00007FF7CE150BE6  ?? ?? 
00007FF7CE150BE7  ?? ?? 
00007FF7CE150BE8  ?? ?? 
00007FF7CE150BE9  ?? ?? 
    if (s->bi_valid == 16) {
00007FF7CE150BEA  clc  
00007FF7CE150BEB  ?? ?? 
00007FF7CE150BEC  ?? ?? 
00007FF7CE150BED  ?? ?? 
00007FF7CE150BEE  ?? ?? 
00007FF7CE150BEF  ?? ?? 
00007FF7CE150BF0  ?? ?? 
00007FF7CE150BF1  ?? ?? 
00007FF7CE150BF2  ?? ?? 
00007FF7CE150BF3  ?? ?? 
00007FF7CE150BF4  ?? ?? 
00007FF7CE150BF5  ?? ?? 
00007FF7CE150BF6  ?? ?? 
00007FF7CE150BF7  ?? ?? 
00007FF7CE150BF8  ?? ?? 
00007FF7CE150BF9  ?? ?? 
00007FF7CE150BFA  ?? ?? 
00007FF7CE150BFB  ?? ?? 
00007FF7CE150BFC  ?? ?? 
00007FF7CE150BFD  ?? ?? 
00007FF7CE150BFE  ?? ?? 
00007FF7CE150BFF  ?? ?? 
00007FF7CE150C00  ?? ?? 
00007FF7CE150C01  ?? ?? 
00007FF7CE150C02  ?? ?? 
00007FF7CE150C03  ?? ?? 
00007FF7CE150C04  ?? ?? 
00007FF7CE150C05  ?? ?? 
00007FF7CE150C06  ?? ?? 
00007FF7CE150C07  ?? ?? 
00007FF7CE150C08  ?? ?? 
00007FF7CE150C09  ?? ?? 
00007FF7CE150C0A  ?? ?? 
00007FF7CE150C0B  ?? ?? 
00007FF7CE150C0C  ?? ?? 
00007FF7CE150C0D  ?? ?? 
        put_short(s, s->bi_buf);
00007FF7CE150C0E  add         byte ptr [rax-75h],cl  
00007FF7CE150C11  adc         byte ptr [r8-0BEF5FCh],cl  
00007FF7CE150C18  sub         byte ptr [r11],sil  
00007FF7CE150C1B  ?? ?? 
00007FF7CE150C1C  ?? ?? 
00007FF7CE150C1D  ?? ?? 
00007FF7CE150C1E  ?? ?? 
00007FF7CE150C1F  ?? ?? 
00007FF7CE150C20  ?? ?? 
00007FF7CE150C21  ?? ?? 
00007FF7CE150C22  ?? ?? 
00007FF7CE150C23  ?? ?? 
00007FF7CE150C24  ?? ?? 
00007FF7CE150C25  ?? ?? 
00007FF7CE150C26  ?? ?? 
00007FF7CE150C27  ?? ?? 
00007FF7CE150C28  ?? ?? 
00007FF7CE150C29  ?? ?? 
00007FF7CE150C2A  ?? ?? 
00007FF7CE150C2B  ?? ?? 
00007FF7CE150C2C  ?? ?? 
00007FF7CE150C2D  ?? ?? 
00007FF7CE150C2E  ?? ?? 
00007FF7CE150C2F  ?? ?? 
00007FF7CE150C30  ?? ?? 
00007FF7CE150C31  ?? ?? 
00007FF7CE150C32  ?? ?? 
00007FF7CE150C33  ?? ?? 
00007FF7CE150C34  ?? ?? 
00007FF7CE150C35  ?? ?? 
00007FF7CE150C36  ?? ?? 
00007FF7CE150C37  ?? ?? 
00007FF7CE150C38  ?? ?? 
00007FF7CE150C39  ?? ?? 
00007FF7CE150C3A  ?? ?? 
00007FF7CE150C3B  ?? ?? 
00007FF7CE150C3C  ?? ?? 
00007FF7CE150C3D  ?? ?? 
00007FF7CE150C3E  ?? ?? 
00007FF7CE150C3F  ?? ?? 
00007FF7CE150C40  ?? ?? 
00007FF7CE150C41  ?? ?? 
00007FF7CE150C42  ?? ?? 
00007FF7CE150C43  ?? ?? 
00007FF7CE150C44  ?? ?? 
00007FF7CE150C45  ?? ?? 
00007FF7CE150C46  ?? ?? 
00007FF7CE150C47  ?? ?? 
00007FF7CE150C48  ?? ?? 
00007FF7CE150C49  ?? ?? 
00007FF7CE150C4A  ?? ?? 
00007FF7CE150C4B  ?? ?? 
00007FF7CE150C4C  ?? ?? 
00007FF7CE150C4D  ?? ?? 
00007FF7CE150C4E  ?? ?? 
00007FF7CE150C4F  ?? ?? 
00007FF7CE150C50  ?? ?? 
00007FF7CE150C51  ?? ?? 
00007FF7CE150C52  ?? ?? 
00007FF7CE150C53  ?? ?? 
00007FF7CE150C54  ?? ?? 
00007FF7CE150C55  ?? ?? 
00007FF7CE150C56  ?? ?? 
00007FF7CE150C57  ?? ?? 
00007FF7CE150C58  ?? ?? 
00007FF7CE150C59  ?? ?? 
00007FF7CE150C5A  ?? ?? 
00007FF7CE150C5B  ?? ?? 
00007FF7CE150C5C  ?? ?? 
00007FF7CE150C5D  ?? ?? 
00007FF7CE150C5E  ?? ?? 
00007FF7CE150C5F  ?? ?? 
00007FF7CE150C60  ?? ?? 
00007FF7CE150C61  ?? ?? 
00007FF7CE150C62  ?? ?? 
00007FF7CE150C63  ?? ?? 
 
/* ===========================================================================
 * Flush the bit buffer and align the output on a byte boundary
 */
local void bi_windup(s)
    deflate_state *s;
{
    if (s->bi_valid > 8) {
        put_short(s, s->bi_buf);
    } else if (s->bi_valid > 0) {
        put_byte(s, (Byte)s->bi_buf);
    }
    s->bi_buf = 0;
    s->bi_valid = 0;
#ifdef DEBUG
    s->bits_sent = (s->bits_sent+7) & ~7;
#endif
}
 
/* ===========================================================================
 * Copy a stored block, storing first the length and its
 * one's complement if requested.
 */
local void copy_block(s, buf, len, header)
    deflate_state *s;
    charf    *buf;    /* the input data */
    unsigned len;     /* its length */
    int      header;  /* true if block header must be written */
{
00007FF7CE150C64  or          byte ptr [rbx+171481h],cl  
    bi_windup(s);        /* align on byte boundary */
00007FF7CE150C6A  add         byte ptr [rbp-75h],al  
 
/* ===========================================================================
 * Flush the bit buffer and align the output on a byte boundary
 */
local void bi_windup(s)
    deflate_state *s;
{
    if (s->bi_valid > 8) {
        put_short(s, s->bi_buf);
    } else if (s->bi_valid > 0) {
        put_byte(s, (Byte)s->bi_buf);
    }
    s->bi_buf = 0;
    s->bi_valid = 0;
#ifdef DEBUG
    s->bits_sent = (s->bits_sent+7) & ~7;
#endif
}
 
/* ===========================================================================
 * Copy a stored block, storing first the length and its
 * one's complement if requested.
 */
local void copy_block(s, buf, len, header)
    deflate_state *s;
    charf    *buf;    /* the input data */
    unsigned len;     /* its length */
    int      header;  /* true if block header must be written */
{
00007FF7CE150C6D  fmul        dword ptr [rax-75h]  
 
/* ===========================================================================
 * Flush the bit buffer and align the output on a byte boundary
 */
local void bi_windup(s)
    deflate_state *s;
{
    if (s->bi_valid > 8) {
        put_short(s, s->bi_buf);
    } else if (s->bi_valid > 0) {
        put_byte(s, (Byte)s->bi_buf);
    }
    s->bi_buf = 0;
    s->bi_valid = 0;
#ifdef DEBUG
    s->bits_sent = (s->bits_sent+7) & ~7;
#endif
}
 
/* ===========================================================================
 * Copy a stored block, storing first the length and its
 * one's complement if requested.
 */
local void copy_block(s, buf, len, header)
    deflate_state *s;
    charf    *buf;    /* the input data */
    unsigned len;     /* its length */
    int      header;  /* true if block header must be written */
{
00007FF7CE150C70  fiadd       dword ptr [rbx+1F7E08F8h]  
    bi_windup(s);        /* align on byte boundary */
00007FF7CE150C76  mov         r10d,dword ptr [rcx+28h]  
00007FF7CE150C7A  movzx       eax,byte ptr [rcx+1710h]  
00007FF7CE150C81  mov         r9,qword ptr [rcx+10h]  
00007FF7CE150C85  mov         byte ptr [r10+r9],al  
00007FF7CE150C89  inc         dword ptr [rcx+28h]  
00007FF7CE150C8C  movzx       eax,byte ptr [rcx+1711h]  
00007FF7CE150C93  jmp         copy_block+40h (07FF7CE150CA0h)  
00007FF7CE150C95  test        eax,eax  
00007FF7CE150C97  jle         copy_block+4Fh (07FF7CE150CAFh)  
00007FF7CE150C99  movzx       eax,byte ptr [rcx+1710h]  
00007FF7CE150CA0  mov         r8d,dword ptr [rcx+28h]  
00007FF7CE150CA4  mov         rdx,qword ptr [rcx+10h]  
00007FF7CE150CA8  mov         byte ptr [r8+rdx],al  
00007FF7CE150CAC  inc         dword ptr [rcx+28h]  
 
    if (header) {
        put_short(s, (ush)len);
00007FF7CE150CAF  mov         edx,dword ptr [rcx+28h]  
    bi_windup(s);        /* align on byte boundary */
00007FF7CE150CB2  xor         eax,eax  
00007FF7CE150CB4  mov         word ptr [rcx+1710h],ax  
00007FF7CE150CBB  mov         dword ptr [rcx+1714h],eax  
 
    if (header) {
        put_short(s, (ush)len);
00007FF7CE150CC1  mov         rax,qword ptr [rcx+10h]  
00007FF7CE150CC5  mov         byte ptr [rdx+rax],r11b  
00007FF7CE150CC9  movzx       edx,r11w  
00007FF7CE150CCD  inc         dword ptr [rcx+28h]  
00007FF7CE150CD0  mov         r8d,dword ptr [rcx+28h]  
00007FF7CE150CD4  mov         rax,qword ptr [rcx+10h]  
00007FF7CE150CD8  shr         dx,8  
00007FF7CE150CDC  mov         byte ptr [r8+rax],dl  
        put_short(s, (ush)~len);
00007FF7CE150CE0  movzx       edx,r11b  
00007FF7CE150CE4  inc         dword ptr [rcx+28h]  
00007FF7CE150CE7  not         dl  
00007FF7CE150CE9  mov         r8d,dword ptr [rcx+28h]  
00007FF7CE150CED  mov         rax,qword ptr [rcx+10h]  
00007FF7CE150CF1  mov         byte ptr [r8+rax],dl  
00007FF7CE150CF5  movzx       edx,r11w  
00007FF7CE150CF9  inc         dword ptr [rcx+28h]  
00007FF7CE150CFC  not         dx  
00007FF7CE150CFF  mov         r8d,dword ptr [rcx+28h]  
00007FF7CE150D03  mov         rax,qword ptr [rcx+10h]  
        put_short(s, (ush)~len);
00007FF7CE150D07  shr         dx,8  
00007FF7CE150D0B  mov         byte ptr [r8+rax],dl  
00007FF7CE150D0F  inc         dword ptr [rcx+28h]  
00007FF7CE150D12  mov         r9d,dword ptr [rcx+28h]  
#ifdef DEBUG
        s->bits_sent += 2*16;
#endif
    }
#ifdef DEBUG
    s->bits_sent += (ulg)len<<3;
#endif
    while (len--) {
00007FF7CE150D16  test        r11d,r11d  
00007FF7CE150D19  je          copy_block+0DFh (07FF7CE150D3Fh)  
00007FF7CE150D1B  nop         dword ptr [rax+rax]  
        put_byte(s, *buf++);
00007FF7CE150D20  movzx       eax,byte ptr [rbx]  
00007FF7CE150D23  lea         rbx,[rbx+1]  
00007FF7CE150D27  mov         rdx,qword ptr [rcx+10h]  
00007FF7CE150D2B  mov         r8d,r9d  
00007FF7CE150D2E  mov         byte ptr [r8+rdx],al  
00007FF7CE150D32  inc         dword ptr [rcx+28h]  
00007FF7CE150D35  mov         r9d,dword ptr [rcx+28h]  
00007FF7CE150D39  add         r11d,0FFFFFFFFh  
00007FF7CE150D3D  jne         copy_block+0C0h (07FF7CE150D20h)  
    }
}
00007FF7CE150D3F  mov         rbx,qword ptr [rsp+8]  
00007FF7CE150D44  ret  
--- No source file -------------------------------------------------------------
00007FF7CE150D45  int         3  
00007FF7CE150D46  int         3  
00007FF7CE150D47  int         3  
00007FF7CE150D48  int         3  
00007FF7CE150D49  int         3  
00007FF7CE150D4A  int         3  
00007FF7CE150D4B  int         3  
00007FF7CE150D4C  int         3  
00007FF7CE150D4D  int         3  
00007FF7CE150D4E  int         3  
00007FF7CE150D4F  int         3  
--- d:\osts\perso\dx12\projet\src\libs\zlib\zutil.c ----------------------------
    if (opaque) items += size - size; /* make compiler happy */
    return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
00007FF7CE150D50  mov         eax,r8d  
00007FF7CE150D53  mul         eax,edx  
00007FF7CE150D55  mov         ecx,eax  
00007FF7CE150D57  mov         rax,0FFFFFFFFFFFFFFFFh  
00007FF7CE150D5E  cmovo       rcx,rax  
00007FF7CE150D62  jmp         qword ptr [__imp_malloc (07FF7CE1733D8h)]  
--- No source file -------------------------------------------------------------
00007FF7CE150D69  int         3  
00007FF7CE150D6A  int         3  
00007FF7CE150D6B  int         3  
--- No source file -------------------------------------------------------------
00007FF7CE150D6C  int         3  
00007FF7CE150D6D  int         3  
00007FF7CE150D6E  int         3  
00007FF7CE150D6F  int         3  
--- d:\osts\perso\dx12\projet\src\libs\zlib\zutil.c ----------------------------
    free(ptr);
00007FF7CE150D70  mov         rcx,rdx  
00007FF7CE150D73  jmp         qword ptr [__imp_free (07FF7CE1733E0h)]  
--- No source file -------------------------------------------------------------
00007FF7CE150D7A  int         3  
00007FF7CE150D7B  int         3  
00007FF7CE150D7C  int         3  
00007FF7CE150D7D  int         3  
00007FF7CE150D7E  int         3  
00007FF7CE150D7F  int         3  
00007FF7CE150D80  push        rbx  
00007FF7CE150D82  sub         rsp,30h  
00007FF7CE150D86  mov         qword ptr [rsp+20h],0FFFFFFFFFFFFFFFEh  
00007FF7CE150D8F  mov         rbx,rcx  
00007FF7CE150D92  add         rcx,68h  
00007FF7CE150D96  lea         r9,[InputManager::~InputManager (07FF7CE135130h)]  
00007FF7CE150D9D  mov         edx,18h  
00007FF7CE150DA2  lea         r8d,[rdx-16h]  
00007FF7CE150DA6  call        `eh vector destructor iterator' (07FF7CE16F8D4h)  
00007FF7CE150DAB  nop  
00007FF7CE150DAC  lea         rcx,[rbx+50h]  
00007FF7CE150DB0  add         rsp,30h  
00007FF7CE150DB4  pop         rbx  
00007FF7CE150DB5  jmp         std::vector<WE2016::DoorMove,std::allocator<WE2016::DoorMove> >::_Tidy (07FF7CE151A90h)  
00007FF7CE150DBA  int         3  
00007FF7CE150DBB  int         3  
00007FF7CE150DBC  int         3  
00007FF7CE150DBD  int         3  
00007FF7CE150DBE  int         3  
00007FF7CE150DBF  int         3  
--- d:\osts\perso\dx12\projet\src\main.cpp -------------------------------------
#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN
 
#define GLX_GLXEXT_LEGACY //Must be declared so that our local glxext.h is picked up, rather than the system one
 
#ifdef _WIN32
#include <windows.h>
#include "Renderer/PC/Windows/glwindow.h"
#else
#include "Renderer/PC/Linux/glxwindow.h"
#endif
#include "Renderer/Shader.h"
 
#include "WE2016.h"
#include "Renderer/Renderer.h"
 
#ifdef _WIN32
int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR cmdLine,
                   int cmdShow)
{
00007FF7CE150DC0  mov         qword ptr [rsp+10h],rbx  
00007FF7CE150DC5  push        rbp  
00007FF7CE150DC6  lea         rbp,[rsp-7ED50h]  
00007FF7CE150DCE  mov         eax,7EE50h  
00007FF7CE150DD3  call        __chkstk (07FF7CE170E80h)  
00007FF7CE150DD8  sub         rsp,rax  
#define WIN32_LEAN_AND_MEAN
#define WIN32_EXTRA_LEAN
 
#define GLX_GLXEXT_LEGACY //Must be declared so that our local glxext.h is picked up, rather than the system one
 
#ifdef _WIN32
#include <windows.h>
#include "Renderer/PC/Windows/glwindow.h"
#else
#include "Renderer/PC/Linux/glxwindow.h"
#endif
#include "Renderer/Shader.h"
 
#include "WE2016.h"
#include "Renderer/Renderer.h"
 
#ifdef _WIN32
int WINAPI WinMain(HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPSTR cmdLine,
                   int cmdShow)
{
00007FF7CE150DDB  mov         rax,qword ptr [__security_cookie (07FF7CE182008h)]  
00007FF7CE150DE2  xor         rax,rsp  
00007FF7CE150DE5  mov         qword ptr [rbp+7ED20h],rax  
00007FF7CE150DEC  mov         rbx,rcx  
00007FF7CE150DEF  xor         edx,edx  
00007FF7CE150DF1  lea         rcx,[programWindow]  
00007FF7CE150DF6  mov         r8d,98h  
00007FF7CE150DFC  call        memset (07FF7CE170CB6h)  
00007FF7CE150E01  xor         edx,edx  
#else
int main(int argc, char** argv)
{
#endif
    //Set our window settings
    const int windowWidth = 640;
    const int windowHeight = 360;
    const int windowBPP = 32;
    const int windowFullscreen = false;
 
#ifdef _WIN32
    //This is our window
    GLWindow programWindow(hInstance);
00007FF7CE150E03  mov         byte ptr [programWindow],1  
00007FF7CE150E08  mov         r8d,7ECF8h  
00007FF7CE150E0E  mov         qword ptr [rsp+60h],0  
00007FF7CE150E17  lea         rcx,[rbp+20h]  
00007FF7CE150E1B  mov         byte ptr [rsp+68h],0  
00007FF7CE150E20  mov         qword ptr [rbp-70h],rbx  
00007FF7CE150E24  call        memset (07FF7CE170CB6h)  
#else
    SimpleGLXWindow programWindow;
#endif
00007FF7CE1521F9  test        rdx,rdx

EDIT: j'ai du couper le code pour rester dans la limite de caractères du forum (100 000, le code original en faisait plus de 322 000 :/ ) Donc il faut me croire sur parole sur l'absence des goto :p

**Luke spywoker** · 21/09/2016, 18h35

Bonjours, LittleWhite

Tu a fait t'es expérience et j'ai fait les miennes concernant le branchement a chaud d'un joystick...

Je dois admettre que:

J'utilise un Input_Handler que je n'ai pas écrit moi-même et il ne permet pas de branché de(s) joystick avec la SDL2 initialiser (comme expliquer)...

C'est peut-être possible autrement autrement, SDL_JoystickUpdate() ou autre, je ne sais pas.

Et un âne comme moi ne campe pas sur ces positions non plus si il a eu tort.

Alors, je ne peux que conclure que vous faites des codes parfaits (j'aimerai aussi avoir ce don (ou cette intelligence, je ne sais pas comment l'appeler)).

Et bien NON je n'écrit pas des programmes parfaits seulement le faîte d'être sûr de soi et de son code demande beaucoup de travail et de relecture et reformatage de son code.

Et même si je m'en sort avec une ou 2 memory leaks au bout du compte qui ne sont pas grave (pas en boucle, etc...) je préfère me dire que je sais ce que je fait, que faire appel a des méthode fainéant comme se protéger contre moi-même.

Je pense au contraire que ce sont ce genre de pratique qui génère des programmes parfaits puisque tout est automatisé (comme la destruction de pointeurs)...

Mais comme la puissance de nos ordinateurs grandis, et bien les programmeurs se dise que tout leurs est permis permis et
des notion de base de bonne écriture et de travail qu'il fallait avant quand je n'était pas encore nées informatiquement sont remplacer par des technique de fainéants.

Alors pour terminer sur ceçi une question:

Combien de code machine en plus l'on génère en utilisant des smart pointer au lieu de raw-pointer ?

Mais l'on s'en fous car de nos jours: la ou il faut de la performance comme les jeux vidéos sont majoritairement écrit en C++ au lieu du C ou de l'assembleur.

Pour finir essaie de tracer des programme dans divers langages qui ne font que retourner 0.

Par exemple en python

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
from sys import exit
exit(0)

Cela donne des tonnes de code machine par rapport a la même chose écrit en C...

a médité.

**LittleWhite** · 21/09/2016, 21h08

Pour finir essaie de tracer des programme dans divers langages qui ne font que retourner 0.

Cela donne des tonnes de code machine par rapport a la même chose écrit en C...

a médité.

Oui, mais combien de temps avez vous pris à écrire telle programme (avec tel langage) et combien de temps l'auriez vous pris à l'écrire en ASM.
C'est d'ailleurs pour ça (et pour d'autres choses) que l'on ne fait plus aucun jeu en ASM (et cela aussi sur console portable). Ça prendrai un temps monstrueusement fou.
De même, avec Python, je peux écrire des scripts sans avoir besoin de coder/recoder des centaines de fonctions pour gérer les chaines de caractères, l'ouverture d'une fenêtre ou tout ça. En plus, il faut être bon pour faire de l'assembleur portable et optimisé (je parle utilisant des instructions avancées du style SSE (1, 2, 3, 4), AVX et ainsi de suite). Je préfère laisser cela aux développeurs de bibliothèques qui ont le temps et les connaissances pour le faire, puis utiliser leur travail pour faire mon jeu aisément, tout en gardant les optimisations.

Pour les pointeurs intelligents, je pense que cela ne sera pas énorme comme code en plus. Avec un compilateur faisant bien son job, cela revient à un coup quasi nul et il gère les ressources. Je peux aussi le faire en C, mais déjà que je râle contre le C++ après avoir fait du Python, je râle sur le C, après avoir fait du C++. Il y a une aisance, une simplicité et surtout une efficacité.

Je ne suis pas pour les programmes qui prennent 20 Go juste parce qu'ils le peuvent. Mais il reste, que même s'il y a une surcouche à utiliser le C, ou le C++, l'aisance apportée par rapport à l'ASM n'est pas à éviter. C'est du temps de gagner et l'assembleur, cela reste dur à maîtriser. Pareil pour le C++, il y a des mécanismes qui font gagner du temps, rien ne vous oblige à les utiliser, mais ne pas les utiliser, c'est un peu vouloir se compliquer la vie.

Je n'arrive pas a quitter depuis une SDL_ShowSimpleMessageBox. [SDL 2.0]

SDL

Discussions similaires

Partager

Partager