Add files using upload-large-folder tool

cc-multilingual-main/cc_net/build/lib/cc_net/data/cutoff.csv

@@ -0,0 +1,101 @@
+,de,it,fr,nl,pl,pt,es,no,da,id,lt,fi,en,hu,ro,ko,ar,bn,fa,ru,uk,ml,my,lv,is,ca,ne,et,hy,ja,hr,hi,az,el,cs,bg,he,zh,ka,km,gu,mk,kn,mr,af,mn,kk,be
+0,0,0,0,10,0,0,0,0,0,0,0,10,0,0,0,20,0,0,0,0,0,0,10,10,10,0,10,0,0,0,0,0,0,0,0,0,0,10,0,10,10,10,10,10,10,0,0,10
+1,150,100,70,170,50,70,70,170,160,210,70,400,160,30,70,20,100,70,110,70,40,480,550,430,410,80,330,470,210,400,290,190,130,210,270,120,400,600,230,410,510,190,730,460,130,240,50,170
+2,170,110,90,200,70,80,90,210,190,260,90,490,180,30,80,30,180,80,150,90,50,740,840,570,490,90,420,630,300,540,360,220,200,250,350,180,520,750,360,460,580,250,1020,630,190,300,110,250
+3,190,120,90,230,70,90,90,230,210,300,100,570,200,40,90,30,220,90,180,110,60,930,980,650,530,100,470,720,360,620,400,240,240,270,410,220,620,840,420,490,630,280,1170,720,220,330,150,300
+4,200,130,100,240,80,90,100,250,220,320,110,620,210,40,100,30,250,100,190,110,60,1080,1140,710,560,110,510,780,400,670,440,260,270,280,450,230,690,900,480,530,670,300,1280,790,260,360,190,340
+5,210,130,100,260,90,100,110,260,230,340,110,670,220,40,110,30,260,100,210,120,70,1210,1260,760,580,120,540,830,430,710,470,270,300,290,480,250,760,950,520,550,690,320,1370,840,290,380,210,370
+6,220,140,110,270,90,100,110,270,240,350,120,700,230,40,110,30,280,110,220,130,70,1310,1390,790,600,120,570,870,450,750,490,280,320,300,510,270,810,990,560,560,720,340,1440,880,310,400,240,390
+7,230,140,110,280,100,110,120,280,250,370,120,740,230,50,120,30,290,110,230,140,70,1400,1500,820,620,130,590,900,480,770,510,300,340,310,540,290,850,1030,580,570,740,350,1500,920,330,410,270,410
+8,230,150,110,290,100,110,120,290,260,380,130,770,240,50,120,40,310,120,240,140,80,1470,1590,840,640,130,610,930,500,800,530,310,360,320,560,300,880,1060,610,600,760,370,1550,950,350,430,280,430
+9,240,150,120,300,100,110,120,300,270,400,130,790,250,50,120,40,320,120,240,150,80,1540,1660,860,650,140,630,960,520,820,540,310,380,330,580,310,910,1090,630,610,780,380,1600,990,370,450,310,450
+10,250,160,120,310,110,120,130,310,270,410,140,810,250,50,130,40,330,130,250,150,90,1600,1740,880,660,140,650,980,530,840,550,320,390,340,600,320,940,1110,650,620,800,390,1640,1010,380,460,330,470
+11,250,160,120,310,110,120,130,310,280,420,140,830,260,50,130,60,340,130,260,150,90,1650,1810,900,680,150,660,1000,550,860,570,330,410,350,610,330,970,1140,670,640,820,400,1680,1040,390,480,350,480
+12,260,160,130,320,110,120,130,320,290,430,140,850,260,50,130,70,350,130,270,160,90,1700,1870,920,690,150,680,1020,570,880,580,340,420,350,630,340,990,1160,690,660,840,410,1720,1060,400,490,370,500
+13,270,170,130,330,120,130,140,330,290,440,150,870,270,60,140,80,360,140,270,160,90,1750,1930,930,700,150,690,1030,580,890,590,350,440,360,640,340,1010,1180,710,680,860,420,1760,1090,410,500,380,510
+14,270,170,130,340,120,130,140,340,300,450,150,890,270,60,140,110,370,140,280,170,100,1800,1990,950,710,160,700,1050,590,910,600,360,450,370,650,350,1030,1200,730,700,880,430,1790,1110,420,510,400,520
+15,280,170,140,340,120,130,140,340,300,460,150,900,280,60,140,110,380,140,290,170,100,1850,2040,960,720,160,720,1070,600,920,610,360,460,370,670,360,1050,1220,740,710,890,430,1820,1130,430,520,420,540
+16,280,180,140,350,120,130,140,350,310,470,160,920,280,60,150,120,380,150,290,170,100,1890,2080,980,730,160,730,1080,620,940,620,370,470,380,680,360,1070,1240,750,740,910,440,1850,1150,440,530,440,550
+17,290,180,140,360,130,140,150,350,320,480,160,940,280,60,150,120,390,150,300,180,110,1940,2120,990,740,170,740,1100,630,950,630,380,480,380,690,370,1090,1260,770,760,920,450,1880,1170,450,550,450,560
+18,300,180,150,360,130,140,150,360,320,490,160,950,290,60,150,160,400,150,300,180,110,1980,2170,1000,750,170,750,1110,640,970,640,390,490,390,700,380,1100,1270,780,770,940,460,1910,1190,450,560,470,570
+19,300,190,150,370,130,140,150,370,330,500,160,970,290,70,150,230,410,160,310,180,110,2030,2200,1010,760,170,760,1130,650,980,640,390,500,390,710,380,1120,1290,790,790,950,460,1940,1210,460,570,480,580
+20,310,190,150,370,130,140,150,370,330,510,170,980,300,70,160,330,420,160,310,180,110,2070,2240,1030,770,180,770,1140,660,990,650,400,510,400,720,390,1140,1310,800,810,970,470,1970,1220,470,580,490,590
+21,310,190,150,380,140,150,160,380,340,520,170,990,300,70,160,370,420,160,320,190,120,2110,2270,1040,770,180,780,1160,670,1010,660,410,520,400,740,400,1150,1320,820,830,980,480,1990,1240,480,590,510,600
+22,320,200,160,390,140,150,160,380,340,530,170,1010,300,70,160,450,430,170,330,190,120,2160,2300,1050,780,180,790,1170,670,1020,670,410,530,410,750,400,1170,1340,830,850,1000,480,2020,1260,490,600,520,610
+23,320,200,160,390,140,150,160,390,350,540,170,1020,310,70,160,600,440,170,330,190,120,2190,2340,1060,790,190,800,1180,680,1030,680,420,540,420,760,410,1180,1350,840,870,1010,490,2040,1270,490,610,530,620
+24,330,200,160,400,140,150,160,400,350,540,170,1030,310,70,170,670,450,170,340,200,130,2230,2360,1070,800,190,810,1190,690,1040,680,430,550,420,770,410,1200,1370,850,890,1020,500,2060,1290,500,620,550,630
+25,340,210,170,400,150,160,170,400,360,550,180,1050,320,80,170,740,460,170,340,200,130,2270,2390,1080,810,190,820,1210,700,1050,690,440,560,430,780,420,1210,1380,860,910,1040,500,2090,1300,510,630,560,640
+26,340,210,170,410,150,160,170,410,360,560,180,1060,320,80,170,790,460,180,350,200,130,2300,2420,1090,820,190,830,1220,710,1060,700,440,570,430,780,420,1220,1400,870,930,1050,510,2110,1320,510,640,570,640
+27,350,210,170,420,150,160,170,410,370,570,180,1070,320,80,170,840,470,180,350,200,130,2340,2450,1100,830,200,840,1230,720,1080,700,450,580,440,790,430,1240,1410,880,960,1070,510,2140,1330,520,650,580,650
+28,350,220,180,420,150,160,170,420,370,580,180,1090,330,80,180,840,480,180,360,210,140,2370,2470,1110,840,200,850,1240,730,1090,710,460,580,440,800,440,1250,1430,890,990,1080,520,2160,1350,530,660,590,660
+29,360,220,180,430,160,160,180,430,380,590,190,1100,330,80,180,890,490,190,370,210,140,2400,2500,1120,850,200,860,1250,740,1100,720,470,590,450,810,440,1270,1440,900,1010,1100,520,2180,1370,530,670,600,670
+30,370,220,180,430,160,170,180,430,380,600,190,1110,340,80,180,920,490,190,370,210,140,2430,2530,1130,850,210,860,1270,750,1110,720,480,600,450,820,450,1280,1460,910,1040,1110,530,2210,1380,540,680,610,670
+31,370,230,190,440,160,170,180,440,390,610,190,1120,340,80,180,920,500,190,380,220,140,2470,2550,1140,860,210,870,1280,750,1120,730,480,610,460,830,460,1290,1470,920,1070,1120,540,2230,1400,550,690,620,680
+32,380,230,190,450,160,170,180,440,390,620,190,1140,350,90,180,920,510,200,390,220,150,2510,2570,1150,870,210,880,1290,760,1130,740,490,620,460,840,460,1310,1490,930,1100,1140,540,2250,1410,550,700,630,690
+33,380,230,190,450,170,170,190,450,400,630,190,1150,350,90,190,940,520,200,390,220,150,2540,2590,1160,880,220,890,1300,770,1140,740,500,630,470,850,470,1320,1500,940,1120,1150,550,2270,1430,560,710,650,700
+34,390,240,200,460,170,180,190,460,410,640,200,1160,350,90,190,940,530,200,400,220,150,2570,2610,1170,890,220,900,1310,780,1150,750,510,640,470,860,470,1330,1520,960,1150,1160,550,2290,1440,570,720,660,700
+35,400,240,200,460,170,180,190,460,410,640,200,1170,360,90,190,940,530,210,410,230,150,2590,2630,1180,900,220,910,1320,790,1160,760,520,650,480,870,480,1350,1530,970,1180,1180,560,2310,1460,580,730,670,710
+36,400,240,200,470,170,180,190,470,420,660,200,1180,360,90,190,1010,540,210,410,230,160,2620,2650,1190,910,230,920,1330,800,1170,760,520,660,480,880,490,1360,1540,980,1210,1190,560,2330,1470,580,740,680,720
+37,410,250,210,480,180,190,200,480,420,670,200,1200,370,90,200,1010,550,210,420,230,160,2650,2660,1200,920,230,930,1340,810,1180,770,530,670,490,890,490,1370,1560,990,1240,1200,570,2350,1490,590,750,690,730
+38,410,250,210,480,180,190,200,480,430,680,210,1210,370,100,200,1020,560,210,430,230,160,2680,2680,1210,930,230,930,1350,820,1190,770,540,680,500,900,500,1390,1570,1000,1270,1220,580,2370,1500,600,760,700,730
+39,420,260,210,490,180,190,200,490,440,690,210,1220,380,100,200,1020,570,220,440,240,160,2710,2700,1220,930,240,940,1360,830,1200,780,550,690,500,910,510,1400,1590,1010,1300,1230,580,2390,1520,600,770,710,740
+40,430,260,220,490,190,190,210,500,440,700,210,1230,380,100,200,1020,570,220,440,240,170,2740,2720,1240,940,240,950,1370,840,1210,790,560,700,510,920,510,1410,1610,1020,1330,1250,590,2410,1540,610,780,720,750
+41,430,260,220,500,190,200,210,500,450,710,210,1240,390,100,210,1050,580,220,450,240,170,2770,2740,1250,950,240,960,1380,850,1230,790,570,710,510,930,520,1430,1620,1030,1360,1260,600,2430,1550,620,790,730,760
+42,440,270,220,510,190,200,210,510,450,720,210,1260,390,100,210,1050,590,230,460,250,170,2800,2760,1260,960,250,970,1390,860,1240,800,580,720,520,940,530,1440,1640,1040,1400,1270,600,2450,1570,630,800,740,770
+43,450,270,230,510,190,200,220,520,460,730,220,1270,400,110,210,1050,600,230,470,250,170,2820,2770,1270,970,250,980,1410,860,1250,800,590,730,530,940,530,1450,1650,1050,1430,1290,610,2470,1580,630,810,750,770
+44,450,280,230,520,200,210,220,530,470,740,220,1280,400,110,220,1050,610,230,480,250,180,2840,2790,1280,980,250,980,1420,870,1260,810,600,740,530,950,540,1470,1670,1070,1470,1300,610,2490,1600,640,820,750,780
+45,460,280,240,530,200,210,220,530,480,750,220,1290,410,110,220,1180,620,240,490,260,180,2870,2800,1290,990,260,990,1430,890,1270,820,610,760,540,970,550,1480,1690,1080,1510,1320,620,2510,1610,650,830,770,790
+46,470,280,240,530,200,210,230,540,480,760,220,1310,420,110,220,1180,630,240,500,260,180,2900,2820,1300,1000,260,1000,1440,900,1280,820,620,770,550,980,550,1500,1700,1090,1550,1330,630,2530,1630,650,840,780,790
+47,470,290,250,540,210,220,230,550,490,780,230,1320,420,110,220,1260,640,250,510,260,180,2930,2840,1310,1010,270,1010,1450,910,1290,830,630,780,550,990,560,1510,1720,1100,1580,1350,630,2540,1640,660,850,790,800
+48,480,290,250,550,210,220,230,560,500,790,230,1330,430,120,230,1410,650,250,520,270,190,2950,2850,1320,1020,270,1020,1460,920,1300,840,640,790,560,1000,570,1530,1740,1120,1620,1360,640,2570,1660,670,860,800,810
+49,490,300,260,560,210,220,240,570,500,800,230,1340,440,120,230,1430,660,250,530,270,190,2970,2870,1330,1030,270,1030,1470,930,1310,840,650,800,570,1010,580,1540,1750,1130,1650,1370,650,2580,1670,680,880,810,820
+50,500,300,260,560,220,230,240,570,510,810,230,1360,440,120,230,1540,670,260,550,270,190,3000,2880,1350,1050,280,1040,1480,940,1330,850,660,820,580,1020,590,1560,1770,1140,1690,1390,660,2600,1690,680,890,820,830
+51,500,310,270,570,220,230,250,580,520,830,240,1370,450,120,240,1560,680,260,560,280,200,3020,2900,1360,1060,280,1050,1500,950,1340,850,670,830,580,1030,600,1570,1790,1160,1730,1410,660,2620,1710,690,900,830,830
+52,510,310,270,580,220,230,250,590,530,840,240,1380,460,120,240,1610,690,270,570,280,200,3040,2910,1370,1070,290,1050,1510,970,1350,860,680,840,590,1040,600,1590,1810,1180,1780,1420,670,2640,1720,700,910,840,840
+53,520,320,280,590,230,240,250,600,540,850,240,1400,460,130,240,1700,700,270,580,280,200,3070,2930,1390,1090,290,1060,1520,980,1360,870,700,850,600,1050,610,1600,1830,1190,1820,1440,680,2660,1740,710,920,850,850
+54,530,320,280,590,230,240,260,610,550,870,250,1410,470,130,250,1730,710,280,600,290,200,3090,2940,1400,1100,300,1070,1540,990,1370,870,710,870,610,1060,620,1610,1840,1210,1870,1460,690,2680,1760,710,930,860,860
+55,540,330,290,600,240,250,260,620,560,880,250,1430,480,130,250,1800,720,280,620,290,210,3110,2960,1410,1120,300,1080,1550,1000,1380,880,720,880,620,1080,630,1630,1860,1220,1910,1480,700,2700,1780,720,950,870,860
+56,550,340,300,610,240,250,270,630,560,900,250,1440,490,130,250,1850,730,280,630,300,210,3130,2980,1430,1130,300,1090,1560,1020,1400,890,740,890,630,1090,640,1650,1880,1240,1960,1490,700,2720,1790,730,960,880,870
+57,560,340,300,620,240,260,270,640,570,910,250,1450,500,140,260,1950,750,290,650,300,210,3150,2990,1440,1150,310,1100,1580,1030,1410,890,750,900,640,1100,650,1660,1900,1260,2020,1510,710,2740,1810,740,970,900,880
+58,570,350,310,630,250,260,280,660,580,930,260,1470,510,140,260,1950,760,290,670,300,220,3170,3010,1450,1160,310,1110,1590,1050,1420,900,760,920,650,1110,660,1680,1920,1270,2070,1530,720,2760,1830,750,990,910,890
+59,580,350,320,640,250,260,280,670,590,950,260,1480,510,140,260,2040,770,300,680,310,220,3200,3020,1470,1170,320,1120,1600,1060,1440,910,780,930,660,1130,670,1700,1940,1290,2130,1550,730,2780,1850,760,1000,920,900
+60,590,360,330,650,260,270,290,680,600,970,270,1500,520,140,270,2130,790,300,700,310,220,3220,3040,1480,1190,330,1130,1620,1080,1450,910,790,950,670,1140,680,1710,1950,1310,2180,1570,740,2800,1870,770,1010,930,910
+61,600,370,340,660,260,270,290,690,620,980,270,1510,530,150,270,2210,800,310,720,320,230,3240,3050,1500,1210,330,1140,1630,1090,1460,920,810,960,680,1160,690,1730,1970,1330,2230,1580,750,2820,1890,780,1030,940,920
+62,610,370,340,670,270,280,300,710,630,1000,270,1530,550,150,280,2280,810,320,740,320,230,3260,3060,1510,1220,340,1160,1650,1110,1470,930,830,980,690,1170,700,1750,2000,1350,2290,1600,760,2840,1920,790,1040,950,920
+63,620,380,350,680,270,290,300,720,640,1020,280,1550,560,150,280,2290,830,320,770,330,230,3280,3080,1530,1240,340,1170,1660,1130,1490,930,840,990,700,1190,720,1770,2020,1370,2350,1620,770,2860,1940,800,1060,970,930
+64,630,390,360,690,280,290,310,730,650,1040,280,1560,570,160,290,2310,850,330,790,330,240,3300,3090,1540,1260,350,1180,1680,1150,1500,940,860,1010,720,1200,730,1790,2040,1400,2400,1650,780,2880,1960,810,1080,980,950
+65,640,400,370,700,280,300,320,750,670,1060,280,1580,580,160,290,2380,860,330,810,340,240,3320,3110,1560,1280,360,1190,1690,1170,1520,950,880,1020,730,1220,740,1810,2060,1420,2460,1670,790,2900,1990,820,1100,990,950
+66,660,410,380,710,290,300,320,770,680,1090,290,1600,600,160,300,2400,880,340,840,340,240,3340,3120,1580,1310,360,1200,1710,1190,1530,960,900,1030,740,1230,750,1830,2090,1450,2510,1690,810,2920,2010,830,1120,1010,960
+67,670,410,400,730,300,310,330,780,690,1110,290,1620,610,170,300,2420,900,350,870,350,250,3360,3140,1600,1330,370,1210,1730,1210,1550,960,920,1050,760,1250,770,1850,2120,1480,2570,1710,820,2950,2030,840,1130,1020,970
+68,680,420,410,740,300,320,340,800,710,1130,300,1640,630,170,310,2450,920,360,890,350,250,3380,3150,1620,1350,380,1230,1740,1230,1570,970,940,1070,770,1270,780,1870,2140,1510,2620,1740,830,2970,2050,850,1150,1030,980
+69,700,430,420,750,310,320,340,820,720,1150,300,1650,640,170,310,2490,940,360,920,360,260,3400,3170,1640,1380,390,1240,1760,1250,1580,980,960,1080,790,1290,790,1890,2170,1540,2670,1760,850,2990,2080,870,1180,1050,990
+70,710,440,430,770,320,330,350,840,740,1180,310,1670,660,180,320,2500,960,370,950,370,260,3420,3190,1660,1400,400,1250,1780,1270,1600,990,980,1100,800,1300,810,1910,2200,1570,2710,1790,860,3010,2100,880,1200,1060,1000
+71,730,460,450,780,320,340,360,860,760,1200,310,1690,680,180,320,2570,980,380,980,370,270,3440,3210,1680,1430,400,1270,1800,1290,1620,990,1010,1120,820,1320,830,1940,2230,1600,2760,1810,880,3030,2130,890,1220,1080,1010
+72,740,470,460,800,330,350,370,890,770,1230,320,1710,700,190,330,2660,1000,390,1010,380,270,3460,3220,1700,1460,410,1280,1820,1320,1640,1000,1030,1140,840,1340,840,1960,2260,1640,2810,1840,890,3060,2160,900,1250,1100,1030
+73,760,480,480,810,340,350,380,910,790,1260,330,1740,720,190,340,2730,1030,400,1050,390,280,3480,3240,1730,1490,420,1300,1840,1340,1660,1010,1060,1170,860,1360,860,1990,2290,1670,2860,1870,910,3080,2190,920,1270,1110,1040
+74,780,500,500,830,350,360,390,940,810,1290,330,1760,740,200,340,2850,1050,410,1080,400,280,3500,3260,1750,1520,430,1320,1860,1360,1680,1020,1080,1190,880,1390,880,2010,2320,1710,2900,1900,930,3110,2220,930,1300,1130,1050
+75,800,510,520,850,360,370,400,970,830,1320,340,1780,770,200,350,2930,1070,420,1110,400,290,3520,3280,1780,1560,440,1330,1880,1390,1710,1030,1110,1220,900,1410,900,2030,2350,1760,2940,1930,950,3130,2250,950,1330,1150,1060
+76,820,530,530,870,370,380,410,1000,860,1350,350,1810,800,210,360,2980,1100,440,1150,410,290,3540,3290,1800,1600,460,1350,1900,1420,1730,1040,1150,1240,920,1430,920,2060,2390,1800,2980,1940,970,3160,2280,970,1360,1170,1070
+77,840,550,550,890,380,390,430,1030,880,1380,350,1830,830,210,360,2990,1130,450,1190,420,300,3560,3310,1830,1630,470,1370,1930,1450,1750,1060,1180,1260,950,1460,940,2090,2420,1850,3020,1980,990,3190,2320,980,1400,1190,1090
+78,860,570,570,910,390,400,440,1070,910,1420,360,1860,860,220,370,3080,1160,470,1230,430,310,3580,3330,1860,1670,480,1390,1950,1480,1780,1070,1220,1290,970,1490,960,2120,2460,1900,3060,2010,1010,3210,2350,1000,1430,1210,1100
+79,890,590,600,930,400,410,450,1110,940,1460,370,1880,890,220,380,3170,1200,480,1270,440,310,3600,3350,1890,1720,500,1400,1980,1510,1810,1080,1260,1320,1000,1520,990,2150,2500,1950,3100,2050,1030,3240,2390,1030,1470,1230,1120
+80,920,620,630,960,410,420,470,1150,970,1500,380,1910,930,230,390,3210,1230,500,1320,450,320,3620,3370,1920,1760,510,1430,2010,1540,1830,1090,1300,1350,1030,1550,1010,2180,2540,2020,3140,2100,1060,3260,2420,1050,1510,1250,1130
+81,950,640,660,990,430,440,480,1200,1000,1540,390,1940,970,240,410,3290,1260,520,1370,460,330,3640,3390,1960,1810,520,1450,2040,1580,1860,1110,1340,1390,1060,1580,1040,2220,2590,2080,3180,2140,1090,3290,2460,1070,1540,1280,1150
+82,980,670,700,1010,440,450,500,1260,1030,1580,400,1980,1010,250,420,3370,1300,540,1430,480,340,3660,3410,1990,1860,540,1470,2070,1610,1890,1120,1390,1430,1100,1620,1070,2250,2630,2160,3230,2190,1120,3320,2500,1100,1590,1310,1170
+83,1010,710,740,1050,450,460,520,1320,1070,1630,410,2010,1060,260,430,3420,1340,570,1490,490,350,3680,3430,2030,1920,560,1500,2110,1640,1930,1140,1440,1470,1130,1650,1100,2290,2680,2230,3260,2240,1150,3350,2540,1130,1640,1340,1190
+84,1050,750,780,1080,470,480,540,1390,1110,1690,420,2050,1110,260,450,3460,1390,590,1550,510,360,3690,3460,2080,1990,580,1530,2150,1680,1960,1150,1490,1520,1170,1690,1140,2330,2730,2320,3310,2290,1190,3380,2590,1170,1690,1370,1210
+85,1100,800,830,1120,490,500,560,1470,1160,1740,440,2090,1170,270,470,3540,1440,630,1620,520,370,3710,3480,2120,2060,600,1560,2190,1730,2000,1170,1550,1570,1220,1740,1180,2370,2780,2420,3350,2350,1230,3410,2600,1200,1740,1400,1220
+86,1150,860,890,1170,500,520,590,1560,1210,1810,450,2130,1230,280,490,3620,1490,660,1680,540,390,3730,3510,2170,2140,630,1600,2230,1770,2040,1190,1620,1630,1260,1780,1220,2410,2830,2550,3390,2410,1280,3440,2660,1240,1790,1450,1250
+87,1200,930,960,1210,520,540,630,1660,1270,1870,460,2180,1300,300,510,3670,1550,700,1710,560,400,3750,3540,2220,2210,650,1630,2280,1820,2080,1210,1690,1680,1320,1830,1260,2460,2890,2700,3430,2490,1330,3470,2700,1280,1850,1490,1280
+88,1260,1010,1040,1260,550,570,660,1770,1340,1930,480,2240,1380,310,540,3670,1610,740,1740,590,420,3770,3560,2270,2280,690,1670,2320,1880,2130,1240,1760,1750,1380,1890,1320,2520,2950,2880,3470,2570,1380,3510,2750,1330,1920,1540,1310
+89,1340,1100,1140,1320,570,600,710,1870,1420,2010,500,2300,1460,330,570,3670,1680,780,1760,610,430,3790,3590,2340,2360,720,1720,2380,1930,2190,1260,1840,1820,1450,1950,1370,2580,3020,3080,3520,2640,1440,3540,2810,1380,2000,1590,1350
+90,1420,1220,1260,1390,610,630,760,1980,1510,2110,520,2370,1570,350,620,3670,1760,840,1800,640,460,3810,3610,2400,2430,760,1770,2440,2000,2250,1290,1920,1910,1530,2010,1440,2630,3090,3350,3560,2710,1510,3580,2870,1420,2090,1650,1390
+91,1530,1360,1390,1460,650,670,820,2100,1620,2220,550,2440,1700,380,680,3670,1850,900,1880,670,480,3830,3650,2470,2510,800,1830,2510,2070,2310,1320,2000,2000,1620,2090,1510,2700,3160,3750,3600,2800,1590,3610,2930,1470,2200,1710,1430
+92,1660,1440,1560,1550,690,720,900,2240,1730,2340,580,2530,1860,410,750,3670,1940,970,2000,710,510,3850,3680,2550,2590,850,1900,2590,2150,2380,1360,2100,2100,1730,2180,1600,2770,3240,3850,3650,2900,1670,3650,3010,1530,2310,1790,1490
+93,1830,1610,1760,1650,750,780,980,2380,1870,2480,610,2630,2060,450,830,3680,2050,1060,2110,760,550,3870,3710,2640,2650,920,1960,2680,2250,2450,1410,2200,2220,1850,2280,1700,2860,3320,3860,3690,2990,1760,3690,3050,1610,2420,1880,1540
+94,2060,1910,1870,1780,820,860,1090,2500,2010,2640,650,2750,2270,500,890,3680,2170,1170,2220,820,590,3890,3750,2740,2740,1000,2060,2780,2360,2530,1460,2320,2360,1990,2400,1820,2950,3400,3870,3730,3100,1870,3730,3140,1720,2560,1990,1620
+95,2350,2300,2030,1930,920,960,1260,2640,2200,2810,700,2880,2520,550,960,3750,2320,1300,2350,900,640,3910,3780,2850,2840,1100,2180,2900,2480,2640,1530,2480,2510,2130,2540,1980,3060,3490,3870,3770,3220,2020,3760,3230,1840,2730,2120,1720
+96,2690,2570,2390,2110,1050,1090,1520,2830,2450,3060,770,3050,2750,580,1010,3800,2480,1470,2540,990,710,3930,3820,2980,2950,1250,2330,3040,2620,2770,1620,2680,2690,2350,2710,2170,3180,3590,3880,3810,3340,2180,3810,3340,2010,2930,2280,1860
+97,3140,2790,2910,2360,1220,1290,1870,3090,2770,3420,850,3250,3260,680,1060,3860,2680,1710,2770,1130,790,3950,3860,3150,3090,1450,2530,3210,2790,2950,1740,2920,2890,2610,2860,2440,3320,3680,3880,3850,3480,2410,3850,3470,2230,3170,2500,2010
+98,3560,3270,3230,2670,1500,1610,2260,3370,3160,3840,990,3470,3460,830,1140,3920,2950,2070,2990,1370,950,3970,3910,3350,3280,1680,2800,3440,3030,3160,1930,3210,3150,2930,3100,2820,3500,3780,3880,3910,3610,2730,3900,3620,2590,3400,2820,2310
+99,3560,3660,3520,3150,1880,2290,2540,3630,3590,3860,1270,3720,3590,1230,1630,3950,3330,2640,3370,1850,1320,3990,3950,3630,3570,2210,3240,3710,3370,3460,2290,3570,3500,3370,3470,3410,3730,3890,3890,3950,3800,3200,3950,3810,3200,3690,3270,2850

cc-multilingual-main/cc_net/build/lib/cc_net/data/test_stats.json

@@ -0,0 +1,38 @@
+{
+  "2019-09/de_head_0000.json.gz": {
+    "size": 5264993,
+    "checksum": "fc12ba3dc982ef06e7e44a916f298e1c16f9a806"
+  },
+  "2019-09/de_middle_0000.json.gz": {
+    "size": 9195535,
+    "checksum": "2369ff0296ab1d924c81083f17ce41f22a10ad69"
+  },
+  "2019-09/de_tail_0000.json.gz": {
+    "size": 33029074,
+    "checksum": "18865040a7263242d298958f358f7cb5511114d4"
+  },
+  "2019-09/fr_head_0000.json.gz": {
+    "size": 4076580,
+    "checksum": "4eef4017bbbe042fc01c45b5fbcf94de49f5138e"
+  },
+  "2019-09/fr_middle_0000.json.gz": {
+    "size": 8075095,
+    "checksum": "fd251a5b924c4aa66a63c375ca3a8fae23b3273b"
+  },
+  "2019-09/fr_tail_0000.json.gz": {
+    "size": 27248949,
+    "checksum": "4a8aed38abc6b9d04459e8d424bd47426f063638"
+  },
+  "2019-09/it_head_0000.json.gz": {
+    "size": 1760696,
+    "checksum": "e5e50e49b4a5147ea82b385babd5c83f74d2a4ed"
+  },
+  "2019-09/it_middle_0000.json.gz": {
+    "size": 4461832,
+    "checksum": "7daab7b7acb93d81e50534196ada4e94947b8224"
+  },
+  "2019-09/it_tail_0000.json.gz": {
+    "size": 14754298,
+    "checksum": "1adc018519a598ff162261d7e480ea41d3458768"
+  }
+}

cc-multilingual-main/cc_net/build/lib/cc_net/mine.py

@@ -0,0 +1,648 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+"""
+Main script to download a CC dump, remove duplicates, split by language and
+filter the documents.
+
+The pipeline parameters are described in the `Config` class.
+"""
+
+import hashlib
+import json
+import time
+import warnings
+from argparse import ArgumentParser
+from collections import defaultdict
+from itertools import repeat
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, NamedTuple, Optional, Sequence, Tuple
+
+import func_argparse
+
+# Local scripts
+from cc_net import dedup, execution, jsonql, minify, perplexity, process_wet_file
+from cc_net import regroup as regroup_module
+from cc_net import split_by_lang
+from cc_net.execution import Executor
+
+# Constant
+FILE_DIR = Path(__file__).parent
+CUTOFF_CSV = FILE_DIR / "data" / "cutoff.csv"
+
+DEFAULT_PIPELINE = [
+    # "dedup",
+    "lid",
+    "keep_lang",
+    "sp",
+    "lm",
+    "pp_bucket",
+    "drop",
+    "split_by_lang",
+]
+
+
+class Config(NamedTuple):
+    """
+    Mine Common Crawl with the given settings.
+
+    config_name
+    dump: CC dump id
+    output_dir: working directory
+    mined_dir: name of the destination folder, full path will be {ouput_dir}/{mined_dir}/{dump_id}
+    execution: chose how to parallelize the execution
+    num_shards: number of shards to split the dump
+    num_segments_per_shard: allow to download a small portion of CC (eg for tests)
+    min_len: remove documents shorter than this (in chars)
+    hashes_in_mem: number of shards hashes to use for dedup
+    lang_whitelist: only treat those languages
+    lang_blacklist: ignore those languages
+    lang_threshold: remove docs whose top language score is lower than this
+    keep_bucket: keep only those perplexity bucket chose from (head, middle, tail, all)
+    lm_dir: folder containing LMs
+    lm_languages: only use LMs for the following languages
+    cutoff: cutoff file to use for split in head/middle/tail
+    mine_num_processes: number of processes to use for mining
+    target_size: size of finals files produce during `regroup` stage
+    cleanup_after_regroup: delete intermediary files after regroup
+    task_parallelism: max number of task to run in parallel
+    pipeline: restricts the mining pipeline to the given steps. Order is important !
+    experiments: (HACK) enable specific experiments in the code
+    """
+
+    config_name: str = "base"
+    dump: str = "2017-51"
+    output_dir: Path = Path("data")
+    mined_dir: str = "mined"
+    execution: str = "auto"
+    num_shards: int = 1600
+    num_segments_per_shard: int = -1
+    metadata: Optional[str] = None
+    min_len: int = 300
+    hash_in_mem: int = 50
+    lang_whitelist: Sequence[str] = ['hi']
+    lang_blacklist: Sequence[str] = []
+    lang_threshold: float = 0.5
+    keep_bucket: Sequence[str] = []
+    lm_dir: Path = Path("data/lm_sp")
+    cutoff: Path = CUTOFF_CSV
+    lm_languages: Optional[Sequence[str]] = None
+    mine_num_processes: int = 16
+    target_size: str = "4G"
+    cleanup_after_regroup: bool = False
+    task_parallelism: int = -1
+    pipeline: Sequence[str] = DEFAULT_PIPELINE
+    experiments: Sequence[str] = []
+    cache_dir: Optional[Path] = None
+
+    def get_executor(
+        self, name: str, timeout_hour: int = 1, mem_gb: int = 1, cpus: int = 1
+    ) -> Executor:
+        name = "_".join((name, self.config_name, *self.experiments))
+        return execution.get_executor(
+            name,
+            self.output_dir / "logs",
+            self.execution,
+            timeout_hour=timeout_hour,
+            mem_gb=mem_gb,
+            cpus=cpus,
+            task_parallelism=self.task_parallelism,
+        )
+
+    def get_cc_shard(self, shard: int) -> process_wet_file.CCShardReader:
+        dump_cache: Optional[Path] = None
+        if self.cache_dir:
+            self.cache_dir.mkdir(exist_ok=True)
+            dump_cache = self.cache_dir / self.dump
+            dump_cache.mkdir(exist_ok=True)
+
+        return process_wet_file.CCShardReader(
+            self.dump,
+            shard=shard,
+            num_shards=self.num_shards,
+            num_segments_per_shard=self.num_segments_per_shard,
+            min_len=self.min_len,
+            cache_dir=dump_cache,
+        )
+
+    @classmethod
+    def from_json(cls, json_file: Path) -> "Config":
+        raw_lines = json_file.read_text().splitlines()
+        raw_lines = [l for l in raw_lines if not l.strip().startswith("//")]
+        json_config = json.loads("".join(raw_lines))
+        path_keys = ["cache_dir", "lm_dir", "output_dir"]
+        for key in path_keys:
+            if key in json_config:
+                json_config[key] = Path(json_config[key])
+        return Config(**json_config)
+
+    @property
+    def will_split(self) -> bool:
+        return "split_by_lang" in self.pipeline or "split_by_segment" in self.pipeline
+
+    def get_lm_languages(self) -> Sequence[str]:
+        if self.lm_languages is not None:
+            return self.lm_languages
+
+        if self.lang_whitelist:
+            return self.lang_whitelist
+
+        languages = [m.name.split(".")[0] for m in self.lm_dir.glob("*.arpa.bin")]
+        if self.lang_blacklist:
+            languages = [l for l in languages if l not in self.lang_blacklist]
+        return languages
+
+    def get_mined_dir(self, regroup: bool = False) -> Path:
+        if self.will_split and not regroup:
+            return self.output_dir / f"{self.mined_dir}_split" / self.dump
+        return self.output_dir / self.mined_dir / self.dump
+
+
+BASE_CONFIG = Config()
+
+BYLANG_CONFIG = Config(
+    config_name="by_lang",
+    mined_dir="mined_by_lang",
+    pipeline=list(BASE_CONFIG.pipeline[:-1]) + ["split_by_lang"],
+)
+
+REPRODUCE_CONFIG = Config(
+    config_name="reproduce",
+    dump="2019-09",
+    mined_dir="reproduce",
+    pipeline=["fetch_metadata", "keep_lang", "keep_bucket", "split_by_lang"],
+    metadata="https://dl.fbaipublicfiles.com/cc_net/1.0.0",
+    # Optional filtering:
+    # It won't change much the execution speed, but decreases the disk requirement.
+    # Restrict languages
+    lang_whitelist=["fr"],
+    # Restrict perplexity buckets
+    # Top languages have been split in perplexity buckets according
+    # to a Wikipedia trained LM.
+    # The buckets from low perplexity (good) to high (bad) are:
+    # ["head", "middle", "tail"]
+    # Languages without a LM have only one bucket "all".
+    # It won't change much the execution speed, but decreases the disk requirement.
+    keep_bucket=["head", "all"],
+    mine_num_processes=1,
+)
+
+TEST_CONFIG = BASE_CONFIG._replace(
+    config_name="test",
+    dump="2019-09",
+    output_dir=Path("test_data"),
+    execution="local",
+    num_shards=4,
+    num_segments_per_shard=1,
+    hash_in_mem=2,
+    mine_num_processes=2,
+    lang_whitelist=["de", "it", "fr"],
+    target_size="32M",
+    cleanup_after_regroup=False,
+    cache_dir=Path("test_data/wet_cache"),
+)
+
+PREDEF_CONFIGS = {
+    "base": BASE_CONFIG,
+    "by_lang": BYLANG_CONFIG,
+    "test": TEST_CONFIG,
+    "test_slurm": TEST_CONFIG._replace(execution="slurm,partition=dev"),
+    "debug": TEST_CONFIG._replace(config_name="debug", mine_num_processes=0),
+    "reproduce": REPRODUCE_CONFIG,
+    "augment": BASE_CONFIG._replace(
+        config_name="augment", dump="2019-13", lang_blacklist=["en"]
+    ),
+}
+
+
+def tmp(output: Path) -> Path:
+    return output.parent / (output.stem + ".tmp" + output.suffix)
+
+
+def finalize(tmp_output: Path, output: Path) -> None:
+    if not tmp_output.exists():
+        warnings.warn(f"Targeted tmp output {tmp_output} doesn't exists.")
+        return
+
+    tmp_index = tmp_output.parent / (tmp_output.name + ".index")
+    tmp_output.rename(output)
+
+    if tmp_index.exists():
+        tmp_index.rename(output.parent / (output.name + ".index"))
+
+
+def _transpose(iterable: Sequence[Tuple[Any, ...]], n=-1) -> Tuple[List, ...]:
+    if n < 0:
+        n = len(iterable[0])
+    columns: tuple = tuple([] for _ in range(n))
+    for row in iterable:
+        assert len(row) == n, f"Found tuple of len({len(row)}, expected {n}: {row}"
+        for i in range(n):
+            columns[i].append(row[i])
+
+    return columns
+
+
+def hashes(conf: Config) -> List[Path]:
+    """Computes hashes for each shard."""
+
+    hashes_dir = conf.output_dir / "hashes" / conf.dump
+    outputs = [hashes_dir / f"{shard:04d}.bin" for shard in range(conf.num_shards)]
+    missing_outputs = [(shard, o) for shard, o in enumerate(outputs) if not o.exists()]
+
+    if not missing_outputs:
+        return outputs
+
+    hashes_dir.mkdir(parents=True, exist_ok=True)
+    # With FlatHashSet we need ~2Gb of RAM / shard, but we need to account for
+    # overhead due to how the dynamic allocation works.
+    ex = conf.get_executor(f"hashes_{conf.dump}", mem_gb=4, timeout_hour=6, cpus=2)
+    ex(_hashes_shard, repeat(conf), *_transpose(missing_outputs))
+
+    # Wait a bit so that files appears on the disk.
+    time.sleep(20)
+    assert all(o.exists() for o in outputs)
+    return outputs
+
+
+def _hashes_shard(conf: Config, shard: int, output: Path):
+    tmp_output = tmp(output)
+    jsonql.run_pipes(
+        dedup.HashesCollector(field="raw_content", output=tmp_output),
+        inputs=conf.get_cc_shard(shard),
+    )
+    finalize(tmp_output, output)
+    return f"Hashed {output}"
+
+
+HASHES_IN_MEM = [0, 1, 2, 5, 10, 20, 50, 100, 200, 400]
+
+
+def mine(conf: Config) -> List[Path]:
+    """Remove dups, run LID and LMs, and split by lang and quality."""
+    mined_dir = conf.get_mined_dir()
+    if conf.will_split:
+        # Give a directories when splitting
+        outputs = [mined_dir / f"{shard:04d}" for shard in range(conf.num_shards)]
+    else:
+        # Files otherwise
+        outputs = [
+            mined_dir / f"{shard:04d}.json.gz" for shard in range(conf.num_shards)
+        ]
+
+    if "mini_again" in conf.experiments:
+        mined_dir = conf.output_dir / "mini_again" / conf.dump
+        outputs = [mined_dir / f"{shard:04d}" for shard in range(conf.num_shards)]
+
+    # TODO: try to reduce this / make it a function of "hash_in_mem" / num_langs
+    mem_gb = 60 + 1 * conf.hash_in_mem
+    timeout_hour = 5
+    if "hashes" in conf.experiments:
+        # HACK: used for generating paper figures
+        outputs = [
+            conf.output_dir / f"hashes_exp/{conf.dump}_0000_dedup{h:03d}.json.gz"
+            for h in HASHES_IN_MEM
+        ]
+        mem_gb = int(max(HASHES_IN_MEM) * 1.2)
+        timeout_hour = 8
+
+    missing_outputs = [(shard, o) for shard, o in enumerate(outputs) if not o.exists()]
+
+    if "mini_again" in conf.experiments:
+        missing_outputs = [
+            (shard, o)
+            for shard, o in enumerate(outputs)
+            if shard in [5, 139] and not o.exists()
+        ]
+
+    if not missing_outputs:
+        return outputs
+
+    mined_dir.mkdir(parents=True, exist_ok=True)
+    ex = conf.get_executor(
+        f"mine_{conf.dump}",
+        mem_gb=mem_gb,
+        timeout_hour=timeout_hour,
+        cpus=conf.mine_num_processes + 1,
+    )
+
+    # Compute hashes firsts.
+    if "dedup" in conf.pipeline:
+        hashes_groups = list(jsonql.grouper(hashes(conf), conf.hash_in_mem))
+        hashes_files: Iterable[List[Path]] = [
+            hashes_groups[shard // conf.hash_in_mem] for shard, o in missing_outputs
+        ]
+    else:
+        hashes_files = repeat([])
+
+    ex(_mine_shard, repeat(conf), hashes_files, *_transpose(missing_outputs))
+
+    assert all(o.exists() for o in outputs)
+    return outputs
+
+
+def _get_segment(tmp_output: Path, doc: dict) -> str:
+    segment: str = doc["cc_segment"].split("/")[-1]
+    return str(tmp_output / segment.replace(".warc.wet.gz", ".json.gz"))
+
+
+def _mine_shard(conf: Config, hashes: List[Path], shard: int, output: Path) -> str:
+    assert conf.pipeline
+    tmp_output = tmp(output)
+    if "hashes" in conf.experiments:
+        # HACK: used for generating paper figures
+        hashes_in_mem = shard
+        hashes = hashes[: HASHES_IN_MEM[hashes_in_mem]]
+        shard = 0
+    cc_shard = conf.get_cc_shard(shard)
+
+    steps: Dict[str, Optional[jsonql.Transformer]] = {}
+    lang_id = Path("bin") / "lid.bin"
+    steps["lid_before_dedup"] = split_by_lang.Classifier(
+        model=lang_id, field="raw_content", out_field="lid_before_dedup", top=5
+    )
+    steps["dedup"] = dedup.DuplicatesRemover(field="raw_content", hashes_files=hashes)
+
+    steps["lid"] = split_by_lang.Classifier(
+        model=lang_id,
+        field="raw_content",
+        out_field="language",
+        top=1,
+        threshold=conf.lang_threshold,
+    )
+    steps["lid_after_dedup"] = split_by_lang.Classifier(
+        model=lang_id, field="raw_content", out_field="lid_after_dedup", top=5
+    )
+
+    if conf.lang_blacklist:
+        steps["keep_lang"] = jsonql.where(
+            [lambda doc: doc.get("language") not in set(conf.lang_blacklist)]
+        )
+    elif conf.lang_whitelist:
+        steps["keep_lang"] = jsonql.where(
+            [lambda doc: doc.get("language") in set(conf.lang_whitelist)]
+        )
+    else:
+        steps["keep_lang"] = None
+
+    tok_field = "tokenized"
+    steps["sp"] = perplexity.MultiSentencePiece(
+        {l: conf.lm_dir / f"{l}.sp.model" for l in conf.get_lm_languages()},
+        field="raw_content",
+        output_field=tok_field,
+        normalize=True,
+    )
+    steps["lm"] = perplexity.DocLM(
+        {l: conf.lm_dir / f"{l}.arpa.bin" for l in conf.get_lm_languages()},
+        field=tok_field,
+        output_field="perplexity",
+        normalize=False,  # Normalization is done before SentencePiece
+        # load_method=kenlm.LoadMethod.PARALLEL_READ,
+    )
+    steps["pp_bucket"] = perplexity.PerplexityBucket(CUTOFF_CSV)
+    steps["drop"] = perplexity.DropKeys(tok_field)
+
+    steps["keep_bucket"] = None
+    if conf.keep_bucket:
+        steps["keep_bucket"] = jsonql.where(
+            [lambda doc: doc.get("bucket", "all") in conf.keep_bucket]
+        )
+
+    if "fetch_metadata" in conf.pipeline:
+        # TODO: better default
+        assert conf.metadata is not None
+        steps["fetch_metadata"] = minify.MetadataFetcher(
+            f"{conf.metadata}/{conf.dump}/"
+        )
+
+    steps["minify"] = minify.Minifier()
+
+    pattern = str(tmp_output / "{language}_{bucket}.json.gz")
+    steps["split_by_lang"] = jsonql.split(pattern=str(pattern), mkdir=True)
+
+    steps["split_by_segment"] = jsonql.split(
+        split_fn=lambda doc: _get_segment(tmp_output, doc), mkdir=True
+    )
+
+    pipeline = filter(None, (steps[s] for s in conf.pipeline))
+
+    jsonql.run_pipes(
+        *pipeline,
+        inputs=cc_shard,
+        processes=conf.mine_num_processes,
+        chunksize=100,
+        # The splitter takes care of writing to files.
+        output=tmp_output if not conf.will_split else None,
+    )
+    finalize(tmp_output, output)
+    return f"Mined {output}"
+
+
+def regroup(conf: Config, all_dirs: List[Path]) -> Path:
+    """Reshards each language/quality after 'mine'."""
+    regroup_dir = conf.get_mined_dir(regroup=True)
+    assert all_dirs
+    all_files = [f for d in all_dirs for f in d.glob("*.json.gz")]
+    if not all_files:
+        print(f"No .json.gz file found in {all_dirs[0]}")
+
+    splits: Dict[str, List[Path]] = defaultdict(list)
+    for f in all_files:
+        split = f.name.split(".")[0]
+        splits[split].append(f)
+
+    print(f"Identified {len(all_files)} files to regroup from {len(splits)} splits.")
+    inputs: List[List[Path]] = []
+    outputs: List[Path] = []
+    target_size = jsonql.parse_size(conf.target_size)
+    for split, files in splits.items():
+        cuts = list(regroup_module.determine_groups(files, target_size=target_size))
+        if not cuts:
+            continue
+
+        pattern = f"{split}_????.json.gz"
+        existing_outputs = sorted(regroup_dir.glob(pattern))
+
+        if not conf.cleanup_after_regroup:
+            # We still have all the inputs so it is safe to overwrite existing outputs.
+            assert len(existing_outputs) <= len(cuts)
+            existing_outputs = []
+
+        if len(existing_outputs) > 0 and len(cuts) == 1:
+            # append to existing file if size allows it.
+            new_size = (
+                sum(f.stat().st_size for f in cuts[0])
+                + existing_outputs[-1].stat().st_size
+            )
+            if new_size < target_size:
+                print(f"Will append {cuts[0]} to {existing_outputs[-1]}")
+                cuts[0].insert(0, existing_outputs.pop(-1))
+
+        n_existing = len(existing_outputs)
+        for i, cut in enumerate(cuts):
+            # avoid overwriting existing files.
+            j = i + n_existing
+            output = regroup_dir / f"{split}_{j:04}.json.gz"
+            inputs.append(cut)
+            outputs.append(output)
+        print(
+            str(regroup_dir / pattern),
+            "->",
+            len(cuts),
+            f"shards ({n_existing} already there).",
+        )
+
+    ex = conf.get_executor(f"regroup_{conf.dump}", mem_gb=1, timeout_hour=12, cpus=2)
+    ex(_regroup, repeat(conf), inputs, outputs)
+
+    return regroup_dir
+
+
+def _regroup(conf: Config, inputs: List[Path], output: Path) -> str:
+    output.parent.mkdir(parents=True, exist_ok=True)
+    regroup_module.fast_reshard(
+        inputs, output, tmp=tmp(output), rm_original=conf.cleanup_after_regroup
+    )
+    return f"Regrouped {output}"
+
+
+def move_segments(conf: Config, all_dirs: Sequence[Path]) -> Path:
+    """Reshards each language/quality after 'mine'."""
+    # check that mining is over.
+    regroup_dir = conf.get_mined_dir(regroup=True)
+    assert all_dirs, "Received no dirs to move"
+    assert all(
+        d.is_dir() for d in all_dirs
+    ), f"move_segments was expecting dirs received files: {all_dirs[:10]}..."
+
+    regroup_dir.parent.mkdir(exist_ok=True)
+    regroup_dir.mkdir(exist_ok=True)
+    ex = conf.get_executor(f"moveseg_{conf.dump}", mem_gb=1, timeout_hour=1, cpus=2)
+
+    def _move_segments(subdir: Path, regroup_dir: Path) -> str:
+        n = 0
+        for f in subdir.iterdir():
+            if not f.is_file() or f.is_symlink():
+                continue
+            n += f.name.endswith(".json.gz")
+            new_name = regroup_dir / f.name
+            target = new_name.resolve()
+            assert f.resolve() != target
+            # this make the job idempotent.
+            f.rename(new_name)
+            f.symlink_to(target)
+
+        if n == 0:
+            return ""
+
+        return f"Moved {n} .json.gz files from {subdir} to {regroup_dir}"
+
+    ex(_move_segments, all_dirs, repeat(regroup_dir))
+    print(f"Results are in {regroup_dir}")
+    return regroup_dir
+
+
+def _validate_test(conf: Config, output_dir: Path, generate: bool = False):
+    stats: Dict[str, dict] = {}
+    for file in sorted(output_dir.glob("*.json.gz")):
+        fname = "/".join((file.parent.name, file.name))
+        # The order of documents is not guaranteed inside a shard,
+        lines = sorted(jsonql.open_read(file))
+        content = "\n".join(lines)
+        size = len(content)
+        checksum = hashlib.sha1(bytes(content, encoding="utf-8")).hexdigest()
+        # first_document = json.loads(lines[0])
+        stats[fname] = {"size": size, "checksum": checksum}
+
+    def dump(x):
+        return json.dumps(x, indent=2, ensure_ascii=False)
+
+    print("*** Stats ***")
+    stats_raw = dump(stats)
+    stats_file = FILE_DIR / "data" / "test_stats.json"
+    if generate:
+        print("Saving stats to", stats_file)
+        stats_file.write_text(stats_raw)
+        return
+
+    expected_stats: Dict[str, dict] = {}
+    if stats_file.exists():
+        expected_stats = json.loads(stats_file.read_text())
+
+    if expected_stats == stats:
+        print("Everything looks good !")
+        return
+
+    stats_file.with_suffix(".actual.json").write_text(stats_raw)
+    print("*** Expected Stats ***")
+    print(dump(expected_stats))
+
+    print("*** Diff ***")
+    for fname in sorted(expected_stats.keys()):
+        print(fname)
+        assert fname in expected_stats, "missing file " + fname
+        if expected_stats[fname]["size"] != stats[fname]["size"]:
+            print(
+                "  - Expected size",
+                expected_stats[fname]["size"],
+                ", size",
+                stats[fname]["size"],
+            )
+        if expected_stats[fname]["checksum"] != stats[fname]["checksum"]:
+            print(
+                "  - Expected checksum",
+                expected_stats[fname]["checksum"],
+                ", checksum",
+                stats[fname]["checksum"],
+            )
+
+
+def get_main_parser() -> ArgumentParser:
+    # Generates the 'main' parser by patching a 'Config' parser
+    p = func_argparse.func_argparser(Config)
+
+    # Override defaults value to None, so we know what was set by the user.
+    # Note that it will keep the original default values in the help message.
+    p.set_defaults(**{f: None for f in Config._fields})
+    p.add_argument("--config", type=str, default="base")
+    p.set_defaults(__command=main)
+    return p
+
+
+def main(config: str = "base", **config_as_dict: Any) -> None:
+    # Use the given 'config' as default value.
+    config_base = config
+    if config_base in PREDEF_CONFIGS:
+        conf = PREDEF_CONFIGS[config_base]
+    elif Path(config_base).exists():
+        conf = Config.from_json(Path(config_base))
+    else:
+        raise ValueError(
+            f"Invalid value {config_base} for --config. "
+            f"Choose from ({', '.join(PREDEF_CONFIGS)}) or give an existing .json file."
+        )
+    conf = conf._replace(**{k: v for (k, v) in config_as_dict.items() if v is not None})
+
+    print(f"Will run cc_net.mine.main with the following config:", conf)
+
+    all_files = mine(conf)
+    if conf.will_split:
+        assert all_files
+        assert all(d.is_dir() for d in all_files)
+        all_dirs = all_files
+        if "split_by_lang" in conf.pipeline:
+            # Only try regrouping if we split the shards.
+            regroup(conf, all_dirs)
+        elif "split_by_segment" in conf.pipeline:
+            # If we split by segment then regrouping is trivial, since segments appear in only one shard.
+            move_segments(conf, all_dirs)
+
+    if conf.config_name == "test":
+        _validate_test(conf, conf.get_mined_dir(regroup=True))
+
+
+if __name__ == "__main__":
+    func_argparse.parse_and_call(get_main_parser())

cc-multilingual-main/cc_net/build/lib/cc_net/perplexity.py

@@ -0,0 +1,356 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import argparse
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Sequence, Tuple, Union
+
+import kenlm  # type: ignore
+import numpy as np  # type: ignore
+import pandas as pd  # type: ignore
+import sentencepiece  # type: ignore
+
+from cc_net import jsonql, text_normalizer
+
+LMDescriptor = Union[Dict[str, Path], Union[Path, str]]
+
+
+def get_args():
+    parser = argparse.ArgumentParser(
+        description="Compute the score of each sentences of a document",
+        parents=[jsonql.io_parser()],
+    )
+    parser.add_argument("--models", type=str)
+
+    parser.add_argument("--sentences", action="store_true", default=False)
+    parser.add_argument(
+        "--languages", type=str, help="Ignore doc with another language"
+    )
+    parser.add_argument("--field", type=str, default=None)
+    parser.add_argument("--newline", type=str, default="\n")
+    return vars(parser.parse_args())
+
+
+def pp(log_score, length):
+    return 10.0 ** (-log_score / length)
+
+
+class SentencePiece(jsonql.Transformer):
+    # Sentence Pieces model have to be read back from disk.
+    warning_when_pickling = True
+
+    def __init__(
+        self,
+        model: Path,
+        field: str,
+        output_field: str = "tokenized",
+        normalize: bool = False,
+    ):
+        super().__init__()
+        self.model = model
+        self.field = field
+        self.output_field = output_field
+        self.normalize = normalize
+        self.sp: sentencepiece.SentencePieceProcessor = None
+
+    def _prepare(self):
+        if self.sp is not None:
+            return
+        self.sp = sentencepiece.SentencePieceProcessor()
+        self.sp.load(str(self.model))
+        return self
+
+    def do(self, document: dict) -> dict:
+        text = document[self.field]
+        if self.normalize:
+            text = text_normalizer.normalize(text)
+        tokenized = self.sp.encode_as_pieces(text)
+        document[self.output_field] = " ".join(tokenized)
+        return document
+
+
+class MultiSentencePiece(jsonql.Transformer):
+    warning_when_pickling = True
+
+    def __init__(
+        self,
+        models: Union[Path, Dict[str, Path]],
+        field: str,
+        output_field: str = "tokenized",
+        normalize: bool = False,
+    ):
+        super().__init__()
+        self.field = field
+        self.output_field = output_field
+        self.normalize = normalize
+        self._prefetch: Sequence[str] = []
+
+        if isinstance(models, Path):
+            self.models = {
+                m.name.split(".")[0]: m for m in models.parent.glob(models.name)
+            }
+        else:
+            self.models = models
+            self._prefetch = list(models.keys())
+        self.sp: Dict[str, sentencepiece.SentencePieceProcessor] = {}
+
+    def _prepare(self) -> None:
+        for lang in self._prefetch:
+            assert (
+                self.get_sp(lang) is not None
+            ), f"No model found for {lang} at {self.models.get(lang)}."
+
+    def get_sp(self, lang) -> Optional[sentencepiece.SentencePieceProcessor]:
+        sp = self.sp.get(lang)
+        if sp is not None:
+            return sp
+        if lang not in self.models:
+            return None
+
+        start_load = time.time()
+        self.log(f"Loading {self.models[lang]}...")
+        sp = sentencepiece.SentencePieceProcessor()
+        sp.load(str(self.models[lang]))
+        self.sp[lang] = sp
+        load_time = time.time() - start_load
+        self.log(f"Loaded {self.models[lang]} (took {load_time / 60:.1f}min)")
+        return sp
+
+    def do(self, document: dict) -> Optional[dict]:
+        text = document[self.field]
+        if self.normalize:
+            text = text_normalizer.normalize(text)
+        sp = self.get_sp(document.get("language"))
+        if sp is None:
+            return document
+        tokenized = sp.encode_as_pieces(text)
+        document[self.output_field] = " ".join(tokenized)
+        return document
+
+
+class DocLM(jsonql.Transformer):
+    def __init__(
+        self,
+        models: Union[Path, Dict[str, Path]],
+        field: str,
+        output_field: str = "perplexity",
+        newline: str = "\n",
+        normalize: bool = True,
+        load_method: int = 2,
+    ):
+        super().__init__()
+        self.field = field
+        self.output_field = output_field
+        self.newline = newline
+        self.normalize = normalize
+        self._prefetch: Sequence[str] = []
+        self.lm_config = kenlm.Config()
+        # This is the default settings
+        # POPULATE will mmap the models and populate the pages.
+        # Maybe that's not the best way when the models are on a network disk.
+        # TODO: try copying models file, try READ or PARALLEL_READ
+        self.lm_config.load_method = load_method
+
+        if isinstance(models, Path):
+            self.models = {
+                m.name.split(".")[0]: m for m in models.parent.glob(models.name)
+            }
+        else:
+            self.models = models
+            self._prefetch = list(models.keys())
+        self.lm: Dict[str, kenlm.Model] = {}
+        self.n_lines = 0
+
+    def _prepare(self) -> None:
+        for lang in self._prefetch:
+            assert (
+                self.get_lm(lang) is not None
+            ), f"No model found for {lang} at {self.models.get(lang)}."
+
+    def get_lines(self, document: dict) -> List[str]:
+        lang = document.get("language")
+        if not lang:
+            return []
+        if lang not in self.models:
+            return []
+
+        content = document.get(self.field)
+        if not content:
+            return []
+
+        lines = content.split(self.newline)
+        self.n_lines += len(lines)
+        return lines
+
+    def get_lm(self, lang: Optional[str]) -> Optional[kenlm.Model]:
+        if lang is None:
+            return None
+        lm = self.lm.get(lang)
+        if lm is not None:
+            return lm
+        model = self.models.get(lang)
+        if model is None:
+            return None
+        start_load = time.time()
+        self.log(f"Loading {self.models[lang]}...")
+        lm = kenlm.Model(str(model), self.lm_config)
+        self.lm[lang] = lm
+        load_time = time.time() - start_load
+        self.log(f"Loaded {self.models[lang]} (took {load_time / 60:.1f}min)")
+
+        return lm
+
+    def do(self, document: dict) -> dict:
+        lines = self.get_lines(document)
+        model = self.get_lm(document.get("language"))
+        if not lines or not model:
+            return document
+
+        doc_log_score, doc_length = 0, 0
+        for line in lines:
+            if self.normalize:
+                line = text_normalizer.normalize(line)
+            log_score = model.score(line)
+            length = len(line.split()) + 1
+            doc_log_score += log_score
+            doc_length += length
+
+        document[self.output_field] = round(pp(doc_log_score, doc_length), 1)
+        return document
+
+    def summary(self):
+        delay = time.time() - self.start_time
+        h = delay / 3600
+        s = self.n_lines / delay
+
+        summ = super().summary()
+        summ.append(f"Processed {self.n_lines:_} lines in {h:.2}h ({s:.1} lines/s).")
+        return summ
+
+
+class SentencesLM(DocLM):
+    """Returns the score of each individual paragraph."""
+
+    def do(self, document: dict) -> Optional[str]:  # type: ignore
+        lines = self.get_lines(document)
+        model = self.get_lm(document.get("language"))
+        if not lines or not model:
+            return None
+
+        sentences = []
+        for line in lines:
+            if self.normalize:
+                line = text_normalizer.normalize(line)
+            log_score = model.score(line)
+            length = len(line.split()) + 1
+
+            sentences.append(f"{pp(log_score, length)}\t{line}")
+
+        return "\n".join(sentences)
+
+
+class PerplexityBucket(jsonql.Transformer):
+    def __init__(
+        self, cutoff_csv: Path, percentile_head: int = 30, percentile_tail: int = 60
+    ):
+        super().__init__()
+        self.cutoff_csv = cutoff_csv
+        self.percentile_head = percentile_head
+        self.percentile_tail = percentile_tail
+        self.cutoffs: Dict[str, Tuple[float, float]] = {}
+
+    def _prepare(self) -> None:
+        cutoffs = pd.read_csv(self.cutoff_csv, index_col=0)
+        self.cutoffs = {
+            l: (cutoffs[l][self.percentile_head], cutoffs[l][self.percentile_tail])
+            for l in cutoffs.columns
+        }
+
+    def get_bucket(self, doc: dict) -> str:
+        perplexity = doc.get("perplexity", -1)
+        lang = doc.get("language")
+        if lang not in self.cutoffs or perplexity < 0:
+            return "all"
+
+        pp_head, pp_tail = self.cutoffs[lang]
+        if perplexity < pp_head:
+            return "head"
+        if perplexity < pp_tail:
+            return "middle"
+        return "tail"
+
+    def do(self, doc: dict) -> dict:
+        doc["bucket"] = self.get_bucket(doc)
+        return doc
+
+
+class DropKeys(jsonql.Transformer):
+    def __init__(self, *keys):
+        super().__init__()
+        self.keys = keys
+
+    def do(self, document: dict) -> Optional[dict]:
+        if not document:
+            return None
+
+        for key in self.keys:
+            document.pop(key, None)
+        return document
+
+
+class RemoveSmall(jsonql.Transformer):
+    def __init__(self, field, min_len):
+        super().__init__()
+        self.field = field
+        self.min_len = min_len
+        self.removed = 0
+
+    def do(self, document: dict) -> Optional[dict]:
+        if not document:
+            return None
+
+        content = document.get(self.field)
+        if not content or len(content) < self.min_len:
+            self.removed += 1
+            return None
+        return document
+
+    def summary(self):
+        r, n = self.removed, self.processed
+        ratio = r / n if n else 0
+        return [f"Removed {r} small documents out of {n} ({ratio:.1%})"]
+
+
+def perplexity_to_bin(file: Path, output: Path, models, tok_field: str):
+    pp_field = "perplexity"
+    lm = DocLM(models, tok_field, output_field=pp_field)
+    stats: List[float] = []
+    max_stats = 1_000_000
+    batch_size = 100_000
+    i = 0
+    batch = []
+    with open(output, "wb") as o:
+        for doc in jsonql.read_jsons(file):
+            i += 1
+            pp = lm(doc)[pp_field]
+            if len(stats) < max_stats:
+                stats.append(pp)
+            batch.append(pp)
+            if len(batch) >= batch_size:
+                np.array(batch, dtype=np.float32).tofile(o)
+                batch = []
+        if len(batch) > 0:
+            np.array(batch, dtype=np.float32).tofile(o)
+
+
+if __name__ == "__main__":
+    args = get_args()
+    output = Path(args["output"])
+    if output.suffix == ".bin":
+        perplexity_to_bin(args["file"], output, args["models"], args["field"])
+    else:
+        jsonql.run_pipe(DocLM, args)

cc-multilingual-main/cc_net/build/lib/cc_net/process_wet_file.py

@@ -0,0 +1,292 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import contextlib
+import functools
+import logging
+import re
+import tempfile
+import time
+import urllib.request
+from pathlib import Path
+from typing import ContextManager, Iterable, Iterator, List, Optional, Sequence
+from urllib.parse import urlparse
+
+import func_argparse
+from bs4 import BeautifulSoup  # type: ignore
+
+from cc_net import jsonql
+
+WET_URL_ROOT = "https://data.commoncrawl.org"
+
+
+logger = logging.getLogger(__name__)
+
+
+def cc_wet_paths_url(dump_id: str) -> str:
+    return "/".join([WET_URL_ROOT, "crawl-data", "CC-MAIN-" + dump_id, "wet.paths.gz"])
+
+
+@functools.lru_cache()
+def cc_segments(dump_id: str, cache_dir: Path = None) -> List[str]:
+    wet_paths = cc_wet_paths_url(dump_id)
+    cache_dir = cache_dir or jsonql._tmp_dir()
+    wet_paths_cache = cache_dir / f"wet_{dump_id}.paths.gz"
+    f = jsonql.open_remote_file(wet_paths, cache=wet_paths_cache)
+    return [segment.strip() for segment in f]
+
+
+def list_dumps() -> List[str]:
+    home_page = BeautifulSoup(
+        urllib.request.urlopen("http://index.commoncrawl.org/"), features="html.parser"
+    )
+    dumps = [a.get("href").strip("/") for a in home_page.findAll("a")]
+    dumps = [a[8:] for a in dumps if re.match(r"^CC-MAIN-\d\d\d\d-\d\d$", a)]
+
+    return sorted(dumps)
+
+
+def ls():
+    for dump in list_dumps():
+        print(dump, "->", cc_wet_paths_url(dump))
+
+
+def parse_doc(headers: List[str], doc: List[str]) -> Optional[dict]:
+    """Headers format is:
+    WARC/1.0
+    WARC-Type: conversion
+    WARC-Target-URI: [url]
+    WARC-Date: [crawldate: 2019-02-15T19:15:59Z]
+    WARC-Record-ID: <urn:uuid:8865156e-d5f1-4734-9c68-4b46eaf2bb7e>
+    WARC-Refers-To: <urn:uuid:340152e2-65cf-4143-b522-8ce4e2d069d7>
+    WARC-Block-Digest: sha1:S3DTWCONT2L6ORTGCY2KXEZ37LNBB7V2
+    Content-Type: text/plain
+    Content-Length: 7743
+    """
+    if not headers or not doc:
+        return None
+
+    try:
+        warc_type = headers[1].split()[1]
+        if warc_type != "conversion":
+            return None
+        url = headers[2].split()[1]
+        date = headers[3].split()[1]
+        digest = headers[6].split()[1]
+        length = 0
+        for h in headers:
+            if(h != "" and h.split()[0] == "Content-Length:"):
+                length = int(h.split()[1])
+                break
+
+    except Exception as e:
+        logger.warning("Can't parse header:", e, headers, doc)
+        return None
+
+    # Docs are separated by two empty lines.
+    last = None
+    if not doc[-1] and not doc[-2]:
+        last = -2
+    title, doc = doc[0], doc[1:last]
+
+    return {
+        "url": url,
+        "date_download": date,
+        "digest": digest,
+        "length": length,
+        "nlines": len(doc),
+        "source_domain": urlparse(url).netloc,
+        "title": title,
+        "raw_content": "\n".join(doc),
+    }
+
+
+def group_by_docs(warc_lines: Iterable[str]) -> Iterable[dict]:
+    doc: List[str] = []
+    headers, read_headers = [], True
+    for warc in warc_lines:
+        warc = warc.strip()
+        if read_headers:
+            headers.append(warc)
+            read_headers = warc != ""
+            continue
+
+        if warc == "WARC/1.0":
+            # We reached the beginning of the new doc.
+            parsed = parse_doc(headers, doc)
+            if parsed is not None:
+                yield parsed
+            headers, doc, read_headers = [warc], [], True
+            continue
+
+        doc.append(warc)
+
+    # Return the last document
+    if doc:
+        parsed = parse_doc(headers, doc)
+        if parsed is not None:
+            yield parsed
+
+
+def parse_warc_file(lines: Iterable[str], min_len: int = 1) -> Iterator[dict]:
+    n_doc = 0
+    n_ok = 0
+    for doc in group_by_docs(lines):
+        n_doc += 1
+        if not doc or len(doc["raw_content"]) < min_len:
+            continue
+        n_ok += 1
+        yield doc
+    if n_doc > 0:
+        logger.info(f"Kept {n_ok:_d} documents over {n_doc:_d} ({n_ok / n_doc:.1%}).")
+    else:
+        logger.info(f"Found no documents")
+
+
+def dl(
+    dump: str,
+    shard: int,
+    num_shards: int,
+    output: Path = None,
+    num_segments_per_shard: int = 0,
+):
+    """Download a shard of the common crawl, and export it to json.
+
+    Arguments:
+        output: filename of the output file
+        dump: CC dump id
+        shard: id of the shard
+        num_shards: total number of shards
+        num_segments_per_shard: manual control of the number of segment per shard.
+    """
+    reader = CCShardReader(dump, shard, num_shards, num_segments_per_shard)
+    jsonql.run_pipes(inputs=reader, output=output)
+    logger.info(f"Done. {output} is ready.")
+
+
+class CCSegmentsReader(Iterable[dict]):
+    def __init__(
+        self, segments: Sequence[str], min_len: int = 0, cache_dir: Path = None
+    ):
+        self._segments = segments
+        self.min_len = min_len
+        if cache_dir is not None:
+            cache_dir = Path(cache_dir)
+            cache_dir.mkdir(exist_ok=True)
+        self.cache_dir = cache_dir
+        self.retrieved_segments = 0
+
+    def segment_url(self, segment: str):
+        return "/".join((WET_URL_ROOT, segment))
+
+    @property
+    def segments(self) -> Sequence[str]:
+        return self._segments
+
+    def open_segment(self, segment: str) -> Iterable[str]:
+        url = self.segment_url(segment)
+        file: Optional[Path] = None
+        if self.cache_dir:
+            file = self.cache_dir / segment.split("/")[-1]
+        if not file or not file.exists():
+            self.retrieved_segments += 1
+
+        return jsonql.open_remote_file(url, cache=file)
+
+    def __iter__(self) -> Iterator[dict]:
+        n = len(self.segments)
+        for i, segment in enumerate(self.segments):
+            start = time.time()
+            # TODO: start downloading the next segment in the background
+            for doc in parse_warc_file(self.open_segment(segment), self.min_len):
+                doc["cc_segment"] = segment
+                yield doc
+
+            if i + 1 >= n:
+                continue
+            end = time.time()
+            delay = (end - start) / 3600 * (n - 1 - i)
+            logger.info(
+                f"Parsed {i + 1} / {n} files. Estimated remaining time: {delay:.1f}h"
+            )
+
+
+class CCShardReader(CCSegmentsReader):
+    def __init__(
+        self,
+        dump: str,
+        shard: int,
+        num_shards: int = -1,
+        num_segments_per_shard: int = 40,
+        min_len: int = 300,
+        cache_dir: Path = None,
+    ):
+        """Downloads a shard of Common Crawl, and yields dict.
+
+        Arguments:
+            dump: CC dump id
+            shard: id of the shard
+            num_shards: total number of shards
+            num_segments_per_shard: if set will limit the number of files by shard.
+                Useful for testing.
+        """
+        super().__init__([], min_len=min_len, cache_dir=cache_dir)
+        self.dump = dump
+        self.shard = shard
+        assert num_shards > 0 or num_segments_per_shard > 0
+        self.num_shards = num_shards
+        self.num_segments_per_shard = num_segments_per_shard
+
+    @property
+    def segments(self) -> Sequence[str]:
+        # Delaying the initialization allows to delay the looking up of the WET files
+        if self._segments:
+            return self._segments
+        segments = cc_segments(self.dump, self.cache_dir)
+        n = len(segments)
+        if self.num_shards < 0:
+            self.num_shards = n // self.num_segments_per_shard
+        i_min = (self.shard * n) // self.num_shards
+        i_max = ((self.shard + 1) * n) // self.num_shards
+        if self.num_segments_per_shard > 0:
+            i_max = min(i_max, i_min + self.num_segments_per_shard)
+        self._segments = segments[i_min:i_max]
+        return self._segments
+
+
+def _tmp(prefix: str = None, suffix: str = None, dir: Path = None) -> Path:
+    _, tmp_path = tempfile.mkstemp(prefix=prefix, suffix=suffix, dir=dir)
+    return Path(tmp_path)
+
+
+@contextlib.contextmanager
+def timer(name: str = "-"):
+    start = time.time()
+    yield None
+    delay = time.time() - start
+    print(f"{name} took {delay:.1f}s")
+
+
+def benchmark(tmp_path: Path):
+    segments = [
+        "crawl-data/CC-MAIN-2019-09/segments/1550249406966.99/wet/CC-MAIN-20190222220601-20190223002601-00441.warc.wet.gz"
+    ]
+    seg_file = tmp_path / "CC-MAIN-20190222220601-20190223002601-00441.warc.wet.gz"
+
+    with timer("from network"):
+        list(CCSegmentsReader(segments))
+
+    with timer("from network, with caching"):
+        list(CCSegmentsReader(segments, cache_dir=tmp_path))
+    assert seg_file.exists()
+
+    with timer("from disk"):
+        CCSegmentsReader(segments, cache_dir=tmp_path)
+    seg_file.unlink()
+
+
+if __name__ == "__main__":
+    func_argparse.main(ls, dl)

cc-multilingual-main/cc_net/build/lib/cc_net/regroup.py

@@ -0,0 +1,122 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import logging
+import subprocess
+from pathlib import Path
+from typing import List
+
+import func_argparse
+import numpy as np
+
+from cc_net import jsonql
+
+
+def get_index(file: Path) -> Path:
+    return file.parent / (file.name + ".index")
+
+
+def _get_tmp(output: Path) -> Path:
+    return output.parent / (output.stem + ".tmp" + output.suffix)
+
+
+def reshard(
+    inputs: List[Path],
+    output: Path,
+    tmp: Path = None,
+    free_original: bool = False,
+    rm_original: bool = False,
+) -> Path:
+    """Read the given files and concatenate them to the output file.
+
+    Can remove original files on completion, or just write dummy content into them to free disk.
+    """
+    if tmp is None:
+        tmp = _get_tmp(output)
+    logging.info(f"Resharding {inputs} to {tmp}, will move later to {output}")
+    jsonql.run_pipes(file=inputs, output=tmp)
+    tmp.replace(output)
+    tmp_index = get_index(tmp)
+    if tmp_index.exists():
+        tmp_index.replace(get_index(output))
+
+    if not (free_original or rm_original):
+        return output
+
+    for _input in inputs:
+        if rm_original:
+            _input.unlink()
+        elif free_original:
+            # Overwrite the previous file.
+            # This frees up disk space and allows doit to properly track the success.
+            _input.write_text(f"Resharded into {output}")
+        if get_index(_input).is_file():
+            get_index(_input).unlink()
+
+    return output
+
+
+def fast_reshard(
+    inputs: List[Path],
+    output: Path,
+    tmp: Path = None,
+    free_original: bool = False,
+    rm_original: bool = False,
+) -> Path:
+    """Same as reshard but don't re-compress the output.
+
+    This will lead to a bigger output file, especially if the shards are very small.
+    """
+    if tmp is None:
+        tmp = _get_tmp(output)
+    with open(tmp, "wb") as o:
+        subprocess.run(["cat"] + [str(f) for f in inputs], stdout=o)
+
+    tmp.replace(output)
+    indexes_files = [get_index(i) for i in inputs]
+    existing_indexes = sum(i.exists() for i in indexes_files)
+    assert (
+        existing_indexes == len(indexes_files) or existing_indexes == 0
+    ), "some indexes don't exist."
+    if existing_indexes > 0:
+        indexes = [np.load(idx) for idx in indexes_files]
+        for i in range(len(indexes) - 1):
+            indexes[i + 1] += indexes[i][-1]
+        with open(str(output) + ".index", "wb") as o:
+            np.save(o, np.concatenate(indexes))
+
+    if not (free_original or rm_original):
+        return output
+
+    for _input in inputs:
+        if rm_original:
+            _input.unlink()
+        elif free_original:
+            # Overwrite the previous file.
+            # This frees up disk space and allows doit to properly track the success.
+            _input.write_text(f"Resharded into {output}")
+        if get_index(_input).is_file():
+            get_index(_input).unlink()
+
+    return output
+
+
+def determine_groups(
+    inputs: List[Path], target_size: int = 4 * 1024 ** 3
+) -> List[List[Path]]:
+    if len(inputs) == 0:
+        return []
+
+    sample = inputs[:10]
+    typical_size = sum(s.stat().st_size for s in sample) / len(sample)
+    group_size = min(target_size // typical_size, len(inputs))
+    group_size = max(group_size, 1)
+
+    return jsonql.grouper(inputs, group_size)
+
+
+if __name__ == "__main__":
+    func_argparse.single_main(reshard)

cc-multilingual-main/cc_net/build/lib/cc_net/text_normalizer.py

@@ -0,0 +1,189 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import re
+import unicodedata
+
+UNICODE_PUNCT = {
+    "，": ",",
+    "。": ".",
+    "、": ",",
+    "„": '"',
+    "”": '"',
+    "“": '"',
+    "«": '"',
+    "»": '"',
+    "１": '"',
+    "」": '"',
+    "「": '"',
+    "《": '"',
+    "》": '"',
+    "´": "'",
+    "∶": ":",
+    "：": ":",
+    "？": "?",
+    "！": "!",
+    "（": "(",
+    "）": ")",
+    "；": ";",
+    "–": "-",
+    "—": " - ",
+    "．": ". ",
+    "～": "~",
+    "’": "'",
+    "…": "...",
+    "━": "-",
+    "〈": "<",
+    "〉": ">",
+    "【": "[",
+    "】": "]",
+    "％": "%",
+    "►": "-",
+}
+
+UNICODE_PUNCT_RE = re.compile(f"[{''.join(UNICODE_PUNCT.keys())}]")
+
+
+def replace_unicode_punct(text: str) -> str:
+    return "".join((UNICODE_PUNCT.get(c, c) for c in text))
+
+
+def remove_unicode_punct(text: str) -> str:
+    """More aggressive version of replace_unicode_punct but also faster."""
+    return UNICODE_PUNCT_RE.sub("", text)
+
+
+def strip_accents(line: str) -> str:
+    """Strips accents from a piece of text."""
+    nfd = unicodedata.normalize("NFD", line)
+    output = [c for c in nfd if unicodedata.category(c) != "Mn"]
+    if len(output) == line:
+        return line
+    return "".join(output)
+
+
+# Build a regex matching all control characters.
+NON_PRINTING_CHARS_RE = re.compile(
+    f"[{''.join(map(chr, list(range(0,32)) + list(range(127,160))))}]"
+)
+DIGIT_RE = re.compile(r"\d")
+PUNCT_OR_NON_PRINTING_CHARS_RE = re.compile(
+    (UNICODE_PUNCT_RE.pattern + NON_PRINTING_CHARS_RE.pattern).replace("][", "")
+)
+
+
+def remove_non_printing_char(text: str) -> str:
+    return NON_PRINTING_CHARS_RE.sub("", text)
+
+
+def normalize_spacing_for_tok(text: str, language: str = "en") -> str:
+    res = (
+        text.replace("\r", "")
+        # remove extra spaces
+        .replace("(", " (")
+        .replace(")", ") ")
+        .replace(" +", " ")
+    )
+    res = re.sub(r"\) ([\.\!\:\?\;\,])", r"\)\1", res)
+    res = res.replace("( ", "(").replace(" )", ")")
+    res = re.sub(r"(\d) \%", r"\1\%", res)
+    res = res.replace(" :", ":").replace(" ;", ";")
+    res = res.replace("`", "'").replace("''", ' " ')
+
+    res = (
+        res.replace("„", '"')
+        .replace("“", '"')
+        .replace("”", '"')
+        .replace("–", "-")
+        .replace("—", " - ")
+        .replace(" +", " ")
+        .replace("´", "'")
+        .replace("([a-z])‘([a-z])", r"\1'\2/")
+        .replace("([a-z])’([a-z])", r"\1'\2/")
+        .replace("‘", '"')
+        .replace("‚", '"')
+        .replace("’", '"')
+        .replace("''", '"')
+        .replace("´´", '"')
+        .replace("…", "...")
+        # French quotes
+        .replace(" « ", ' "')
+        .replace("« ", '"')
+        .replace("«", '"')
+        .replace(" » ", '" ')
+        .replace(" »", '"')
+        .replace("»", '"')
+        # handle pseudo-spaces
+        .replace(" %", "%")
+        .replace("nº ", "nº ")
+        .replace(" :", ":")
+        .replace(" ºC", " ºC")
+        .replace(" cm", " cm")
+        .replace(" ?", "?")
+        .replace(" !", "!")
+        .replace(" ;", ";")
+        .replace(", ", ", ")
+        .replace(" +", " ")
+        .replace("．", ". ")
+    )
+    # English "quotation," followed by comma, style
+    if language == "en":
+        res = re.sub(r"\"([,\.]+)", r"\1\"", res)
+    # Czech is confused
+    elif language == "cs" or language == "cz":
+        pass
+    # German/Spanish/French "quotation", followed by comma, style
+    else:
+        res = res.replace(',"', '",')
+        res = re.sub(
+            r"(\.+)\"(\s*[^<])", r"\"\1\2", res
+        )  # don't fix period at end of sentence
+
+    if (
+        language == "de"
+        or language == "es"
+        or language == "cz"
+        or language == "cs"
+        or language == "fr"
+    ):
+        res = re.sub(r"(\d) (\d)", r"\1,\2", res)
+    else:
+        res = re.sub(r"(\d) (\d)", r"\1.\2", res)
+    return res
+
+
+def normalize(line: str, accent=True, case=True, numbers=True, punct=1) -> str:
+    line = line.strip()
+    if not line:
+        return line
+    if case:
+        line = line.lower()
+    if accent:
+        line = strip_accents(line)
+    if numbers:
+        line = DIGIT_RE.sub("0", line)
+    if punct == 1:
+        line = replace_unicode_punct(line)
+    elif punct == 2:
+        line = remove_unicode_punct(line)
+    line = remove_non_printing_char(line)
+    return line
+
+
+def slow_normalize_for_dedup(line: str) -> str:
+    return normalize(line, accent=False, case=True, numbers=True, punct=2)
+
+
+def normalize_for_dedup(line: str) -> str:
+    line = line.strip()
+    if not line:
+        return line
+    # case
+    line = line.lower()
+    # numbers
+    line = DIGIT_RE.sub("0", line)
+    line = PUNCT_OR_NON_PRINTING_CHARS_RE.sub("", line)
+    return line

cc-multilingual-main/cc_net/cc_net.egg-info/PKG-INFO

@@ -0,0 +1,194 @@
+Metadata-Version: 2.1
+Name: cc_net
+Version: 1.0.0
+Summary: Tools to download and clean Common Crawl
+Home-page: https://github.com/facebookresearch/cc_net
+Author: Guillaume Wenzek
+Author-email: [email protected]
+License: CC-BY-NC-4.0
+Project-URL: Bug Tracker, https://github.com/facebookresearch/cc_net/issues
+Project-URL: Source Code, https://github.com/facebookresearch/cc_net
+Keywords: common crawl dataset
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.7
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: beautifulsoup4>=4.7.1
+Requires-Dist: pandas>=0.23.4
+Requires-Dist: requests>=2.22.0
+Requires-Dist: fasttext>=0.9.1
+Requires-Dist: sentencepiece>=0.1.82
+Requires-Dist: kenlm@ git+https://github.com/kpu/kenlm.git@master
+Requires-Dist: func_argparse>=1.1.1
+Requires-Dist: psutil>=5.6.3
+Requires-Dist: sacremoses
+Requires-Dist: submitit>=1.0.0
+Requires-Dist: typing_extensions
+Provides-Extra: dev
+Requires-Dist: mypy==0.790; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: black==19.3b0; extra == "dev"
+Requires-Dist: isort==5.6.4; extra == "dev"
+Provides-Extra: tools
+Requires-Dist: lxml; extra == "tools"
+Requires-Dist: sentence_splitter; extra == "tools"
+Provides-Extra: getpy
+Requires-Dist: getpy@ git+https://github.com/gwenzek/[email protected] ; extra == "getpy"
+
+# cc_net
+
+Tools to download and clean Common Crawl as introduced in our paper [CCNet](https://arxiv.org/abs/1911.00359).
+
+If you found these resources useful, please consider citing:
+
+```
+@inproceedings{wenzek2020ccnet,
+  title={CCNet: Extracting High Quality Monolingual Datasets from Web Crawl Data},
+  author={Wenzek, Guillaume and Lachaux, Marie-Anne and Conneau, Alexis and Chaudhary, Vishrav and Guzm{\'a}n, Francisco and Joulin, Armand and Grave, {\'E}douard},
+  booktitle={Proceedings of The 12th Language Resources and Evaluation Conference},
+  pages={4003--4012},
+  year={2020}
+}
+```
+
+[![CircleCI](https://circleci.com/gh/facebookresearch/cc_net.svg?style=svg)](https://circleci.com/gh/facebookresearch/cc_net)
+
+
+## Installation
+
+We only tried this on Linux but installation should be possible on MacOS too.
+
+1. Create or simlink a `data` folder to where you want to download the corpus.
+
+2. Run `make install`. This will download some resources and install required packages.
+
+3. If you have a C++ 17 compiler you can also run
+`pip install .[getpy]`, it provides more memory efficient hashset.
+
+4. Install the following tools manually if `make install` failed:
+- `lmplz` and `build_binary` from [KenLM](https://github.com/kpu/kenlm)
+- `spm_train` and `spm_encode` from [Sentence Piece](https://github.com/google/sentencepiece)
+
+## Training Language Models
+
+The `Makefile` is used to train Sentence Piece and LM on Wikipedia data.
+
+* `make help` shows help
+* `make lang=de lm` trains a Sentence Piece and a LM on German Wikipedia
+* `make all_lm` trains the same model than in the paper
+* `make lang=de dl_lm` downloads the LM trained for the paper
+* `make dl_all_lm` downloads all of them
+
+## Pipeline overview
+
+The full mining pipeline is divided in 3 steps:
+
+- `hashes` downloads one Common-Crawl snapshot, and compute hashes for each paragraph
+- `mine` removes duplicates, detects language, run the LM and split by lang/perplexity buckets
+- `regroup` regroup the files created by `mine` in chunks of 4Gb
+
+Each step needs the previous step to be over before starting.
+You can launch the full pipeline using `python -m cc_net`.
+
+* `python -m cc_net --help` shows help
+* `python -m cc_net --dump 2019-13` treats a specific snapshot
+* `python -m cc_net -l my -l gu` 
+restricts to specific languages
+* `python -m cc_net --lm_dir my_lms/` uses custom LMs
+* `python -m cc_net --lang_threshold 0.3` set a specific field in `mine.Config`
+* `python -m cc_net --config test` runs on a tiny subset of a snapshot
+* `python -m cc_net --config config/my_config.json` uses configuration from the given config file
+
+## Reproducing our work
+
+Given the CPU required to run the full pipeline on such a big corpus we share a mapping from url to the information we computed.
+You can reconstruct the corpus used in the paper by using:
+
+```sh
+python -m cc_net --conf reproduce --dump 2019-09
+```
+
+## Extract XLM-R data
+
+[Unsupervised Cross-lingual Representation Learning at Scale (XLM-RoBERTa)](https://arxiv.org/pdf/1911.02116.pdf)
+paper was trained on data extracted by an internal version of cc_net.
+
+Due to the format being a little bit different please use the following command instead:
+
+```sh
+python cc_net/tools/dl_cc_100.py --help
+python cc_net/tools/dl_cc_100.py --outdir data_cc100 --process 8
+```
+
+If you use this version of the data please also consider citing:
+
+```bibtex
+@article{conneau2019unsupervised,
+  title={Unsupervised Cross-lingual Representation Learning at Scale},
+  author={Conneau, Alexis and Khandelwal, Kartikay and Goyal, Naman and Chaudhary, Vishrav and Wenzek, Guillaume and Guzm{\'a}n, Francisco and Grave, Edouard and Ott, Myle and Zettlemoyer, Luke and Stoyanov, Veselin},
+  journal={arXiv preprint arXiv:1911.02116},
+  year={2019}
+}
+```
+
+
+## Adapting to your infrastructure
+
+Given the computation cost of running the full pipeline we distributed the computation
+on a [Slurm](https://slurm.schedmd.com/) cluster using [submitit](https://github.com/facebookincubator/submitit).
+`submitit` will default to spawning processes on your machine if Slurm cluster is found.
+You should tweak `--task_parallelism` to something adapated to your machine.
+Defaults are 512 for mining and 20 for reproducing.
+
+To run the tasks in-process use `--execution debug`.
+
+
+## Output format
+
+Generated files are compressed JSON files. There is one JSON object per line.
+
+__List of fields__:
+
+- url: webpage URL (part of CC)
+- date_download: date of download (part of CC)
+- digest: sha1 digest of the webpage (part of CC)
+- length: number of chars
+- nlines: number of lines
+- source_domain: web domain of the webpage
+- title: page title (part of CC)
+- raw_content: webpage content after deduplication
+- original_nlines: number of lines before deduplication
+- original_length: number of chars before deduplication
+- language: language detected by FastText LID
+- language_score: language score
+- perplexity: perplexity of a LM trained on Wikipedia
+
+__Sample JSON object__:
+```json
+{
+  "url": "http://www.pikespeakhospice.org/members/1420",
+  "date_download": "2019-02-15T18:40:25Z",
+  "digest": "sha1:VQW3KXUOALO543IJGTK2JLVEAN2XXKHI",
+  "length": 752,
+  "nlines": 5,
+  "source_domain": "www.pikespeakhospice.org",
+  "title": "LeeRoy Aragon",
+  "raw_content": "Date Honored: March 2017\nHe was a man of integrity, a hard worker, and a dedicated family man. He loved spending time with family camping, fishing, hunting, boating and just hanging out.\nHis Catholic faith was extremely important to him as he gave of his time and talents to the community. He had many friends through church and the Knights of Columbus. He was a meticulous handyman, and enjoyed building and fixing things and restoring antique furniture to perfection. He was a fan and supported his Colorado Rockies and Denver Broncos. Throughout the years he had devoted four-legged friends (his dogs and a horse named Sunny Boy).\nWe have many cherished memories of him that we will treasure until we are with him again.\n~ Family of LeeRoy F. Aragon",
+  "original_nlines": 7,
+  "original_length": 754,
+  "language": "en",
+  "language_score": 0.99,
+  "perplexity": 255.11,
+}
+```
+
+You can peak at those files using UNIX tools `zcat` and [`jq`](https://stedolan.github.io/jq/manual/), eg:
+`zcat data/mined/2019-09/en_head_0000.json.gz | head -1 | jq .`
+
+`jq` can do some complicated filtering.
+`jsonql.py` provides a Python API with multiprocess support to do more complicated operations like LM scoring of the document.
+
+## License
+
+By contributing to `cc_net`, you agree that your contributions will be licensed
+under the LICENSE file in the root directory of this source tree.

cc-multilingual-main/cc_net/cc_net.egg-info/SOURCES.txt

@@ -0,0 +1,33 @@
+README.md
+pyproject.toml
+setup.py
+cc_net/__init__.py
+cc_net/__main__.py
+cc_net/dedup.py
+cc_net/execution.py
+cc_net/flat_hash_set.py
+cc_net/get_wiki_cirrus.py
+cc_net/jsonql.py
+cc_net/mine.py
+cc_net/minify.py
+cc_net/perplexity.py
+cc_net/process_wet_file.py
+cc_net/regroup.py
+cc_net/split_by_lang.py
+cc_net/text_normalizer.py
+cc_net/tokenizer.py
+cc_net.egg-info/PKG-INFO
+cc_net.egg-info/SOURCES.txt
+cc_net.egg-info/dependency_links.txt
+cc_net.egg-info/requires.txt
+cc_net.egg-info/top_level.txt
+cc_net/data/cutoff.csv
+cc_net/data/test_stats.json
+tests/test_dedup.py
+tests/test_flat_hash_set.py
+tests/test_jsonql.py
+tests/test_minify.py
+tests/test_normalizer.py
+tests/test_parse_wet_file.py
+tests/test_regroup.py
+tests/test_transformer.py

cc-multilingual-main/cc_net/cc_net.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cc-multilingual-main/cc_net/cc_net.egg-info/requires.txt

@@ -0,0 +1,24 @@
+beautifulsoup4>=4.7.1
+pandas>=0.23.4
+requests>=2.22.0
+fasttext>=0.9.1
+sentencepiece>=0.1.82
+kenlm@ git+https://github.com/kpu/kenlm.git@master
+func_argparse>=1.1.1
+psutil>=5.6.3
+sacremoses
+submitit>=1.0.0
+typing_extensions
+
+[dev]
+mypy==0.790
+pytest
+black==19.3b0
+isort==5.6.4
+
+[getpy]
+getpy@ git+https://github.com/gwenzek/[email protected]
+
+[tools]
+lxml
+sentence_splitter

cc-multilingual-main/cc_net/cc_net.egg-info/top_level.txt

@@ -0,0 +1 @@
+cc_net

cc-multilingual-main/cc_net/tests/__init__.py

@@ -0,0 +1,6 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+#

cc-multilingual-main/cc_net/tests/conftest.py

@@ -0,0 +1,19 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import pytest
+
+
+def _request_is_disabled(self, *args, **kwargs):
+    raise Exception(
+        f"Your code tried to call 'request' with: {args}, {kwargs}. Unit test aren't allowed to reach internet."
+    )
+
+
+@pytest.fixture(autouse=True)
+def no_requests(monkeypatch):
+    """Remove requests.sessions.Session.request for all tests."""
+    monkeypatch.setattr("requests.sessions.Session.request", _request_is_disabled)

cc-multilingual-main/cc_net/tests/data/sample.warc.txt

@@ -0,0 +1,66 @@
+WARC/1.0
+WARC-Type: warcinfo
+WARC-Date: 2019-03-27T06:10:48Z
+WARC-Filename: CC-MAIN-20190318132220-20190318153634-00064.warc.wet.gz
+WARC-Record-ID: <urn:uuid:d711dd43-8280-457b-9566-530ef6ea5d43>
+Content-Type: application/warc-fields
+Content-Length: 370
+
+Software-Info: ia-web-commons.1.1.9-SNAPSHOT-20190314010907
+Extracted-Date: Wed, 27 Mar 2019 06:10:48 GMT
+robots: checked via crawler-commons 0.11-SNAPSHOT (https://github.com/crawler-commons/crawler-commons)
+isPartOf: CC-MAIN-2019-13
+operator: Common Crawl Admin ([email protected])
+description: Wide crawl of the web for March 2019
+publisher: Common Crawl
+
+WARC/1.0
+WARC-Type: conversion
+WARC-Target-URI: http://sample_english.com
+WARC-Date: 2019-03-18T00:00:00Z
+WARC-Record-ID: <urn:uuid:cd61b0b3-d9b0-466c-9a5e-99c191f8d2e1>
+WARC-Refers-To: <urn:uuid:eb4541d2-5ad0-4ed0-91a6-34380636d506>
+WARC-Block-Digest: sha1:XQZHW7QWIG54HVAV3KPRW6MK5ILDNCER
+Content-Type: text/plain
+Content-Length: 353
+
+Famous Mark Twain Quotes
+Don't part with your illusions. When they are gone you may still exist, but you have ceased to live.
+Education: that which reveals to the wise, and conceals from the stupid, the vast limits of their knowledge.
+
+Facts are stubborn things, but statistics are more pliable.
+Fiction is obliged to stick to possibilities. Truth isn't.
+
+WARC/1.0
+WARC-Type: conversion
+WARC-Target-URI: http://sample_chinese.zh
+WARC-Date: 2019-03-18T00:00:01Z
+WARC-Record-ID: <urn:uuid:cd61b0b3-d9b0-466c-9a5e-99c191f8d2e1>
+WARC-Refers-To: <urn:uuid:eb4541d2-5ad0-4ed0-91a6-34380636d506>
+WARC-Block-Digest: sha1:Y4E6URVYGIAFNVRTPZ5S3J64RTZTP6HJ
+Content-Type: text/plain
+Content-Length: 109
+
+馬克·吐溫名言
+不要放棄你的幻想。 當它們消失後，您可能仍然存在，但您已經不復存在。
+教育：向智者揭示並從愚蠢者中隱藏其知識的巨大局限的教育。
+事實是固執的東西，但統計數字卻比較柔和。
+小說必須堅持可能。 真理不是。
+
+WARC/1.0
+WARC-Type: conversion
+WARC-Target-URI: http://sample_russian.ru
+WARC-Date: 2019-03-18T00:00:02Z
+WARC-Record-ID: <urn:uuid:27dccd48-27b2-4eb0-b10b-a43661cbf0bc>
+WARC-Refers-To: <urn:uuid:5d53cf06-9ccf-4216-917a-89cdc3d50d54>
+WARC-Block-Digest: sha1:RBW57C753IE4CHCOZCMS2BHMHBEGXKXL
+Content-Type: text/plain
+Content-Length: 355
+
+Цитаты знаменитого Марка Твена
+Не расставайся со своими иллюзиями. Когда они исчезнут, вы все еще можете существовать, но вы перестали жить.
+Образование: то, что открывает мудрым и скрывает от глупых обширные границы их знаний.
+Факты - упрямые вещи, но статистика более податлива.
+Художественная литература обязана придерживаться возможностей. Правда нет.
+
+

cc-multilingual-main/cc_net/tests/test_dedup.py

@@ -0,0 +1,245 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import json
+from pathlib import Path
+from typing import Iterable, Sequence
+
+from cc_net import dedup, jsonql
+from cc_net.dedup import str_hash
+from cc_net.flat_hash_set import FlatHashSet
+
+
+def text(*args: str) -> str:
+    return "\n".join(args)
+
+
+def write_docs(file: Path, docs: Iterable[Sequence[str]]):
+    file.parent.mkdir(exist_ok=True)
+    with open(file, "w") as f:
+        for sentences in docs:
+            doc = dict(text=text(*sentences))
+            print(json.dumps(doc), file=f)
+
+
+def as_dict(hash_set):
+    if not isinstance(hash_set, dict):
+        hash_set = {k: v for (k, v) in hash_set.items()}
+    return hash_set
+
+
+def load_hashes(file):
+    results = dedup.FlatHashSet()
+    results.load(file)
+    return as_dict(results)
+
+
+LENGTHS = ["original_length", "length"]
+
+
+def assert_documents_equal(expected, actual, ignoring={}):
+    expected = [{k: doc[k] for k in doc if k not in ignoring} for doc in expected]
+    actual = [{k: doc[k] for k in doc if k not in ignoring} for doc in expected]
+    assert expected == actual
+
+
+def test_simple_dedup(tmp_path: Path) -> None:
+    write_docs(
+        tmp_path / "docs.json",
+        [
+            ["_Hello", "_World", "I'm so original"],
+            ["_world", "I'm originaler", "_Hello"],
+        ],
+    )
+    results = list(dedup.deduplicate(tmp_path / "docs.json", field="text"))
+    expected = [
+        # First document is untouched
+        dict(
+            text=text("_Hello", "_World", "I'm so original"),
+            original_nlines=3,
+            nlines=3,
+            line_ids=[0, 1, 2],
+        ),
+        # Second documents loses several lines
+        dict(text="I'm originaler", original_nlines=3, nlines=1, line_ids=[1]),
+    ]
+
+    assert_documents_equal(expected, results, ignoring=LENGTHS)
+
+
+def test_dedup_with_dump(tmp_path: Path):
+    hashes = tmp_path / "hashes.bin"
+    documents = [
+        dict(text=text("_Hello", "_World", "I'm so original")),
+        dict(text=text("_world", "I'm originaler", "_Hello")),
+    ]
+    collector = dedup.HashesCollector(field="text", output=hashes)
+    list(collector.map(documents))
+    results = load_hashes(hashes)
+    expected = {
+        str_hash(l): l.startswith("_")
+        for l in ["_hello", "_world", "i'm so original", "i'm originaler"]
+    }
+    assert expected == results
+
+
+def test_dedup_with_np_dump(tmp_path: Path):
+    hashes = tmp_path / "hashes.bin"
+    documents = [
+        dict(text=text("_Hello", "_World", "I'm so original")),
+        dict(text=text("_world", "I'm originaler", "_Hello")),
+    ]
+    with dedup.HashesCollector(field="text", output=hashes) as d:
+        list(d.map(documents))
+
+    results = FlatHashSet()
+    results.load_np(hashes)
+    expected = set(
+        str_hash(l) for l in ["_hello", "_world", "i'm so original", "i'm originaler"]
+    )
+    assert expected == set(results.keys())
+
+
+def test_dedup_from_hashes(tmp_path: Path):
+    documents = [
+        dict(text=text("_Hello", "World", "I'm so original")),
+        dict(text=text("Good morning", "World", "I'm originaler")),
+    ]
+    seen = ["_hello", "i'm originaler", "world"]
+    hashes = [str_hash(h) for h in seen]
+    h = dedup.FlatHashSet()
+    h.add(hashes)
+    # Note: 'world' appears only once and won't be treated as a duplicate.
+    h.add(hashes[:-1])
+    h.dump(tmp_path / "hashes.bin")
+
+    results = list(
+        dedup.DuplicatesRemover("text", [tmp_path / "hashes.bin"]).map(documents)
+    )
+    expected = [
+        dict(
+            text=text("World", "I'm so original"),
+            original_nlines=3,
+            nlines=2,
+            line_ids=[1, 2],
+        ),
+        dict(
+            text=text("Good morning", "World"),
+            original_nlines=3,
+            nlines=2,
+            line_ids=[0, 1],
+        ),
+    ]
+
+    assert_documents_equal(expected, results, ignoring=LENGTHS)
+
+
+def test_dedup_fast(tmp_path: Path):
+    data = tmp_path / "data"
+    part_0 = [["Hello", "_World", "I'm so original"]]
+    write_docs(data / "part_0.json", part_0)
+    part_1 = [["Good morning", "_World", "I'm originaler"]]
+    write_docs(data / "part_1.json", part_1)
+    parts = [data / "part_0.json", data / "part_1.json"]
+
+    res = tmp_path / "res"
+    res.mkdir()
+    h = tmp_path / "hashes.bin"
+    field = "text"
+    jsonql.run_pipes(dedup.HashesCollector(field, output=h), file=parts)
+    for part in parts:
+        jsonql.run_pipes(
+            dedup.DuplicatesRemover(field, [h]), file=part, output=res / part.name
+        )
+        jsonql.run_pipes(
+            dedup.DuplicatesRemover(field, [h]), file=part, output=res / part.name
+        )
+
+    results_0 = list(jsonql.read_jsons(res / "part_0.json"))
+    expected_0 = [
+        dict(
+            text=text("Hello", "I'm so original"),
+            original_nlines=3,
+            nlines=2,
+            line_ids=[0, 2],
+        )
+    ]
+    assert_documents_equal(expected_0, results_0, ignoring=LENGTHS)
+
+    results_1 = list(jsonql.read_jsons(res / "part_1.json"))
+    expected_1 = [
+        dict(
+            text=text("Good morning", "I'm originaler"),
+            original_nlines=3,
+            nlines=2,
+            line_ids=[0, 2],
+        )
+    ]
+
+    assert_documents_equal(expected_1, results_1, ignoring=LENGTHS)
+
+    words = [w for part in [part_0, part_1] for doc in part for w in doc]
+    expected = {str_hash(s.lower()): s.startswith("_") for s in words}
+    assert expected == load_hashes(h)
+
+
+def test_remove_duplicates_sharded(tmp_path: Path):
+    data = tmp_path / "data"
+    part_0 = [["Hello", "_World", "I'm so original"]]
+    write_docs(data / "part_0.json", part_0)
+    part_1 = [["_Good morning", "_World", "I'm originaler"]]
+    write_docs(data / "part_1.json", part_1)
+
+    h = tmp_path / "hashes"
+    h.mkdir()
+    h0 = FlatHashSet()
+    h0.add([str_hash(s.lower()) for doc in part_0 for s in doc])
+    h0.add([str_hash("_world")])
+    h0.dump(h / "part_0.bin")
+    assert {
+        str_hash("hello"): False,
+        str_hash("_world"): True,
+        str_hash("i'm so original"): False,
+    } == as_dict(h0)
+
+    h1 = FlatHashSet()
+    h1.add([str_hash(s.lower()) for doc in part_1 for s in doc])
+    h1.add([str_hash("_good morning")])
+    h1.dump(h / "part_1.bin")
+    assert {
+        str_hash("_good morning"): True,
+        str_hash("_world"): False,
+        str_hash("i'm originaler"): False,
+    } == as_dict(h1)
+
+    res = tmp_path / "res"
+    res.mkdir()
+    # dedup.DISABLE_MULTI_PROCESSING = True  # Simplifies debugging
+    dedup.remove_duplicates_sharded(
+        files=[data / "part_0.json", data / "part_1.json"],
+        outputs=[res / "part_0.json", res / "part_1.json"],
+        field="text",
+        hashes_dir=h,
+    )
+
+    results_0 = list(jsonql.read_jsons(res / "part_0.json"))
+    expected_0 = [
+        dict(
+            text=text("Hello", "I'm so original"),
+            original_nlines=3,
+            nlines=2,
+            line_ids=[0, 2],
+        )
+    ]
+    assert_documents_equal(expected_0, results_0, ignoring=LENGTHS)
+
+    # First pass removes "_world", second "_good morning".
+    results_1 = list(jsonql.read_jsons(res / "part_1.json"))
+    expected_1 = [
+        dict(text=text("I'm originaler"), original_nlines=3, nlines=1, line_ids=[2])
+    ]
+
+    assert_documents_equal(expected_1, results_1, ignoring=LENGTHS)

cc-multilingual-main/cc_net/tests/test_flat_hash_set.py

@@ -0,0 +1,78 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import numpy as np
+import pytest
+
+from cc_net.flat_hash_set import HASH_TYPE, FlatHashSet, NaiveHashSet
+
+
+def as_dict(flat_hash_set) -> dict:
+    return {k: v for (k, v) in flat_hash_set.items()}
+
+
+need_getpy = pytest.mark.skipif(
+    FlatHashSet == NaiveHashSet, reason="getpy isn't installed"
+)
+
+
+def same_behavior(test_case):
+    def run_case():
+        naive = as_dict(test_case(FlatHashSet))
+        flat = as_dict(test_case(NaiveHashSet))
+        assert naive == flat
+
+    return need_getpy(run_case)
+
+
+@same_behavior
+def test_setitem(hash_set_cls):
+    h = hash_set_cls()
+    h[np.arange(10, dtype=h.dtype)] = np.zeros(10, dtype=np.uint8)
+    h[np.arange(5, dtype=h.dtype)] = np.ones(5, dtype=np.uint8)
+    return h
+
+
+@same_behavior
+def test_add_dup(hash_set_cls):
+    h = hash_set_cls()
+    h.add(np.arange(10, dtype=h.dtype))
+    h.add(np.arange(5, dtype=h.dtype))
+
+    expected = {i: i < 5 for i in range(10)}
+    assert expected == as_dict(h), f"add_dup with {hash_set_cls.__name__}"
+    return h
+
+
+@need_getpy
+def test_gp_dict():
+    import getpy as gp  # type: ignore
+
+    h = gp.Dict(HASH_TYPE, np.uint8)
+    h[np.arange(10, dtype=HASH_TYPE)] = np.zeros(10, dtype=np.uint8)
+    h[np.arange(5, dtype=HASH_TYPE)] = np.ones(5, dtype=np.uint8)
+    expected = {i: i < 5 for i in range(10)}
+    assert expected == as_dict(h)
+
+
+def check_reload(h, dump, load, tmp_path):
+    dump_path = tmp_path / dump.__name__
+    dump(h, dump_path)
+    h2 = type(h)()
+    load(h2, dump_path)
+    assert as_dict(h) == as_dict(h2)
+
+
+@pytest.mark.parametrize("hash_set_cls", [FlatHashSet, NaiveHashSet])
+def test_loading(tmp_path, hash_set_cls):
+    h = hash_set_cls()
+    x = np.random.randint(0, 2 ** 32, (100,), dtype=h.dtype)
+    h.add(x)
+
+    check_reload(h, hash_set_cls.dump, hash_set_cls.load, tmp_path)
+    check_reload(h, hash_set_cls.dump_np, hash_set_cls.load_np, tmp_path)
+    if hasattr(hash_set_cls, "dump_gp"):
+        check_reload(h, hash_set_cls.dump_gp, hash_set_cls.load_gp, tmp_path)

cc-multilingual-main/cc_net/tests/test_jsonql.py

@@ -0,0 +1,312 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import io
+from pathlib import Path
+from typing import Sequence
+
+import numpy as np
+import pytest
+
+from cc_net import jsonql
+
+
+def bar(small_bar: str) -> str:
+    return small_bar.replace(" ", " " * 10).replace("█", "█" * 10)
+
+
+def get_output(transformer, data, **kwargs):
+    with io.StringIO() as output:
+        # Convert data to a generator so that it's not interpreted as a file list.
+        jsonql.run_pipe(transformer, kwargs, file=(x for x in data), output=output)
+        return output.getvalue()
+
+
+def test_split(tmp_path: Path):
+    data = [
+        dict(text="Hello world", lang="en"),
+        dict(text="Boujour les amis", lang="fr"),
+        dict(text="Rock your boat", lang="en"),
+    ]
+    with jsonql.split(tmp_path / "{lang}.json") as split:
+        list(split.map(data))
+        summary = split.summary()
+    assert "Found 2 splits." in summary
+    en_docs = list(jsonql.read_jsons(tmp_path / "en.json"))
+    assert [data[0], data[2]] == en_docs
+
+    fr_docs = list(jsonql.read_jsons(tmp_path / "fr.json"))
+    assert [data[1]] == fr_docs
+
+
+def test_split_bad_pattern(tmp_path: Path):
+    data = [dict(text="Hello world", lang="en")]
+    with pytest.raises(KeyError):
+        with jsonql.split(tmp_path / "{language}.json") as split:
+            list(split.map(data))
+
+
+def test_histogram():
+    data = [0.1, 0.1, 0.1, 0.1, 0.4, 0.4, 0.9, 0.9]
+    hist, bins = jsonql.histogram(data, bins=8, weights=None)
+    np.testing.assert_almost_equal(bins, [0.1 * x for x in range(1, 10)])
+    np.testing.assert_almost_equal(hist, [4, 0, 0, 2, 0, 0, 0, 2])
+
+    data = [0, 0.1, 0.1, 0.1, 0.1, 0.4, 0.4, 0.8, 0.8, 1]
+    hist, bins = jsonql.histogram(data, bins=10, weights=None)
+    np.testing.assert_almost_equal(bins, [0.1 * x for x in range(11)])
+    np.testing.assert_almost_equal(hist, [1, 4, 0, 0, 2, 0, 0, 0, 2, 1])
+
+
+def test_display_stats():
+    stats = {
+        jsonql.ALL_DOCUMENTS: 100,
+        "title": 80,
+        "title.length": 80 * 50,
+        "text": 100,
+        "text.length": 100 * 1000,
+        "popularity": 8,
+        "popularity.val": [0.1, 0.1, 0.1, 0.1, 0.4, 0.4, 0.9, 0.9],
+    }
+
+    (title,) = jsonql.display_stats(stats, "title")
+    assert "title" in title
+    assert "saw 80 times" in title
+    assert "average length is" in title
+    assert "\n" not in title
+
+    (text,) = jsonql.display_stats(stats, "text")
+    assert "text" in text
+    assert "saw 100 times" in text
+    assert "average length is" in text
+    assert "\n" not in text
+
+    histogram = jsonql.display_stats(
+        stats, "popularity", bins=[x / 10 for x in range(1, 10)]
+    )
+    assert "popularity" in histogram[0]
+    assert "saw 8 times" in histogram[0]
+    assert "histogram is" in histogram[0]
+    assert "0.100 " + bar("████████") in histogram[1]
+    assert "0.400 " + bar("████    ") in histogram[2]
+    assert "0.800 " + bar("████    ") in histogram[3]
+
+    cum_histogram = jsonql.display_stats(stats, "popularity", bins=8, cumulative=True)
+    assert "popularity" in cum_histogram[0]
+    assert "saw 8 times" in cum_histogram[0]
+    assert "histogram is" in cum_histogram[0]
+    assert "0.100 " + bar("████    ") in cum_histogram[1]
+    assert "0.400 " + bar("██████  ") in cum_histogram[2]
+    assert "0.800 " + bar("████████") in cum_histogram[3]
+
+
+def test_describe():
+    def sample(pop):
+        return dict(title="Lorem", text="Lorem ipsum dolor sit amet.", popularity=pop)
+
+    data = [sample(pop) for pop in [0.1, 0.1, 0.1, 0.1, 0.4, 0.4, 0.9, 0.9]]
+    desc = get_output(
+        jsonql.describe, data, columns=None, bins=[x / 10 for x in range(1, 10)]
+    )
+
+    assert "Field title saw 8 times (100.0%), average length is 5" in desc
+    assert "Field text saw 8 times (100.0%), average length is 27" in desc
+    assert "Field popularity saw 8 times (100.0%), histogram is" in desc
+    assert "0.100 " + bar("████████") in desc
+    assert "0.400 " + bar("████    ") in desc
+    assert "0.800 " + bar("████    ") in desc
+
+    desc = get_output(jsonql.describe, data, columns=["text"])
+    assert "Field title saw 8 times (100.0%), average length is 5" not in desc
+    assert "Field text saw 8 times (100.0%), average length is 27" in desc
+    assert "Field popularity, histogram is:" not in desc
+
+
+def test_custom_pipe():
+    def transformer(source, sep=" "):
+        for i, line in enumerate(source):
+            res = f"{i}{sep}{line}"
+            yield res
+
+    data = ["hello", "world"]
+    assert get_output(transformer, data) == "0 hello\n1 world\n"
+    assert get_output(transformer, data, sep="_") == "0_hello\n1_world\n"
+
+
+def test_open_read_write(tmp_path: Path):
+    def _lines(filename: Path) -> Sequence[str]:
+        # jsonql.lines calls open_read
+        return list(jsonql.lines(filename))
+
+    tmp = tmp_path
+    with jsonql.open_write(tmp / "a.txt") as o:
+        print("a", file=o)
+    assert _lines(tmp / "a.txt") == ["a"]
+
+    jsonql.write_jsons([{"a": 1}], tmp / "a.txt")
+    assert _lines(tmp / "a.txt") == ['{"a": 1}']
+
+    with jsonql.open_write(tmp / "a.gz") as o:
+        print("a", file=o)
+    assert _lines(tmp / "a.gz") == ["a"]
+
+    with jsonql.open_write([tmp / "a0.txt", tmp / "a1.txt"]) as o:
+        print("a", file=o)
+    assert _lines(tmp / "a0.txt") == ["a"]
+    assert not (tmp / "a1.txt").is_file()
+
+    with jsonql.open_write([tmp / "b0.txt", tmp / "b1.txt"], max_size="1k") as o:
+        print("0" * 2000, file=o)
+        print("1" * 2000, file=o)
+    assert _lines(tmp / "b0.txt") == ["0" * 2000]
+    assert _lines(tmp / "b1.txt") == ["1" * 2000]
+
+    with jsonql.open_write(tmp / "a_????.json") as o:
+        print("a", file=o)
+    assert _lines(tmp / "a_0000.json") == ["a"]
+    assert not (tmp / "a_0001.json").is_file()
+    assert _lines(tmp / "a_*.json") == ["a"]
+
+    with jsonql.open_write(tmp / "b_??.json", max_size="1k") as o:
+        print("0" * 2000, file=o)
+        print("1" * 2000, file=o)
+    assert _lines(tmp / "b_00.json") == ["0" * 2000]
+    assert _lines(tmp / "b_01.json") == ["1" * 2000]
+    assert _lines(tmp / "b_*.json") == ["0" * 2000, "1" * 2000]
+
+
+def test_split_file(tmp_path: Path):
+    file = tmp_path / "test.txt"
+    content = "Hello\nWorld\n"
+
+    with open(file, "w") as o:
+        o.write(content)
+
+    with jsonql.SplitFile(file, chunk=0, n_chunks=2) as f:
+        assert f.readlines() == ["Hello\n"]
+
+    with jsonql.SplitFile(file, chunk=1, n_chunks=2) as f:
+        assert f.readlines() == ["World\n"]
+
+
+def test_split_file_middle_of_line(tmp_path: Path):
+    file = tmp_path / "test.txt"
+    content = "Hello _|_\nWorld\n"
+    # split is here   ^
+
+    with open(file, "w") as o:
+        o.write(content)
+
+    with jsonql.SplitFile(file, chunk=0, n_chunks=2) as f:
+        assert f.readlines() == ["Hello _|_\n"]
+
+    with jsonql.SplitFile(file, chunk=1, n_chunks=2) as f:
+        assert f.readlines() == ["World\n"]
+
+
+def test_split_file_middle_of_char(tmp_path: Path):
+    file = tmp_path / "test.txt"
+    content = "Hello\U0001F40D\nWorld\n"
+    # split is here       ^^
+
+    with open(file, "w") as o:
+        o.write(content)
+
+    with jsonql.SplitFile(file, chunk=0, n_chunks=2) as f:
+        assert f.readlines() == ["Hello🐍\n"]
+
+    with jsonql.SplitFile(file, chunk=1, n_chunks=2) as f:
+        assert f.readlines() == ["World\n"]
+
+
+def test_blocked_gzip(tmp_path: Path):
+    file = tmp_path / "test.gz"
+    f = str(file)
+    # Each object is 10/11 bytes long. We have 2 of them by block.
+    content = ['{"xx": %d}' % i for i in range(80)]
+    with jsonql.BlockedGzipWriter(file, "wt", block_size="20B") as o:
+        for line in content:
+            print(line, file=o)
+
+    jr = jsonql.JsonReader(strict=True)
+    expected = list(jr.map(content))
+    # read as one file
+    assert expected == list(jsonql.read_jsons(file))
+    # read first block
+    assert expected[:2] == list(jsonql.read_jsons(f + "[0/40]"))
+    # read last block
+    assert expected[-2:] == list(jsonql.read_jsons(f + "[39/40]"))
+
+    readers = jsonql.get_block_readers(file, 9)
+    read_as_several_files = [list(jsonql.read_jsons(r)) for r in readers]
+    # 40 splits of 2 docs, 9 readers -> 5 splits, 10 docs per reader
+    assert list(jsonql.grouper(expected, 10)) == read_as_several_files
+
+
+def test_enter_exit(capsys):
+    class MyTransformer(jsonql.Transformer):
+        def __enter__(self):
+            print("trans: started")
+            self.ready = True
+            return self
+
+        def __exit__(self, *args):
+            print("trans: done")
+
+        def do(self, x):
+            return (x, x)
+
+    def acc(values):
+        print("acc: started")
+        res = 0
+        for (x, _) in values:
+            res += int(x)
+        print("acc: done")
+        yield f"acc: result={res}"
+
+    t = MyTransformer()
+    data = (str(x) for x in range(10))
+    print("pipeline: started")
+    # Print to stdout.
+    jsonql.run_pipes(t, acc, file=data)
+    print("pipeline: done")
+    out = capsys.readouterr().out
+    assert (
+        "\n".join(
+            [
+                "pipeline: started",
+                "trans: started",
+                "acc: started",
+                "acc: done",
+                f"acc: result=45",
+                # Transformers are closed at the very end.
+                "trans: done",
+                "pipeline: done\n",
+            ]
+        )
+        == out
+    )
+
+
+def test_write_to_stdout(capsys):
+    lines = [str(x) for x in range(10)]
+    jsonql.run_pipes(file=iter(lines))
+    out = capsys.readouterr().out
+    assert out == "\n".join(lines) + "\n"
+
+
+def test_write_to_stdout_handle_newlines(capsys):
+    lines = [str(x) + "\n" for x in range(10)]
+    jsonql.run_pipes(file=iter(lines))
+    out = capsys.readouterr().out
+    assert out == "".join(lines)
+
+
+def test_multiprocess(capsys):
+    mult = jsonql.Mapper(lambda x: f"2x = {2 * int(x)}")
+    jsonql.run_pipes(mult, processes=2, file=(str(x) for x in range(10)))
+    out = set(capsys.readouterr().out.strip("\n").split("\n"))
+    assert set(f"2x = {2 * x}" for x in range(10)) == out

cc-multilingual-main/cc_net/tests/test_minify.py

@@ -0,0 +1,153 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import json
+from pathlib import Path
+
+import pytest
+
+import cc_net
+import cc_net.minify as minify
+from cc_net import jsonql, process_wet_file
+from cc_net.minify import (
+    HASH_SIZE,
+    decode_hashes,
+    encode_hashes,
+    encode_line_ids,
+    get_hashes,
+)
+
+
+def test_encode_decode():
+    sentences = ["Hello world !", "Is everyone happy in here ?"]
+    hashes = get_hashes(sentences)
+    assert all([len(h) == HASH_SIZE for h in hashes])
+    hashes_int = [minify._b2i(h) for h in hashes]
+    encoded = encode_hashes(hashes)
+    decoded = decode_hashes(encoded)
+    assert all([len(d) == HASH_SIZE for d in decoded])
+
+    decoded_int = [minify._b2i(d) for d in decoded]
+
+    assert hashes_int == decoded_int
+    assert hashes == decoded
+
+
+def test_minify():
+    doc = {
+        "raw_content": "Hello world !\nIs everyone happy in here ?",
+        "language": "en",
+        "perplexity": 120.0,
+        "line_ids": [0, 4],
+    }
+    expected = {"line_ids": "AAAEAA==", "language": "en", "perplexity": 120.0}
+    minifier = minify.Minifier()
+    assert expected == minifier(doc)
+
+
+@pytest.fixture
+def http_from_disk(monkeypatch):
+    def read_sample_file(url: str, n_retry: int = 3) -> bytes:
+        expected_url = process_wet_file.WET_URL_ROOT + "/crawl-data/sample.warc.wet"
+        assert expected_url == url
+        file = Path(__file__).parent / "data" / "sample.warc.txt"
+        return file.read_bytes()
+
+    monkeypatch.setattr(cc_net.jsonql, "request_get_content", read_sample_file)
+
+
+def test_minify_and_fetch(http_from_disk, tmp_path: Path):
+    full_quotes = """Don't part with your illusions. When they are gone you may still exist, but you have ceased to live.
+Education: that which reveals to the wise, and conceals from the stupid, the vast limits of their knowledge.
+Facts are stubborn things, but statistics are more pliable.
+Fiction is obliged to stick to possibilities. Truth isn't."""
+    # We don't need no education.
+    chosen_quotes = "\n".join(
+        l for l in full_quotes.splitlines() if "Education" not in l
+    )
+
+    cc_doc = {
+        "url": "http://sample_english.com",
+        "date_download": "2019-03-18T00:00:00Z",
+        "digest": "sha1:XQZHW7QWIG54HVAV3KPRW6MK5ILDNCER",
+        "source_domain": "sample_english.com",
+        "title": "Famous Mark Twain Quotes",
+        "raw_content": full_quotes,
+        "cc_segment": "crawl-data/sample.warc.wet",
+        "nlines": 4,
+        "length": 353,
+    }
+
+    ccnet_metadata = {
+        "language": "en",
+        "language_score": 0.99,
+        "perplexity": 151.5,
+        "bucket": "head",
+        "raw_content": chosen_quotes,
+        "nlines": 3,
+        "length": len(chosen_quotes),
+        "original_nlines": 4,
+        "original_length": 353,
+        "line_ids": [0, 2, 3],
+    }
+    ccnet_doc = dict(cc_doc, **ccnet_metadata)
+    mini = minify.Minifier()(ccnet_doc.copy())
+    assert mini is not ccnet_doc
+
+    important_fields = [
+        "url",
+        "digest",
+        "cc_segment",
+        "language",
+        "language_score",
+        "perplexity",
+        "bucket",
+        "line_ids",
+    ]
+    expected = {k: ccnet_doc[k] for k in important_fields}
+    expected["line_ids"] = encode_line_ids(expected["line_ids"])  # type: ignore
+    assert expected == mini
+
+    with jsonql.open_write(tmp_path / "sample.json") as o:
+        print(json.dumps(mini), file=o)
+    fetcher = minify.MetadataFetcher(tmp_path)
+    # line_ids is removed when unminifying
+    ccnet_doc.pop("line_ids")
+    assert ccnet_doc == fetcher(cc_doc)
+
+
+def test_fetch(http_from_disk, tmp_path: Path):
+    mini_docs = [
+        {
+            "url": "http://sample_chinese.com",
+            "digest": "sha1:Y4E6URVYGIAFNVRTPZ5S3J64RTZTP6HJ",
+            "cc_segment": "crawl-data/sample.warc.wet",
+            "line_ids": encode_line_ids([2]),
+            "bucket": "not_that_great",
+        },
+        {
+            "url": "http://sample_english.com",
+            "digest": "sha1:XQZHW7QWIG54HVAV3KPRW6MK5ILDNCER",
+            "cc_segment": "crawl-data/sample.warc.wet",
+            "line_ids": encode_line_ids([3]),
+            "bucket": "top_notch",
+        },
+    ]
+    with jsonql.open_write(tmp_path / "sample.json") as o:
+        for mini in mini_docs:
+            print(json.dumps(mini), file=o)
+
+    fetcher = minify.MetadataFetcher(tmp_path)
+    cc = process_wet_file.CCSegmentsReader(["crawl-data/sample.warc.wet"])
+    docs = [d for d in fetcher.map(cc) if d is not None]
+    assert cc.retrieved_segments == 1
+
+    # Note: documents are retrieved as they are ordered in the .warc.wet file
+    assert [
+        "Facts are stubborn things, but statistics are more pliable.",
+        "事實是固執的東西，但統計數字卻比較柔和。",
+    ] == [d["raw_content"] for d in docs]
+    assert ["top_notch", "not_that_great"] == [d["bucket"] for d in docs]

cc-multilingual-main/cc_net/tests/test_normalizer.py

@@ -0,0 +1,29 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import cc_net.text_normalizer as txt
+
+
+def test_unicode_punct():
+    weird = "，。、„”“«»１」「《》´∶：？！（）；–—．～’…━〈〉【】％"
+    replaced = ',.,""""""""""\'::?!();- - . ~\'...-<>[]%'
+    assert txt.replace_unicode_punct(weird) == replaced
+
+    assert txt.remove_unicode_punct(weird) == ""
+
+
+def test_numbers():
+    weird = "０２３４５６７８９ | 0123456789"
+    normalized = "000000000 | 0000000000"
+    assert txt.normalize(weird, numbers=True) == normalized
+    assert txt.normalize(weird, numbers=False) == weird
+
+
+def test_normalize_for_dedup():
+    weird = "０２３´∶：\x10 | ;012 hèllo"
+    normalized = "000 | ;000 hèllo"
+    assert normalized == txt.slow_normalize_for_dedup(weird)
+    assert normalized == txt.normalize_for_dedup(weird)

cc-multilingual-main/cc_net/tests/test_parse_wet_file.py

@@ -0,0 +1,47 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+from pathlib import Path
+
+from cc_net import process_wet_file
+
+
+def test_parsing():
+    sample = Path(__file__).parent / "data" / "sample.warc.txt"
+    with open(sample) as f:
+        documents = list(process_wet_file.parse_warc_file(f))
+
+    expected_urls = [
+        "http://sample_english.com",
+        "http://sample_chinese.zh",
+        "http://sample_russian.ru",
+    ]
+    assert expected_urls == [d["url"] for d in documents]
+    expected_domains = ["sample_english.com", "sample_chinese.zh", "sample_russian.ru"]
+    assert expected_domains == [d["source_domain"] for d in documents]
+
+    expected_date = [
+        "2019-03-18T00:00:00Z",
+        "2019-03-18T00:00:01Z",
+        "2019-03-18T00:00:02Z",
+    ]
+    assert expected_date == [d["date_download"] for d in documents]
+
+    expected_title = [
+        "Famous Mark Twain Quotes",
+        "馬克·吐溫名言",
+        "Цитаты знаменитого Марка Твена",
+    ]
+    assert expected_title == [d["title"] for d in documents]
+
+    expected_quotes = """Don't part with your illusions. When they are gone you may still exist, but you have ceased to live.
+Education: that which reveals to the wise, and conceals from the stupid, the vast limits of their knowledge.
+
+Facts are stubborn things, but statistics are more pliable.
+Fiction is obliged to stick to possibilities. Truth isn't.
+"""
+
+    assert expected_quotes == documents[0]["raw_content"]

cc-multilingual-main/cc_net/tests/test_regroup.py

@@ -0,0 +1,50 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import time
+
+from cc_net import jsonql, regroup
+
+
+def check_regroup(tmp_path, regroup_fn, check_blocks_boundaries=False):
+    n_shards = 4
+    n_docs = 20
+    shards = [
+        [dict(id=i, shard=s, raw_content="hello world") for i in range(n_docs)]
+        for s in range(n_shards)
+    ]
+    shards_files = [tmp_path / f"{s:04d}.json.gz" for s in range(n_shards)]
+    for shard, shard_file in zip(shards, shards_files):
+        jsonql.run_pipes(inputs=shard, output=shard_file)
+    regroup_file = tmp_path / "regroup.json.gz"
+    start = time.time()
+    regroup_fn(shards_files, regroup_file)
+    duration = time.time() - start
+    print(f"{regroup_fn.__module__}.{regroup_fn.__name__} took {duration}s")
+
+    regrouped = list(jsonql.read_jsons(regroup_file))
+    assert [doc for shard in shards for doc in shard] == regrouped
+
+    readers = jsonql.get_block_readers(regroup_file, n_shards)
+    if not check_blocks_boundaries:
+        assert [doc for shard in shards for doc in shard] == [
+            doc for reader in readers for doc in jsonql.read_jsons(reader)
+        ]
+        return
+
+    for shard, reader in zip(shards, readers):
+        block = [doc for doc in jsonql.read_jsons(reader)]
+        assert shard == block
+
+
+def test_regroup(tmp_path):
+    # With regroup boundaries will be every 256Mb.
+    check_regroup(tmp_path, regroup.reshard, check_blocks_boundaries=False)
+
+
+def test_fast_regroup(tmp_path):
+    # With fast regroup boundaries should match the shards.
+    check_regroup(tmp_path, regroup.fast_reshard, check_blocks_boundaries=True)

cc-multilingual-main/cc_net/tests/test_transformer.py

@@ -0,0 +1,86 @@
+# Copyright (c) Facebook, Inc. and its affiliates.
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+#
+
+import inspect
+import pickle
+from pathlib import Path
+
+import pytest
+
+from cc_net import dedup, jsonql, perplexity, split_by_lang, tokenizer
+
+
+def get_transformers(module):
+    return [
+        v
+        for v in vars(module).values()
+        if type(v) is type
+        and issubclass(v, jsonql.Transformer)
+        and v != jsonql.Transformer
+    ]
+
+
+ALL_TRANSFORMERS = (
+    get_transformers(jsonql)
+    + get_transformers(dedup)
+    + get_transformers(perplexity)
+    + get_transformers(tokenizer)
+    + get_transformers(split_by_lang)
+)
+
+
+def check_transformer_is_calling_super_init(cls: type):
+    assert issubclass(cls, jsonql.Transformer)
+    # accessing __init__ is generally an error, but here we do want to inspect
+    # the __init__method.
+    code = inspect.getsource(cls.__init__)  # type: ignore
+    code = code.replace(" ", "")
+
+    # Check that super().__init__ is called.
+    assert "super().__init__()" in code
+
+
+def test_bad_transformers_are_caught():
+    class BadTransformer(jsonql.Transformer):
+        def __init__(self, arg):
+            # We aren't calling super /!\
+            self.arg = arg
+
+    with pytest.raises(AssertionError):
+        check_transformer_is_calling_super_init(BadTransformer)
+
+
+@pytest.mark.parametrize("transformer", ALL_TRANSFORMERS)
+def test_transformer_is_correctly_implemented(transformer):
+    check_transformer_is_calling_super_init(transformer)
+
+
+@pytest.mark.skipif(
+    not Path("bin/lid.bin").exists(), reason="bin/lid.bin not found, run `make install`"
+)
+def test_can_pickle_transformer(tmp_path):
+    model = Path("bin/lid.bin")
+    if not model.exists():
+        return
+    classifier = split_by_lang.Classifier(model, "text", "lang")
+    classifier.__enter__()
+    doc = dict(text="Hello world ! This is English btw.")
+    original_results = classifier(doc)
+
+    with open(tmp_path / "transformer.pkl", "wb") as o:
+        pickle.dump(classifier, o)
+    with open(tmp_path / "transformer.pkl", "rb") as f:
+        classifier = pickle.load(f)
+
+    assert original_results == classifier(doc)
+
+    # Do it again with the unpickled object.
+    with open(tmp_path / "transformer.pkl", "wb") as o:
+        pickle.dump(classifier, o)
+    with open(tmp_path / "transformer.pkl", "rb") as f:
+        classifier = pickle.load(f)
+
+    assert original_results == classifier(doc)

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_acquire_msys.cmake

@@ -0,0 +1,644 @@
+# Full mirror list: https://github.com/msys2/MSYS2-packages/blob/master/pacman-mirrors/mirrorlist.msys
+set(Z_VCPKG_ACQUIRE_MSYS_MIRRORS
+    # Alternative primary
+    "https://repo.msys2.org/"
+    # Tier 1
+    "https://mirror.yandex.ru/mirrors/msys2/"
+    "https://mirrors.tuna.tsinghua.edu.cn/msys2/"
+    "https://mirrors.ustc.edu.cn/msys2/"
+    "https://mirror.selfnet.de/msys2/"
+)
+
+# Downloads the given package
+function(z_vcpkg_acquire_msys_download_package out_archive)
+    cmake_parse_arguments(PARSE_ARGV 1 "arg" "" "URL;SHA512;FILENAME" "")
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "internal error: z_vcpkg_acquire_msys_download_package passed extra args: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    string(REPLACE "https://repo.msys2.org/" "https://mirror.msys2.org/" all_urls "${arg_URL}")
+    foreach(mirror IN LISTS Z_VCPKG_ACQUIRE_MSYS_MIRRORS)
+        string(REPLACE "https://mirror.msys2.org/" "${mirror}" mirror_url "${arg_URL}")
+        list(APPEND all_urls "${mirror_url}")
+    endforeach()
+
+    vcpkg_download_distfile(msys_archive
+        URLS ${all_urls}
+        SHA512 "${arg_SHA512}"
+        FILENAME "${arg_FILENAME}"
+        QUIET
+    )
+    set("${out_archive}" "${msys_archive}" PARENT_SCOPE)
+endfunction()
+
+# Declares a package
+# Writes to the following cache variables:
+#   - Z_VCPKG_MSYS_PACKAGES_AVAILABLE
+#   - Z_VCPKG_MSYS_${arg_NAME}_URL
+#   - Z_VCPKG_MSYS_${arg_NAME}_SHA512
+#   - Z_VCPKG_MSYS_${arg_NAME}_FILENAME
+#   - Z_VCPKG_MSYS_${arg_NAME}_DEPS
+#   - Z_VCPKG_MSYS_${arg_NAME}_PATCHES
+#   - Z_VCPKG_MSYS_${arg_NAME}_DIRECT
+#   - Z_VCPKG_MSYS_${arg_NAME}_PROVIDES
+#   - Z_VCPKG_MSYS_${alias}_PROVIDED_BY
+function(z_vcpkg_acquire_msys_declare_package)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "DIRECT" "NAME;URL;SHA512" "DEPS;PATCHES;PROVIDES")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "internal error: z_vcpkg_acquire_msys_declare_package passed extra args: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    foreach(required_arg IN ITEMS URL SHA512)
+        if(NOT DEFINED arg_${required_arg})
+            message(FATAL_ERROR "internal error: z_vcpkg_acquire_msys_declare_package requires argument: ${required_arg}")
+        endif()
+    endforeach()
+
+    if(arg_DIRECT)
+        if(NOT arg_NAME)
+            message(FATAL_ERROR "internal error: z_vcpkg_acquire_msys_declare_package requires argument: NAME")
+        endif()
+        get_filename_component(filename "${arg_URL}" NAME)
+    else()
+        if(NOT arg_URL MATCHES [[^https://mirror\.msys2\.org/.*/(([^/]*)-[^-/]+-[^-/]+-[^-/]+\.pkg\.tar\.(xz|zst))$]])
+            message(FATAL_ERROR "internal error: regex does not match supplied URL to vcpkg_acquire_msys: ${arg_URL}")
+        endif()
+        set(filename "msys2-${CMAKE_MATCH_1}")
+        if(NOT DEFINED arg_NAME)
+            set(arg_NAME "${CMAKE_MATCH_2}")
+        endif()
+        if(Z_VCPKG_MSYS_${arg_NAME}_DIRECT)
+            return()
+        endif()
+        if(arg_NAME IN_LIST Z_VCPKG_MSYS_PACKAGES_AVAILABLE)
+            message(FATAL_ERROR "Redeclaration of package '${arg_NAME}'")
+        endif()
+    endif()
+
+    list(APPEND Z_VCPKG_MSYS_PACKAGES_AVAILABLE "${arg_NAME}")
+    set(Z_VCPKG_MSYS_PACKAGES_AVAILABLE "${Z_VCPKG_MSYS_PACKAGES_AVAILABLE}" CACHE INTERNAL "")
+    set(Z_VCPKG_MSYS_${arg_NAME}_URL "${arg_URL}" CACHE INTERNAL "")
+    set(Z_VCPKG_MSYS_${arg_NAME}_SHA512 "${arg_SHA512}" CACHE INTERNAL "")
+    set(Z_VCPKG_MSYS_${arg_NAME}_FILENAME "${filename}" CACHE INTERNAL "")
+    set(Z_VCPKG_MSYS_${arg_NAME}_DEPS "${arg_DEPS}" CACHE INTERNAL "")
+    set(Z_VCPKG_MSYS_${arg_NAME}_PATCHES "${arg_PATCHES}" CACHE INTERNAL "")
+    set(Z_VCPKG_MSYS_${arg_NAME}_DIRECT "${arg_DIRECT}" CACHE INTERNAL "")
+    set(Z_VCPKG_MSYS_${arg_NAME}_PROVIDES "${arg_PROVIDES}" CACHE INTERNAL "")
+    foreach(name IN LISTS arg_PROVIDES)
+        set(Z_VCPKG_MSYS_${name}_PROVIDED_BY "${arg_NAME}" CACHE INTERNAL "")
+    endforeach()
+endfunction()
+
+# Collects all required packages to satisfy the given input set
+# Writes to the following cache variables:
+#   - Z_VCPKG_MSYS_<name>_ARCHIVE
+function(z_vcpkg_acquire_msys_download_packages)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "OUT_UNKNOWN;OUT_RESOLVED" "PACKAGES")
+    set(backlog "${arg_PACKAGES}")
+    list(REMOVE_DUPLICATES backlog)
+
+    list(FILTER arg_PACKAGES EXCLUDE REGEX "^mingw64")
+    if(NOT arg_PACKAGES STREQUAL "" AND NOT "msys2-runtime" IN_LIST arg_PACKAGES)
+        list(APPEND backlog "msys2-runtime")
+    endif()
+
+    set(unknown "")
+    set(resolved "")
+    set(need_msys_runtime 0)
+    while(NOT backlog STREQUAL "")
+        list(POP_FRONT backlog name)
+        if(DEFINED Z_VCPKG_MSYS_${name}_PROVIDED_BY AND NOT name IN_LIST Z_VCPKG_MSYS_PACKAGES_AVAILABLE)
+            set(name "${Z_VCPKG_MSYS_${name}_PROVIDED_BY}")
+            if(name IN_LIST resolved)
+                continue()
+            endif()
+        endif()
+        if(NOT name IN_LIST Z_VCPKG_MSYS_PACKAGES_AVAILABLE)
+            list(APPEND unknown "${name}")
+            continue()
+        endif()
+        list(APPEND resolved "${name}")
+        list(REMOVE_ITEM Z_VCPKG_MSYS_${name}_DEPS ${resolved} ${backlog})
+        list(APPEND backlog ${Z_VCPKG_MSYS_${name}_DEPS})
+
+        z_vcpkg_acquire_msys_download_package(archive
+            URL "${Z_VCPKG_MSYS_${name}_URL}"
+            SHA512 "${Z_VCPKG_MSYS_${name}_SHA512}"
+            FILENAME "${Z_VCPKG_MSYS_${name}_FILENAME}"
+        )
+        set(Z_VCPKG_MSYS_${name}_ARCHIVE "${archive}" CACHE INTERNAL "")
+    endwhile()
+    if(DEFINED arg_OUT_UNKNOWN)
+        set("${arg_OUT_UNKNOWN}" "${unknown}" PARENT_SCOPE)
+    endif()
+    if(DEFINED arg_OUT_RESOLVED)
+        set("${arg_OUT_RESOLVED}" "${resolved}" PARENT_SCOPE)
+    endif()
+endfunction()
+
+# Returns a stable collection of hashes, regardless of package order
+function(z_vcpkg_acquire_msys_collect_hashes out_hash)
+    cmake_parse_arguments(PARSE_ARGV 1 "arg" "" "" "PACKAGES")
+    list(SORT arg_PACKAGES)
+    set(result "")
+    foreach(name IN LISTS arg_PACKAGES)
+        if(NOT DEFINED Z_VCPKG_MSYS_${name}_SHA512)
+            message(FATAL_ERROR "SHA512 unknown for '${name}'.")
+        endif()
+        string(APPEND result "${Z_VCPKG_MSYS_${name}_SHA512}")
+        foreach(patch IN LISTS Z_VCPKG_MSYS_${name}_PATCHES)
+            file(SHA512 "${patch}" patch_sha)
+            string(APPEND result "${patch_sha}")
+        endforeach()
+    endforeach()
+    set(${out_hash} "${result}" PARENT_SCOPE)
+endfunction()
+
+function(vcpkg_acquire_msys out_msys_root)
+    cmake_parse_arguments(PARSE_ARGV 1 "arg"
+        "NO_DEFAULT_PACKAGES;Z_ALL_PACKAGES"
+        "Z_DECLARE_EXTRA_PACKAGES_COMMAND"
+        "PACKAGES;DIRECT_PACKAGES"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "vcpkg_acquire_msys was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    z_vcpkg_acquire_msys_declare_all_packages()
+    if(NOT "${arg_Z_DECLARE_EXTRA_PACKAGES_COMMAND}" STREQUAL "")
+        cmake_language(CALL "${arg_Z_DECLARE_EXTRA_PACKAGES_COMMAND}")
+    endif()
+    set(requested "${arg_PACKAGES}")
+    if(arg_Z_ALL_PACKAGES)
+        set(requested "${Z_VCPKG_MSYS_PACKAGES_AVAILABLE}")
+    elseif(NOT arg_NO_DEFAULT_PACKAGES)
+        list(APPEND requested bash coreutils file gawk grep gzip diffutils make pkgconf sed)
+    endif()
+
+    if(DEFINED arg_DIRECT_PACKAGES AND NOT arg_DIRECT_PACKAGES STREQUAL "")
+        list(LENGTH arg_DIRECT_PACKAGES direct_packages_length)
+        math(EXPR direct_packages_parity "${direct_packages_length} % 2")
+        math(EXPR direct_packages_number "${direct_packages_length} / 2")
+        math(EXPR direct_packages_last "${direct_packages_number} - 1")
+
+        if(direct_packages_parity EQUAL 1)
+            message(FATAL_ERROR "vcpkg_acquire_msys(... DIRECT_PACKAGES ...) requires exactly pairs of URL/SHA512")
+        endif()
+
+        set(direct_packages "")
+        # direct_packages_last > direct_packages_number - 1 > 0 - 1 >= 0, so this is fine
+        foreach(index RANGE "${direct_packages_last}")
+            math(EXPR url_index "${index} * 2")
+            math(EXPR sha512_index "${url_index} + 1")
+            list(GET arg_DIRECT_PACKAGES "${url_index}" url)
+            list(GET arg_DIRECT_PACKAGES "${sha512_index}" sha512)
+            get_filename_component(filename "${url}" NAME)
+            if(NOT filename MATCHES "^(.*)-[^-]+-[^-]+-[^-]+\.pkg\.tar\..*$")
+                message(FATAL_ERROR "Cannot determine package name for '${filename}'")
+            endif()
+            set(pkg_name "${CMAKE_MATCH_1}")
+            z_vcpkg_acquire_msys_declare_package(
+                NAME "${pkg_name}"
+                URL "${url}"
+                SHA512 "${sha512}"
+                DIRECT
+            )
+            list(APPEND direct_packages "${pkg_name}")
+        endforeach()
+        list(INSERT requested 0 ${direct_packages})
+    endif()
+ 
+    z_vcpkg_acquire_msys_download_packages(
+        PACKAGES ${requested}
+        OUT_RESOLVED resolved
+        OUT_UNKNOWN unknown
+    )
+    if(NOT unknown STREQUAL "")
+        message(FATAL_ERROR "Unknown packages were required for vcpkg_acquire_msys(${requested}): ${unknown}
+This can be resolved by explicitly passing URL/SHA pairs to DIRECT_PACKAGES.")
+    endif()
+    set(Z_VCPKG_MSYS_PACKAGES_RESOLVED "${resolved}" CACHE INTERNAL "Export for CI")
+
+    z_vcpkg_acquire_msys_collect_hashes(hashes PACKAGES ${resolved})
+    string(SHA512 total_hash "${hashes}")
+    string(SUBSTRING "${total_hash}" 0 16 total_hash)
+    set(path_to_root "${DOWNLOADS}/tools/msys2/${total_hash}")
+
+    if(NOT EXISTS "${path_to_root}")
+        file(REMOVE_RECURSE "${path_to_root}.tmp")
+        file(MAKE_DIRECTORY "${path_to_root}.tmp/tmp")
+        foreach(name IN LISTS resolved)
+            file(ARCHIVE_EXTRACT
+                INPUT "${Z_VCPKG_MSYS_${name}_ARCHIVE}"
+                DESTINATION "${path_to_root}.tmp"
+            )
+            if(Z_VCPKG_MSYS_${name}_PATCHES)
+                z_vcpkg_apply_patches(
+                    SOURCE_PATH "${path_to_root}.tmp"
+                    PATCHES ${Z_VCPKG_MSYS_${name}_PATCHES}
+                )
+            endif()
+        endforeach()
+        file(RENAME "${path_to_root}.tmp" "${path_to_root}")
+    endif()
+    # Due to skipping the regular MSYS2 installer,
+    # some config files need to be established explicitly.
+    if(NOT EXISTS "${path_to_root}/etc/fstab")
+        # This fstab entry removes the cygdrive prefix from paths.
+        file(WRITE "${path_to_root}/etc/fstab" "none  /  cygdrive  binary,posix=0,noacl,user  0  0")
+    endif()
+    message(STATUS "Using msys root at ${path_to_root}")
+    set("${out_msys_root}" "${path_to_root}" PARENT_SCOPE)
+endfunction()
+
+# Expand this while CMAKE_CURRENT_LIST_DIR is for this file.
+set(Z_VCPKG_AUTOMAKE_CLANG_CL_PATCH "${CMAKE_CURRENT_LIST_DIR}/compile_wrapper_consider_clang-cl.patch")
+
+macro(z_vcpkg_acquire_msys_declare_all_packages)
+    set(Z_VCPKG_MSYS_PACKAGES_AVAILABLE "" CACHE INTERNAL "")
+
+    # The following list can be updated via test port vcpkg-ci-msys2[update-all].
+    # Upstream binary package information is available via
+    # https://packages.msys2.org/search?t=binpkg&q=<Pkg>
+
+    # msys subsystem
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/autoconf-wrapper-20221207-1-any.pkg.tar.zst"
+        SHA512 601ceb483ddf49d744ed7e365317d64777752e35010a1087082452afd42d8d29fc5331cb3fa4654eb09eec85416c8c5b70fed91a45acfaa667f06f80e6d42f30
+        PROVIDES autoconf
+        DEPS autoconf2.71 bash sed
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/autoconf2.71-2.71-3-any.pkg.tar.zst"
+        SHA512 dd312c428b2e19afd00899eb53ea4255794dea4c19d1d6dea2419cb6a54209ea2130d48abbc20af12196b9f628143436f736fbf889809c2c2291be0c69c0e306
+        DEPS awk bash diffutils m4 perl sed
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/autoconf-archive-2023.02.20-1-any.pkg.tar.zst"
+        SHA512 0dbdba67934402eeb974e6738eb9857d013342b4e3a11200710b87fbf085d5bebf49b29b6a14b6ff2511b126549919a375b68f19cc22aa18f6ba23c57290ac72
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/automake-wrapper-20221207-2-any.pkg.tar.zst"
+        SHA512 4351c607edcf00df055b1310a790e41a63c575fbd80a6888d3693b88cad31d4628f9b96f849e319089893c826cf4473d9b31206d7ccb4cea15fd05b6b0ccb582
+        PROVIDES automake
+        DEPS automake1.16 bash gawk
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/automake1.16-1.16.5-1-any.pkg.tar.zst"
+        SHA512 62c9dfe28d6f1d60310f49319723862d29fc1a49f7be82513a4bf1e2187ecd4023086faf9914ddb6701c7c1e066ac852c0209db2c058f3865910035372a4840a
+        DEPS bash perl
+        PATCHES "${Z_VCPKG_AUTOMAKE_CLANG_CL_PATCH}"
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/bash-5.2.026-1-x86_64.pkg.tar.zst"
+        SHA512 f69046b27b0ecec6afc60b3ba107491c50c70f6f41b989fe6fcc58da798345cb8336ff6cc668bc13ee49ff24d3be4b5932bc8fe87e80da4e6243063c18f0dcf8
+        PROVIDES sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/binutils-2.42-1-x86_64.pkg.tar.zst"
+        SHA512 6e12fbb6e7a14bac5cf3665d0e9867d40ef47ba76d4887748671e46e9ea288dbfc59b40461e6552559aa24651a057c18c022d2f24d679edfc42d8ca7e43af28d
+        DEPS libiconv libintl zlib
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/bzip2-1.0.8-4-x86_64.pkg.tar.zst"
+        SHA512 1d2ce42c6775c0cb0fe9c2863c975fd076579131d0a5bce907355315f357df4ee66869c9c58325f5b698f3aba2413b2823deda86dd27fdb6e2e5e5d4de045259
+        DEPS libbz2
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/coreutils-8.32-5-x86_64.pkg.tar.zst"
+        SHA512 63f99348e654440458f26e9f52ae3289759a5a03428cf2fcf5ac7b47fdf7bf7f51d08e3346f074a21102bee6fa0aeaf88b8ebeba1e1f02a45c8f98f69c8db59c
+        DEPS libiconv libintl gmp
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/diffutils-3.10-1-x86_64.pkg.tar.zst"
+        SHA512 7ed406370a699be98bff4eeb156a063de80ac8e332fb1873639e0b95b2e72e626351e24c5ca0021af9c0e56c4a3d91bd6669e6245b21c9d4ebdbb36888d8e39d
+        DEPS libiconv libintl sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/file-5.45-1-x86_64.pkg.tar.zst"
+        SHA512 fae01c7e2c88357be024aa09dba7b805d596cec7cde5c29a46c3ab209c67de64a005887e346edaad84b5173c033cb6618997d864f7fad4a7555bd38a3f7831c5
+        DEPS gcc-libs libbz2 liblzma libzstd zlib
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/findutils-4.9.0-3-x86_64.pkg.tar.zst"
+        SHA512 1538733929ecc11bc7c19797577e4cd59cc88499b375e3c2ea4a8ed4d66a1a02f4468ff916046c76195ba92f4c591d0e351371768117a423595d2e43b3321aad
+        DEPS libintl libiconv
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/gawk-5.3.0-1-x86_64.pkg.tar.zst"
+        SHA512 01a65153ffa109c51f05ef014534feecde9fc3e83ab4f5fc7f0ae957ea8a0bad2756fc65a86e20ab87a063c92161f7a7fccc8232b51c44c6ee506b7cff3762e7
+        PROVIDES awk
+        DEPS libintl libreadline mpfr sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/gcc-libs-13.2.0-2-x86_64.pkg.tar.zst" # 05-Jul-2022
+        SHA512 0bf8d56516ed7f14db2d1a991ccced0977d33a560f1844b114b62b2cd93d96374d3b85c5257adc0c4f141c3f3533bc4e8914349547092d607c22dea3bdbbbd0d
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/gettext-0.22.4-1-x86_64.pkg.tar.zst"
+        SHA512 7bd1dc50df8a973a075286fdf115fa30c8a78aa23d2845e2bdeb6068bf3391321d9b3ce3241626453bb660d1a57563bea44eebadf81cb2f98f15fbaf266648ec
+        DEPS libasprintf libgettextpo libintl
+    )
+    # This package shouldn't be a here
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/gettext-devel-0.22.4-1-x86_64.pkg.tar.zst"
+        SHA512 e7748736014b0aa47f2bc740189a5e8e1bcc99a82ccd02d6f75e226b041704e4f353107df175c0547651a05f5a352ec474a7af693fb33d42a8885e47ac371d2e
+        DEPS gettext # libiconv-devel
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/gmp-6.3.0-1-x86_64.pkg.tar.zst"
+        SHA512 d4e8549e55d4088eca30753f867bf82d9287955209766f488f2a07ecc71bc63ef2c50fcc9d47470ea3b0d2f149f1648d9c2453e366e3eb2c2e2d60939f311a40
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/grep-1~3.0-6-x86_64.pkg.tar.zst"
+        SHA512 79b4c652082db04c2ca8a46ed43a86d74c47112932802b7c463469d2b73e731003adb1daf06b08cf75dc1087f0e2cdfa6fec0e8386ada47714b4cff8a2d841e1
+        DEPS libiconv libintl libpcre sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/gzip-1.13-1-x86_64.pkg.tar.zst"
+        SHA512 4dbcfe5df7c213b10f003fc2a15123a5ed0d1a6d09638c467098f7b7db2e4fdd75a7ceee03b3a26c2492ae485267d626db981c5b9167e3acb3d7436de97d0e97
+        DEPS bash
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libasprintf-0.22.4-1-x86_64.pkg.tar.zst"
+        SHA512 06f353d2020d1e7168f4084e9fc17856a158a67a61098314e4b1d7db075542eb29dfe8a84bd154dad28942ee8eaae1e13a6510a4d2caab4509d9f3ea22db6d87
+        DEPS gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libbz2-1.0.8-4-x86_64.pkg.tar.zst"
+        SHA512 5a7be6d04e55e6fb1dc0770a8c020ca24a317807c8c8a4813146cd5d559c12a6c61040797b062e441645bc2257b390e12dd6df42519e56278a1fe849fe76a1c4
+        DEPS gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libgettextpo-0.22.4-1-x86_64.pkg.tar.zst"
+        SHA512 7552bc873331f07a4c006f27fe9f72186eed9717d68c4cbf54a75ff65c9445f874c43ccced2f9fa75ff1602c1209f6f1f4335a6ae6bf9bd5e951292584db7539
+        DEPS gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libiconv-1.17-1-x86_64.pkg.tar.zst"
+        SHA512 e8fc6338d499ccf3a143b3dbdb91838697de76e1c9582bb44b0f80c1d2da5dcfe8102b7512efa798c5409ba9258f4014eb4eccd24a9a46d89631c06afc615678
+        DEPS gcc-libs libintl
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libintl-0.22.4-1-x86_64.pkg.tar.zst"
+        SHA512 07f41f7fa53967bb5b0aca72255c70d7aeed58ea86b67bd0e765e08c20c50187ef2e775b630c0d48b3afbe62203754f7e8653a5f2e1a87a38b4af5753c7bd232
+        DEPS gcc-libs libiconv
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/liblzma-5.4.6-2-x86_64.pkg.tar.zst"
+        SHA512 d79bf6089f258e17226b30c1d68ee7b391048174386d366007f2361f2db0dc069a056549f483ac62285db238d9812d801bc347684ab485058d55cad16ce36dc0
+        # This package installs only a DLL. No extra deps.
+        DEPS # gettext libiconv sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libpcre-8.45-4-x86_64.pkg.tar.zst"
+        SHA512 e1eb5cb38dce22012527bba2e92f908bf23c7725d77dcbd7fa14597af0f5b413319e0a7dd66555370afffc3b55d6074b8b83fd3c384d31ac505b74db246d54ac
+        DEPS gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libreadline-8.2.010-1-x86_64.pkg.tar.zst"
+        SHA512 ce5e4b4abd347a2e8d4a48860aca062b0478000b3696859d0e143643f16b845bc0e7c84bf4fbf95cbcc043a6acebe2d28acc65b763d2de6a95f13ab6b3a3649f
+        DEPS ncurses
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libtool-2.4.7-3-x86_64.pkg.tar.zst"
+        SHA512 a202ddaefa93d8a4b15431dc514e3a6200c47275c5a0027c09cc32b28bc079b1b9a93d5ef65adafdc9aba5f76a42f3303b1492106ddf72e67f1801ebfe6d02cc
+        DEPS sh tar
+             # extra deps which are really needed
+             awk findutils grep sed
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libxcrypt-4.4.36-1-x86_64.pkg.tar.zst"
+        SHA512 457320daebd1aa45461788fb52dd4772fe91c34902201fac81d94ee2cbbfa216b02b3831a3e32a5ac638a3f12ac31fcec94ee95b19696fec6624e10e3dc5ffff
+        DEPS gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/libzstd-1.5.5-1-x86_64.pkg.tar.zst"
+        SHA512 c3d491f90bef0cbd7447303ff6f5a647e9fcf7bb0af9116cfe5fe421180e2283ec9403c768caa9434e9b158ce6ebde1a4750c56db8f67dfac4d6282d0ac30413
+        DEPS gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/m4-1.4.19-2-x86_64.pkg.tar.zst"
+        SHA512 7471099ba7e3b47e5b019dc0e563165a8660722f2bbd337fb579e6d1832c0e7dcab0ca9297c4692b18add92c4ad49e94391c621cf38874e2ff63d4f926bac38c
+        DEPS bash gcc-libs libiconv
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/make-4.4.1-1-x86_64.pkg.tar.zst"
+        SHA512 7e1c95b976d949db4b74c444e0d1495bbee26649aa82eadf34076dba3c1223d4e7b901e07935ba73dceda67f0a0cf25dd99fe3eed5300a5163fdaab14ca8d9fc
+        DEPS libintl sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/mpfr-4.2.1-1-x86_64.pkg.tar.zst"
+        SHA512 7417bb02a0f1073b8c1a64732463ec178d28f75eebd9621d02117cda1d214aff3e28277bd20e1e4731e191daab26e38333ace007ed44459ce3e2feae27aedc00
+        DEPS gmp
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/msys2-runtime-3.4.10-4-x86_64.pkg.tar.zst"
+        SHA512 b921b59b840dc2813825917dcff0c3686658f9af556bdb95b536fcb949d593886c9815e4bff136472797218e1f0462fbc49f87f2a31ec9abb2407c5506807f88
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/ncurses-6.4-2-x86_64.pkg.tar.zst"
+        SHA512 31d1e75071158aae970209de79adc3b3ff1d189ffc18460b3f1c818784e571ff3e0ff2767013516f9bb3fd0e62c2038444f1e8c1816db357d57e31f8663f4420
+        DEPS gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/patch-2.7.6-2-x86_64.pkg.tar.zst"
+        SHA512 eb484156e6e93da061645437859531f7b04abe6fef9973027343302f088a8681d413d87c5635a10b61ddc4a3e4d537af1de7552b3a13106639e451b95831ec91
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/perl-5.38.2-1-x86_64.pkg.tar.zst"
+        SHA512 00c992e0fd8847f579dd33a82140034c6a81b650f456d2b22706f82c5c6db04dce4f1194024775081ae7bffa01afc476df1815ec7cc98ebb0a676726a0c1c2b2
+        DEPS coreutils libxcrypt sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/pkgconf-2.1.0-1-x86_64.pkg.tar.zst"
+        SHA512 4376aba6fd2c118b1cb7e2008a23724aae62e9c972849b984a087079eaff1a29f423d3dedc3d7cfa682d931eb9a72891c8630196507a4a2cbe15f80a359bfa58
+        PROVIDES pkg-config
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/sed-4.9-1-x86_64.pkg.tar.zst"
+        SHA512 8006a83f0cc6417e3f23ffd15d0cbca2cd332f2d2690232a872ae59795ac63e8919eb361111b78f6f2675c843758cc4782d816ca472fe841f7be8a42c36e8237
+        DEPS libintl sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/tar-1.35-2-x86_64.pkg.tar.zst"
+        SHA512 86269fe17729e5381f8236a0251088110725c3eb930215b8378b6673e5ee136847997bb6a667fe0398b65b85e3f3a7e4679a0fd4bb2ebcb9429a5d7273a02d54
+        DEPS libiconv libintl sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/texinfo-7.1-2-x86_64.pkg.tar.zst"
+        SHA512 10edea1d3e2720afd47f0ff77ba47849b3eaf5d62d6025c3bce1d683302ae11126e7ee7b26751d1a6a66bc86a4c09021feb373434b1808441897e02245235c7b
+        DEPS perl sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/unzip-6.0-3-x86_64.pkg.tar.zst"
+        SHA512 1d6df49e826617ef3d3976be33361e189d8a5aee3a33ae79474fd08ca44ebd113981e6ba25c968b3cf5fb9826edd42dee21a97261cbc86fd8b143c950ba1f357
+        DEPS bash libbz2
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/which-2.21-4-x86_64.pkg.tar.zst"
+        SHA512 5323fd6635093adf67c24889f469e1ca8ac969188c7f087244a43b3afa0bf8f14579bd87d9d7beb16a7cd61a5ca1108515a46b331868b4817b35cebcb4eba1d1
+        DEPS sh
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/xz-5.4.6-2-x86_64.pkg.tar.zst"
+        SHA512 301e612ce0174b1d80a0e40c96f6bc2941c57f5e2a6c0e8e05b9d479cc000204d0df364c0a4df6eeb923107bee3e8f20cbef35825a2eec3e489c525ce2605534
+        DEPS libiconv libintl liblzma
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/msys/x86_64/zlib-1.3.1-1-x86_64.pkg.tar.zst"
+        SHA512 a432b0f927d342b678df706487595eff1b780371548933f956adcf697eea11ddbca2863d9d9fb88675a7040dcfddab56f8f71a8ae4d0cd4969e715545c77e87c
+        DEPS gcc-libs
+    )
+
+    # mingw64 subsystem
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-bzip2-1.0.8-3-any.pkg.tar.zst"
+        SHA512 fb1ae524d7b04e1f35c3101c318136dbe08da8093bda98f6aea7e6c2564fec5f8533fb61cac5001b6425105cd982511964ec04099c6651f990dc3b8baf7f7057
+        DEPS mingw-w64-x86_64-gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-ca-certificates-20230311-1-any.pkg.tar.zst"
+        SHA512 f7526ad35bccc5edba3fcf1354a85eacbd61dba5780b1bc65c7e8795ecb252432004af809052bb0ba981b1dea174c40e2d3f20655d8e2b29be95ad54d2aa5782
+        DEPS mingw-w64-x86_64-p11-kit
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-expat-2.5.0-1-any.pkg.tar.zst"
+        SHA512 b49ec84750387af5b73a78d654673d62cf0e2cb2b59b4d25acb7eca3830018f7a2aefe600d67d843417cfbdd97db81ecfd49a8811e312f53b42c21fb106b230d
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-gcc-libgfortran-13.2.0-3-any.pkg.tar.zst"
+        SHA512 da0902979b2fd1a556d639587caeb24a756bdab29f6179fdb2deac3463bb7c150f13db6b944da2a7ade69d496199b7e8bd22ec1515beb26fab1a01e3b4e6c2bd
+        PROVIDES mingw-w64-x86_64-fc-libs
+        DEPS mingw-w64-x86_64-gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-gcc-libs-13.2.0-3-any.pkg.tar.zst"
+        SHA512 f904ee75196ab63df4b63b84f08bfd5956a178c72fea21fdcf8727f7d70f538b358a546316c4542c36a5c3169f88437426c785ac8e2a99d8eb952be7429216d4
+        PROVIDES mingw-w64-x86_64-omp
+        DEPS mingw-w64-x86_64-libwinpthread
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-gettext-runtime-0.22.4-5-any.pkg.tar.zst"
+        SHA512 03a0210dd2c57a282e8de6a96d871cf8957b16a88464f62fa0cbf42e6ccf60046ce2ff7fcabd086775893f7ade92bb9f9bf5740e92aba6efbdc2aea3ece35c73
+        DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-libiconv
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-gmp-6.3.0-2-any.pkg.tar.zst"
+        SHA512 38ab150051d787e44f1c75b3703d6c8deb429d244acb2a973ee232043b708e6c9e29a1f9e28f12e242c136d433e8eb5a5133a4d9ac7b87157a9749a8d215d2f0
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-libffi-3.4.4-1-any.pkg.tar.zst"
+        SHA512 ec88a0e0cb9b3ff3879d3fd952d3ad52f0d86a42669eddaeca47778ab0d5213abdea7d480a23aa3870e08d6b93b9c4988855e368474be7186e9719456baae5df
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-libiconv-1.17-4-any.pkg.tar.zst"
+        SHA512 dc703b103291a5b89175c3ddf4282c1a40bcd91549c8f993300671b9afffb28559e118a2c665f47a465bd7286b9e3400c29d42761e0189c425fb156b37783927
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-libsystre-1.0.1-5-any.pkg.tar.zst"
+        SHA512 10ea2bacebb8b05c642f34c0ecf61710b9f1906615851825d1104d0e25b1a911f7541a3068b97de2eb71aa13d6963f61c7fdf051c5582e0868a6f90b93f7aa77
+        PROVIDES mingw-w64-x86_64-libgnurx
+        DEPS mingw-w64-x86_64-libtre
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-libtasn1-4.19.0-1-any.pkg.tar.zst"
+        SHA512 761a7c316914d7f98ec6489fb4c06d227e5956d50f2e233ad9be119cfd6301f6b7e4f872316c0bae3913268c1aa9b224b172ab94130489fbd5d7269ff9064cfb
+        DEPS mingw-w64-x86_64-gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-libtre-git-r177.07e66d0-2-any.pkg.tar.zst"
+        SHA512 a21a03fd446707f748f4101e723f71d5f2c93c736d86205dc9eee6681d1bb1248283b8921f897391b56143d8dcf6be29cf8c2c57abcf32e1e4d0b2ea2309a790
+        PROVIDES mingw-w64-x86_64-libtre
+        DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-gettext-runtime
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-libwinpthread-git-11.0.0.r551.g86a5e0f41-1-any.pkg.tar.zst"
+        SHA512 2742d5939e6f677d148f0f07ddc399bf8e4bf3c07f9b90160f20314f1c69e549b9f9d6cbf0df35d7f950d2e09e57c56c0496475cb66f053dcf0bcfdf3bb14bb1
+        PROVIDES mingw-w64-x86_64-libwinpthread
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-mpc-1.3.1-2-any.pkg.tar.zst"
+        SHA512 3fe183d4af3b3935a4394502eab75a8f7b7692f551fd44e54c67935a4691388d23a021ee1147f0345ed27ffe8a8db3e9e7e37caf2348df3413e0acd519c12a0c
+        DEPS mingw-w64-x86_64-gmp mingw-w64-x86_64-mpfr
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-mpdecimal-2.5.1-1-any.pkg.tar.zst"
+        SHA512 1204c31367f9268ffd6658be04af7687c01f984c9d6be8c7a20ee0ebde1ca9a03b766ef1aeb1fa7aaa97b88a57f7a73afa7f7a7fed9c6b895a032db11e6133bf
+        DEPS mingw-w64-x86_64-gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-mpfr-4.2.1-2-any.pkg.tar.zst"
+        SHA512 03a727e1622b09ed0b6e0cb93a6b1040c31c9504c3f14bd1a2e12b8293153609796bc99882393b343c4d96e45f402f847317a3a65212b972ff96a964e5e52815
+        DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-gmp
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-ncurses-6.4.20231217-1-any.pkg.tar.zst"
+        SHA512 54a936731589a1af653dc73da983b683e8fc687e9c3737f5215acdef70e3596cddce44d01a6e98e482fd3f071da20cd5ab10b54d52cbdc0b34bbdc090a1cf3d3
+        DEPS mingw-w64-x86_64-libsystre
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-openblas-0.3.26-1-any.pkg.tar.zst"
+        SHA512 de5b2b3eca6976a26dded23d5be6f1cdccb68e4a41a3568f917f78aee2bc9c91b5ff7e566cbc2fa9d6852c57b90bb92a36b95efe458c88f1819961a27d91129b
+        PROVIDES mingw-w64-x86_64-OpenBLAS
+        DEPS mingw-w64-x86_64-gcc-libgfortran mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-libwinpthread mingw-w64-x86_64-omp
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-openssl-3.2.1-1-any.pkg.tar.zst"
+        SHA512 706218c8d7321358cf7f1c472c89c19f88245eeff5037712b2a64c9f81166bcd7b2a06cc3343af5a75a65c520890d845d8d1234feddbe622992b6e9825e81f5c
+        #DEPS mingw-w64-x86_64-ca-certificates mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-zlib
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-p11-kit-0.25.3-2-any.pkg.tar.zst"
+        SHA512 81e62ad4b1bdf7da3b2de20a3a444b2a30a7b38dda8df41ca7e8baed0954a335cc9594ddd577f4ea5b6000d945348dc7d0364c9408e8a3e3afef34cc5c083c85
+        DEPS mingw-w64-x86_64-gettext-runtime mingw-w64-x86_64-libffi mingw-w64-x86_64-libtasn1
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-python-3.11.7-1-any.pkg.tar.zst"
+        SHA512 f94e2e53887da29bdcdafd4ad86d709e98c1bd271fdf9c5a85904cf20eae7690b8efef5b858a8bc979f6106343cec6ab6a828fcad631e4c30ce89c736603375e
+        PROVIDES mingw-w64-x86_64-python3 mingw-w64-x86_64-python3.11
+        DEPS mingw-w64-x86_64-bzip2 mingw-w64-x86_64-expat mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-libffi mingw-w64-x86_64-mpdecimal mingw-w64-x86_64-ncurses mingw-w64-x86_64-openssl mingw-w64-x86_64-sqlite3 mingw-w64-x86_64-tcl mingw-w64-x86_64-tk mingw-w64-x86_64-xz mingw-w64-x86_64-zlib
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-python-numpy-1.26.3-1-any.pkg.tar.zst"
+        SHA512 62fac7ca3c936bc42902652933373420fb422fb49bfe808e4a4d71183983c5d386f88c1772e6e07477c5b76f5fd489ef5084bef33588c3db63edccaa361520d2
+        PROVIDES mingw-w64-x86_64-python3-numpy
+        DEPS mingw-w64-x86_64-openblas mingw-w64-x86_64-python
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-readline-8.2.010-1-any.pkg.tar.zst"
+        SHA512 ade6caf9e97e762cb2a129a838e1b73e4a2cc4488a7db5c1b6a3ec5db7206d9108a9a7fc5e0e6d7099f26d15ddf71238006dd09467ad2a7617ad9dd925ea04e2
+        DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-termcap
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-sqlite3-3.45.1-1-any.pkg.tar.zst"
+        SHA512 b54ae774fc82f83a19a78910cc068597f85fbd798d52c518fee24030043b606986f235ed86f99879d8de3360c2cbaf53500108a3db8638da1f32096d9439e90f
+        PROVIDES mingw-w64-x86_64-sqlite mingw-w64-x86_64-sqlite-analyzer
+        DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-readline mingw-w64-x86_64-tcl mingw-w64-x86_64-zlib
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-termcap-1.3.1-7-any.pkg.tar.zst"
+        SHA512 2610355be441fd933f660f8181a5ad074057361a9aadeaad85961230dcf6df5d5165b94ccf9887144c91812485be57c2d79f39e8191ff525889bdff042d34ce6
+        DEPS mingw-w64-x86_64-gcc-libs
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-tcl-8.6.13-1-any.pkg.tar.zst"
+        SHA512 e143405ed45da7986d30d2f14bde9dff16fb0ea85a01df45d15cbe8fc52065f5efcb22f8da98962022efbfee3a704fc20e38839ec448cdbb5809336b6b97d550
+        DEPS mingw-w64-x86_64-gcc-libs mingw-w64-x86_64-zlib
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-tk-8.6.12-2-any.pkg.tar.zst"
+        SHA512 832c98f2bb8963540d175bc6511f00747483d86b0e0d3219c7b6e5b0bd5e7d038018db08875bf26b3fbe6082b4ff1958777e5cfd1920f5d235493f0a1ce071b2
+        DEPS mingw-w64-x86_64-tcl
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-xz-5.4.6-2-any.pkg.tar.zst"
+        SHA512 4ca1f3707003d43bdf5c6e7df1d0ea2a9ea56acfaa8a1b8db89f76d97ac8eb709b8af4d4233da412fdec3bffb72f7809462356d2afe61675bce8d2b23a7ce1d6
+        DEPS mingw-w64-x86_64-gettext-runtime
+    )
+    z_vcpkg_acquire_msys_declare_package(
+        URL "https://mirror.msys2.org/mingw/mingw64/mingw-w64-x86_64-zlib-1.3.1-1-any.pkg.tar.zst"
+        SHA512 1336cd0db102af495d8bbfc6a1956f365750b19d2377fe809e9b26f61a8a6600394e7343677645c5743f4974161535dad5c0503ff50f6126d27bb927754e7320
+    )
+endmacro()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_add_to_path.cmake

@@ -0,0 +1,10 @@
+function(vcpkg_add_to_path)
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "PREPEND" "" "")
+    if(arg_PREPEND)
+        set(operation PREPEND)
+    else()
+        set(operation APPEND)
+    endif()
+
+    vcpkg_host_path_list("${operation}" ENV{PATH} ${arg_UNPARSED_ARGUMENTS})
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_backup_restore_env_vars.cmake

@@ -0,0 +1,35 @@
+function(vcpkg_backup_env_variables)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "" "VARS")
+    if(NOT DEFINED arg_VARS)
+        message(FATAL_ERROR "VARS must be defined.")
+    endif()
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    foreach(envvar IN LISTS arg_VARS)
+        if(DEFINED ENV{${envvar}})
+            set("z_vcpkg_env_backup_${envvar}" "$ENV{${envvar}}" PARENT_SCOPE)
+        else()
+            unset("z_vcpkg_env_backup_${envvar}" PARENT_SCOPE)
+        endif()
+    endforeach()
+endfunction()
+
+function(vcpkg_restore_env_variables)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "" "VARS")
+    if(NOT DEFINED arg_VARS)
+        message(FATAL_ERROR "VARS must be defined.")
+    endif()
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    foreach(envvar IN LISTS arg_VARS)
+        if(DEFINED z_vcpkg_env_backup_${envvar})
+            set("ENV{${envvar}}" "${z_vcpkg_env_backup_${envvar}}")
+        else()
+            unset("ENV{${envvar}}")
+        endif()
+    endforeach()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_ninja.cmake

@@ -0,0 +1,30 @@
+function(z_vcpkg_build_ninja_build config targets)
+    message(STATUS "Building (${config})...")
+    vcpkg_execute_build_process(
+        COMMAND "${NINJA}" -C "${CURRENT_BUILDTREES_DIR}/${config}" ${targets}
+        WORKING_DIRECTORY "${SOURCE_PATH}"
+        LOGNAME "build-${config}"
+    )
+endfunction()
+
+
+function(vcpkg_build_ninja)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "" "TARGETS")
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT DEFINED arg_TARGETS)
+        set(arg_TARGETS "")
+    endif()
+
+    vcpkg_find_acquire_program(NINJA)
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        z_vcpkg_build_ninja_build("${TARGET_TRIPLET}-dbg" "${arg_TARGETS}")
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        z_vcpkg_build_ninja_build("${TARGET_TRIPLET}-rel" "${arg_TARGETS}")
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_build_nmake.cmake

@@ -0,0 +1,166 @@
+function(vcpkg_build_nmake)
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "ADD_BIN_TO_PATH;ENABLE_INSTALL;NO_DEBUG;PREFER_JOM"
+        "SOURCE_PATH;PROJECT_SUBPATH;PROJECT_NAME;LOGFILE_ROOT;CL_LANGUAGE"
+        "OPTIONS;OPTIONS_RELEASE;OPTIONS_DEBUG;PRERUN_SHELL;PRERUN_SHELL_DEBUG;PRERUN_SHELL_RELEASE;TARGET"
+    )
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT DEFINED arg_SOURCE_PATH)
+        message(FATAL_ERROR "SOURCE_PATH must be specified")
+    endif()
+
+    if(arg_NO_DEBUG)
+        message(WARNING "NO_DEBUG argument to ${CMAKE_CURRENT_FUNCTION} is deprecated")
+    endif()
+    if(arg_ADD_BIN_TO_PATH)
+        message(WARNING "ADD_BIN_TO_PATH argument to ${CMAKE_CURRENT_FUNCTION} is deprecated - it never did anything")
+    endif()
+
+    if(NOT VCPKG_HOST_IS_WINDOWS)
+        message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} only support windows.")
+    endif()
+
+    if(NOT DEFINED arg_LOGFILE_ROOT)
+        set(arg_LOGFILE_ROOT "build")
+    endif()
+    if(NOT DEFINED arg_PROJECT_NAME)
+        set(arg_PROJECT_NAME makefile.vc)
+    endif()
+
+    if(NOT DEFINED arg_TARGET)
+        vcpkg_list(SET arg_TARGET all)
+    endif()
+    if(arg_ENABLE_INSTALL)
+        vcpkg_list(APPEND arg_TARGET install)
+    endif()
+
+    if(NOT DEFINED arg_CL_LANGUAGE)
+        vcpkg_list(SET arg_CL_LANGUAGE CXX)
+    endif()
+
+    find_program(NMAKE nmake REQUIRED)
+    get_filename_component(NMAKE_EXE_PATH "${NMAKE}" DIRECTORY)
+    # Load toolchains
+    z_vcpkg_get_cmake_vars(cmake_vars_file)
+    debug_message("Including cmake vars from: ${cmake_vars_file}")
+    include("${cmake_vars_file}")
+    # Set needed env
+    set(ENV{PATH} "$ENV{PATH};${NMAKE_EXE_PATH}")
+    set(ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include;$ENV{INCLUDE}")
+    # Set make options
+    vcpkg_list(SET make_opts_base /NOLOGO /G /U /F "${arg_PROJECT_NAME}" ${arg_TARGET})
+
+    if(arg_PREFER_JOM AND VCPKG_CONCURRENCY GREATER "1")
+        vcpkg_find_acquire_program(JOM)
+        get_filename_component(JOM_EXE_PATH "${JOM}" DIRECTORY)
+        vcpkg_add_to_path("${JOM_EXE_PATH}")
+        if(arg_CL_LANGUAGE AND "${VCPKG_DETECTED_CMAKE_${arg_CL_LANGUAGE}_COMPILER_ID}" STREQUAL "MSVC")
+            string(REGEX REPLACE " [/-]MP[0-9]* " " " VCPKG_COMBINED_${arg_CL_LANGUAGE}_FLAGS_DEBUG " ${VCPKG_COMBINED_${arg_CL_LANGUAGE}_FLAGS_DEBUG} /FS")
+            string(REGEX REPLACE " [/-]MP[0-9]* " " " VCPKG_COMBINED_${arg_CL_LANGUAGE}_FLAGS_RELEASE " ${VCPKG_COMBINED_${arg_CL_LANGUAGE}_FLAGS_RELEASE} /FS")
+        endif()
+    else()
+        set(arg_PREFER_JOM FALSE)
+    endif()
+
+    # Add subpath to work directory
+    if(DEFINED arg_PROJECT_SUBPATH)
+        set(project_subpath "/${arg_PROJECT_SUBPATH}")
+    else()
+        set(project_subpath "")
+    endif()
+
+    vcpkg_backup_env_variables(VARS _CL_ LINK)
+    cmake_path(NATIVE_PATH CURRENT_PACKAGES_DIR NORMALIZE install_dir_native)
+    foreach(build_type IN ITEMS debug release)
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL build_type)
+            if(build_type STREQUAL "debug")
+                # Generate obj dir suffix
+                set(short_build_type "-dbg")
+                # Add install command and arguments
+                set(make_opts "${make_opts_base}")
+                if (arg_ENABLE_INSTALL)
+                    vcpkg_list(APPEND make_opts "INSTALLDIR=${install_dir_native}\\debug")
+                endif()
+                vcpkg_list(APPEND make_opts ${arg_OPTIONS} ${arg_OPTIONS_DEBUG})
+                if(NOT arg_CL_LANGUAGE STREQUAL "NONE")
+                    set(ENV{_CL_} "${VCPKG_DETECTED_CMAKE_${arg_CL_LANGUAGE}_FLAGS_DEBUG}")
+                endif()
+                set(ENV{_LINK_} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
+
+                set(prerun_variable_name arg_PRERUN_SHELL_DEBUG)
+            else()
+                set(short_build_type "-rel")
+                # Add install command and arguments
+                set(make_opts "${make_opts_base}")
+                if (arg_ENABLE_INSTALL)
+                    vcpkg_list(APPEND make_opts "INSTALLDIR=${install_dir_native}")
+                endif()
+                vcpkg_list(APPEND make_opts ${arg_OPTIONS} ${arg_OPTIONS_RELEASE})
+
+                if(NOT arg_CL_LANGUAGE STREQUAL "NONE")
+                    set(ENV{_CL_} "${VCPKG_DETECTED_CMAKE_${arg_CL_LANGUAGE}_FLAGS_RELEASE}")
+                endif()
+                set(ENV{_LINK_} "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
+                set(prerun_variable_name arg_PRERUN_SHELL_RELEASE)
+            endif()
+
+            set(triplet_and_build_type "${TARGET_TRIPLET}${short_build_type}")
+            set(object_dir "${CURRENT_BUILDTREES_DIR}/${triplet_and_build_type}")
+
+            file(REMOVE_RECURSE "${object_dir}")
+            file(COPY "${arg_SOURCE_PATH}/" DESTINATION "${object_dir}")
+
+            if(DEFINED arg_PRERUN_SHELL)
+                message(STATUS "Prerunning ${triplet_and_build_type}")
+                vcpkg_execute_required_process(
+                    COMMAND ${arg_PRERUN_SHELL}
+                    WORKING_DIRECTORY "${object_dir}${project_subpath}"
+                    LOGNAME "prerun-${triplet_and_build_type}"
+                )
+            endif()
+            if(DEFINED "${prerun_variable_name}")
+                message(STATUS "Prerunning ${triplet_and_build_type}")
+                vcpkg_execute_required_process(
+                    COMMAND ${${prerun_variable_name}}
+                    WORKING_DIRECTORY "${object_dir}${project_subpath}"
+                    LOGNAME "prerun-specific-${triplet_and_build_type}"
+                )
+            endif()
+
+            if (NOT arg_ENABLE_INSTALL)
+                message(STATUS "Building ${triplet_and_build_type}")
+            else()
+                message(STATUS "Building and installing ${triplet_and_build_type}")
+            endif()
+
+            set(run_nmake TRUE)
+            set(tool_suffix "")
+            if(arg_PREFER_JOM)
+                execute_process(
+                    COMMAND "${JOM}" /K /J ${VCPKG_CONCURRENCY} ${make_opts}
+                    WORKING_DIRECTORY "${object_dir}${project_subpath}"
+                    OUTPUT_FILE "${CURRENT_BUILDTREES_DIR}/${arg_LOGFILE_ROOT}-${triplet_and_build_type}-jom-out.log"
+                    ERROR_FILE "${CURRENT_BUILDTREES_DIR}/${arg_LOGFILE_ROOT}-${triplet_and_build_type}-jom-err.log"
+                    RESULT_VARIABLE error_code
+                )
+                if(error_code EQUAL "0")
+                    set(run_nmake FALSE)
+                else()
+                    message(STATUS "Restarting build without parallelism")
+                    set(tool_suffix "-nmake")
+                endif()
+            endif()
+            if(run_nmake)
+                vcpkg_execute_build_process(
+                    COMMAND "${NMAKE}" ${make_opts}
+                    WORKING_DIRECTORY "${object_dir}${project_subpath}"
+                    LOGNAME "${arg_LOGFILE_ROOT}-${triplet_and_build_type}${tool_suffix}"
+                )
+            endif()
+
+            vcpkg_restore_env_variables(VARS _CL_ LINK)
+        endif()
+    endforeach()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_buildpath_length_warning.cmake

@@ -0,0 +1,8 @@
+function(vcpkg_buildpath_length_warning warning_length)
+    string(LENGTH "${CURRENT_BUILDTREES_DIR}" buildtrees_path_length)
+    if(buildtrees_path_length GREATER warning_length AND CMAKE_HOST_WIN32)
+            message(WARNING "${PORT}'s buildsystem uses very long paths and may fail on your system.\n"
+                "We recommend moving vcpkg to a short path such as 'C:\\src\\vcpkg' or using the subst command."
+            )
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_check_features.cmake

@@ -0,0 +1,96 @@
+function(z_vcpkg_check_features_last_feature out_var features_name features_list)
+    list(LENGTH features_list features_length)
+    math(EXPR features_length_mod_2 "${features_length} % 2")
+    if(NOT features_length_mod_2 EQUAL 0)
+        message(FATAL_ERROR "vcpkg_check_features has an incorrect number of arguments to ${features_name}")
+    endif()
+
+    math(EXPR last_feature "${features_length} / 2 - 1")
+    set("${out_var}" "${last_feature}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_check_features_get_feature idx features_list out_feature_name out_feature_var)
+    math(EXPR feature_name_idx "${idx} * 2")
+    math(EXPR feature_var_idx "${feature_name_idx} + 1")
+
+    list(GET features_list "${feature_name_idx}" feature_name)
+    list(GET features_list "${feature_var_idx}" feature_var)
+
+    set("${out_feature_name}" "${feature_name}" PARENT_SCOPE)
+    set("${out_feature_var}" "${feature_var}" PARENT_SCOPE)
+endfunction()
+
+function(vcpkg_check_features)
+    cmake_parse_arguments(
+        PARSE_ARGV 0 "arg"
+        ""
+        "OUT_FEATURE_OPTIONS;PREFIX"
+        "FEATURES;INVERTED_FEATURES"
+    )
+
+    if(NOT DEFINED arg_OUT_FEATURE_OPTIONS)
+        message(FATAL_ERROR "OUT_FEATURE_OPTIONS must be defined.")
+    endif()
+    if(NOT DEFINED arg_PREFIX)
+        set(prefix "")
+    else()
+        set(prefix "${arg_PREFIX}_")
+    endif()
+
+    set(feature_options)
+    set(feature_variables)
+
+    if(NOT DEFINED arg_FEATURES AND NOT DEFINED arg_INVERTED_FEATURES)
+        message(DEPRECATION
+"calling `vcpkg_check_features` without the `FEATURES` keyword has been deprecated.
+    Please add the `FEATURES` keyword to the call.")
+        set(arg_FEATURES "${arg_UNPARSED_ARGUMENTS}")
+    elseif(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "vcpkg_check_features called with unknown arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+
+
+    z_vcpkg_check_features_last_feature(last_feature "FEATURES" "${arg_FEATURES}")
+    if(last_feature GREATER_EQUAL 0)
+        foreach(feature_pair_idx RANGE "${last_feature}")
+            z_vcpkg_check_features_get_feature("${feature_pair_idx}" "${arg_FEATURES}" feature_name feature_var)
+
+            list(APPEND feature_variables "${feature_var}")
+            if(feature_name IN_LIST FEATURES)
+                list(APPEND feature_options "-D${feature_var}=ON")
+                set("${prefix}${feature_var}" ON PARENT_SCOPE)
+            else()
+                list(APPEND feature_options "-D${feature_var}=OFF")
+                set("${prefix}${feature_var}" OFF PARENT_SCOPE)
+            endif()
+        endforeach()
+    endif()
+
+    z_vcpkg_check_features_last_feature(last_inverted_feature "INVERTED_FEATURES" "${arg_INVERTED_FEATURES}")
+    if(last_inverted_feature GREATER_EQUAL 0)
+        foreach(feature_pair_idx RANGE "${last_inverted_feature}")
+            z_vcpkg_check_features_get_feature("${feature_pair_idx}" "${arg_INVERTED_FEATURES}" feature_name feature_var)
+
+            list(APPEND feature_variables "${feature_var}")
+            if(feature_name IN_LIST FEATURES)
+                list(APPEND feature_options "-D${feature_var}=OFF")
+                set("${prefix}${feature_var}" OFF PARENT_SCOPE)
+            else()
+                list(APPEND feature_options "-D${feature_var}=ON")
+                set("${prefix}${feature_var}" ON PARENT_SCOPE)
+            endif()
+        endforeach()
+    endif()
+
+    list(SORT feature_variables)
+    set(last_variable)
+    foreach(variable IN LISTS feature_variables)
+        if(variable STREQUAL last_variable)
+            message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "vcpkg_check_features passed the same feature variable multiple times: '${variable}'")
+        endif()
+        set(last_variable ${variable})
+    endforeach()
+
+    set("${arg_OUT_FEATURE_OPTIONS}" "${feature_options}" PARENT_SCOPE)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_check_linkage.cmake

@@ -0,0 +1,36 @@
+function(vcpkg_check_linkage)
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "ONLY_STATIC_LIBRARY;ONLY_DYNAMIC_LIBRARY;ONLY_DYNAMIC_CRT;ONLY_STATIC_CRT"
+        ""
+        ""
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(arg_ONLY_STATIC_LIBRARY AND arg_ONLY_DYNAMIC_LIBRARY)
+        message(FATAL_ERROR "Requesting both ONLY_STATIC_LIBRARY and ONLY_DYNAMIC_LIBRARY; this is an error.")
+    endif()
+    if(arg_ONLY_STATIC_CRT AND arg_ONLY_DYNAMIC_CRT)
+        message(FATAL_ERROR "Requesting both ONLY_STATIC_CRT and ONLY_DYNAMIC_CRT; this is an error.")
+    endif()
+
+    if(arg_ONLY_STATIC_LIBRARY AND "${VCPKG_LIBRARY_LINKAGE}" STREQUAL "dynamic")
+        message(STATUS "Note: ${PORT} only supports static library linkage. Building static library.")
+        set(VCPKG_LIBRARY_LINKAGE static PARENT_SCOPE)
+    elseif(arg_ONLY_DYNAMIC_LIBRARY AND "${VCPKG_LIBRARY_LINKAGE}" STREQUAL "static")
+        message(STATUS "Note: ${PORT} only supports dynamic library linkage. Building dynamic library.")
+        if("${VCPKG_CRT_LINKAGE}" STREQUAL "static")
+            message(FATAL_ERROR "Refusing to build unexpected dynamic library against the static CRT.
+    If this is desired, please configure your triplet to directly request this configuration.")
+        endif()
+        set(VCPKG_LIBRARY_LINKAGE dynamic PARENT_SCOPE)
+    endif()
+
+    if(arg_ONLY_DYNAMIC_CRT AND "${VCPKG_CRT_LINKAGE}" STREQUAL "static")
+        message(FATAL_ERROR "${PORT} only supports dynamic crt linkage")
+    elseif(arg_ONLY_STATIC_CRT AND "${VCPKG_CRT_LINKAGE}" STREQUAL "dynamic")
+        message(FATAL_ERROR "${PORT} only supports static crt linkage")
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_clean_executables_in_bin.cmake

@@ -0,0 +1,46 @@
+function(z_vcpkg_clean_executables_in_bin_remove_directory_if_empty directory)
+    if(NOT EXISTS "${directory}")
+        return()
+    endif()
+
+    if(NOT IS_DIRECTORY "${directory}")
+        message(FATAL_ERROR "${directory} must be a directory")
+    endif()
+
+    file(GLOB items "${directory}/*")
+    if("${items}" STREQUAL "")
+        file(REMOVE_RECURSE "${directory}")
+    endif()
+endfunction()
+
+
+function(vcpkg_clean_executables_in_bin)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "" "FILE_NAMES")
+
+    if(NOT DEFINED arg_FILE_NAMES)
+        message(FATAL_ERROR "FILE_NAMES must be specified.")
+    endif()
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+
+    foreach(file_name IN LISTS arg_FILE_NAMES)
+        file(REMOVE
+            "${CURRENT_PACKAGES_DIR}/bin/${file_name}${VCPKG_TARGET_EXECUTABLE_SUFFIX}"
+            "${CURRENT_PACKAGES_DIR}/debug/bin/${file_name}${VCPKG_TARGET_EXECUTABLE_SUFFIX}"
+            "${CURRENT_PACKAGES_DIR}/bin/${file_name}.pdb"
+            "${CURRENT_PACKAGES_DIR}/debug/bin/${file_name}.pdb"
+        )
+        if(NOT VCPKG_TARGET_BUNDLE_SUFFIX STREQUAL "")
+            file(REMOVE_RECURSE
+                "${CURRENT_PACKAGES_DIR}/bin/${file_name}${VCPKG_TARGET_BUNDLE_SUFFIX}"
+                "${CURRENT_PACKAGES_DIR}/debug/bin/${file_name}${VCPKG_TARGET_BUNDLE_SUFFIX}"
+            )
+        endif()
+    endforeach()
+
+    z_vcpkg_clean_executables_in_bin_remove_directory_if_empty("${CURRENT_PACKAGES_DIR}/bin")
+    z_vcpkg_clean_executables_in_bin_remove_directory_if_empty("${CURRENT_PACKAGES_DIR}/debug/bin")
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_common_functions.cmake

@@ -0,0 +1,3 @@
+# DEPRECATED
+
+message("${Z_VCPKG_BACKCOMPAT_MESSAGE_LEVEL}" "vcpkg_common_functions has been removed and all values are automatically provided in all portfile.cmake invocations. Please remove `include(vcpkg_common_functions)`.")

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_cmake.cmake

@@ -0,0 +1,393 @@
+function(z_vcpkg_configure_cmake_both_or_neither_set var1 var2)
+    if(DEFINED "${var1}" AND NOT DEFINED "${var2}")
+        message(FATAL_ERROR "If ${var1} is set, ${var2} must be set.")
+    endif()
+    if(NOT DEFINED "${var1}" AND DEFINED "${var2}")
+        message(FATAL_ERROR "If ${var2} is set, ${var1} must be set.")
+    endif()
+endfunction()
+function(z_vcpkg_configure_cmake_build_cmakecache out_var whereat build_type)
+    set(line "build ${whereat}/CMakeCache.txt: CreateProcess\n")
+    string(APPEND line "  process = \"${CMAKE_COMMAND}\" -E chdir \"${whereat}\"")
+    foreach(arg IN LISTS "${build_type}_command")
+        string(APPEND line " \"${arg}\"")
+    endforeach()
+    set("${out_var}" "${${out_var}}${line}\n\n" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_get_visual_studio_generator)
+    cmake_parse_arguments(PARSE_ARGV 0 arg "" "OUT_GENERATOR;OUT_ARCH" "")
+    
+    if (NOT DEFINED arg_OUT_GENERATOR)
+        message(FATAL_ERROR "OUT_GENERATOR must be defined.")
+    endif()
+    if(NOT DEFINED arg_OUT_ARCH)
+        message(FATAL_ERROR "OUT_ARCH must be defined.")
+    endif()
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+            message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(DEFINED ENV{VisualStudioVersion})
+        if("$ENV{VisualStudioVersion}" VERSION_LESS_EQUAL  "12.99" AND
+           "$ENV{VisualStudioVersion}" VERSION_GREATER_EQUAL  "12.0" AND
+           NOT "${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "arm64")
+            set(generator "Visual Studio 12 2013")
+        elseif("$ENV{VisualStudioVersion}" VERSION_LESS_EQUAL  "14.99" AND
+               NOT "${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "arm64")
+            set(generator "Visual Studio 14 2015")
+        elseif("$ENV{VisualStudioVersion}" VERSION_LESS_EQUAL  "15.99")
+            set(generator "Visual Studio 15 2017")
+        elseif("$ENV{VisualStudioVersion}" VERSION_LESS_EQUAL  "16.99")
+            set(generator "Visual Studio 16 2019")
+        elseif("$ENV{VisualStudioVersion}" VERSION_LESS_EQUAL  "17.99")
+            set(generator "Visual Studio 17 2022")
+        endif()
+    endif()
+
+    if("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "x86")
+        set(generator_arch "Win32")
+    elseif("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "x64")
+        set(generator_arch "x64")
+    elseif("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "arm")
+        set(generator_arch "ARM")
+    elseif("${VCPKG_TARGET_ARCHITECTURE}" STREQUAL "arm64")
+        set(generator_arch "ARM64")
+    endif()
+    set(${arg_OUT_GENERATOR} "${generator}" PARENT_SCOPE)
+    set(${arg_OUT_ARCH} "${generator_arch}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_select_default_vcpkg_chainload_toolchain)
+    # Try avoiding adding more defaults here. 
+    # Set VCPKG_CHAINLOAD_TOOLCHAIN_FILE explicitly in the triplet.
+    if(DEFINED Z_VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
+        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${Z_VCPKG_CHAINLOAD_TOOLCHAIN_FILE}")
+    elseif(VCPKG_TARGET_IS_MINGW)
+        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/mingw.cmake")
+    elseif(VCPKG_TARGET_IS_WINDOWS)
+        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/windows.cmake")
+    elseif(VCPKG_TARGET_IS_LINUX)
+        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/linux.cmake")
+    elseif(VCPKG_TARGET_IS_ANDROID)
+        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/android.cmake")
+    elseif(VCPKG_TARGET_IS_OSX)
+        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/osx.cmake")
+    elseif(VCPKG_TARGET_IS_IOS)
+        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/ios.cmake")
+    elseif(VCPKG_TARGET_IS_FREEBSD)
+        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/freebsd.cmake")
+    elseif(VCPKG_TARGET_IS_OPENBSD)
+        set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE "${SCRIPTS}/toolchains/openbsd.cmake")
+    endif()
+    set(VCPKG_CHAINLOAD_TOOLCHAIN_FILE ${VCPKG_CHAINLOAD_TOOLCHAIN_FILE} PARENT_SCOPE)
+endfunction()
+
+
+function(vcpkg_configure_cmake)
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "PREFER_NINJA;DISABLE_PARALLEL_CONFIGURE;NO_CHARSET_FLAG;Z_GET_CMAKE_VARS_USAGE"
+        "SOURCE_PATH;GENERATOR;LOGNAME"
+        "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;MAYBE_UNUSED_VARIABLES"
+    )
+
+    if(NOT arg_Z_GET_CMAKE_VARS_USAGE AND Z_VCPKG_CMAKE_CONFIGURE_GUARD)
+        message(FATAL_ERROR "The ${PORT} port already depends on vcpkg-cmake; using both vcpkg-cmake and vcpkg_configure_cmake in the same port is unsupported.")
+    endif()
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT DEFINED arg_SOURCE_PATH)
+        message(FATAL_ERROR "SOURCE_PATH must be specified")
+    endif()
+    if(NOT DEFINED arg_LOGNAME)
+        set(arg_LOGNAME "config-${TARGET_TRIPLET}")
+    endif()
+
+    vcpkg_list(SET manually_specified_variables)
+
+    if(arg_Z_GET_CMAKE_VARS_USAGE)
+        set(configuring_message "Getting CMake variables for ${TARGET_TRIPLET}")
+    else()
+        set(configuring_message "Configuring ${TARGET_TRIPLET}")
+
+        foreach(option IN LISTS arg_OPTIONS arg_OPTIONS_RELEASE arg_OPTIONS_DEBUG)
+            if("${option}" MATCHES "^-D([^:=]*)[:=]")
+                vcpkg_list(APPEND manually_specified_variables "${CMAKE_MATCH_1}")
+            endif()
+        endforeach()
+        vcpkg_list(REMOVE_DUPLICATES manually_specified_variables)
+        foreach(maybe_unused_var IN LISTS arg_MAYBE_UNUSED_VARIABLES)
+            vcpkg_list(REMOVE_ITEM manually_specified_variables "${maybe_unused_var}")
+        endforeach()
+        debug_message("manually specified variables: ${manually_specified_variables}")
+    endif()
+
+    set(ninja_can_be_used ON) # Ninja as generator
+    set(ninja_host ON) # Ninja as parallel configurator
+
+    if(NOT arg_PREFER_NINJA AND VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
+        set(ninja_can_be_used OFF)
+    endif()
+
+    if(VCPKG_HOST_IS_WINDOWS)
+        if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+            set(host_arch "$ENV{PROCESSOR_ARCHITEW6432}")
+        else()
+            set(host_arch "$ENV{PROCESSOR_ARCHITECTURE}")
+        endif()
+
+        if("${host_arch}" STREQUAL "x86")
+            # Prebuilt ninja binaries are only provided for x64 hosts
+            set(ninja_can_be_used OFF)
+            set(ninja_host OFF)
+        endif()
+    endif()
+
+    set(generator "Ninja") # the default generator is always ninja!
+    set(generator_arch "")
+    if(DEFINED arg_GENERATOR)
+        set(generator "${arg_GENERATOR}")
+    elseif(NOT ninja_can_be_used)
+        set(generator "")
+        z_vcpkg_get_visual_studio_generator(OUT_GENERATOR generator OUT_ARCH generator_arch)
+        if("${generator}" STREQUAL "" OR "${generator_arch}" STREQUAL "")
+            message(FATAL_ERROR
+                "Unable to determine appropriate generator for triplet ${TARGET_TRIPLET}:
+    ENV{VisualStudioVersion} : $ENV{VisualStudioVersion}
+    platform toolset: ${VCPKG_PLATFORM_TOOLSET}
+    architecture    : ${VCPKG_TARGET_ARCHITECTURE}")
+        endif()
+        if(DEFINED VCPKG_PLATFORM_TOOLSET)
+            vcpkg_list(APPEND arg_OPTIONS "-T${VCPKG_PLATFORM_TOOLSET}")
+        endif()
+    endif()
+
+    # If we use Ninja, make sure it's on PATH
+    if("${generator}" STREQUAL "Ninja" AND NOT DEFINED ENV{VCPKG_FORCE_SYSTEM_BINARIES})
+        vcpkg_find_acquire_program(NINJA)
+        get_filename_component(ninja_path "${NINJA}" DIRECTORY)
+        vcpkg_add_to_path("${ninja_path}")
+        vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_MAKE_PROGRAM=${NINJA}")
+    endif()
+
+    file(REMOVE_RECURSE
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
+        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
+
+    if(DEFINED VCPKG_CMAKE_SYSTEM_NAME)
+        vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_SYSTEM_NAME=${VCPKG_CMAKE_SYSTEM_NAME}")
+        if(VCPKG_TARGET_IS_UWP AND NOT DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
+            set(VCPKG_CMAKE_SYSTEM_VERSION 10.0)
+        elseif(VCPKG_TARGET_IS_ANDROID AND NOT DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
+            set(VCPKG_CMAKE_SYSTEM_VERSION 21)
+        endif()
+    endif()
+
+    if(DEFINED VCPKG_XBOX_CONSOLE_TARGET)
+        vcpkg_list(APPEND arg_OPTIONS "-DXBOX_CONSOLE_TARGET=${VCPKG_XBOX_CONSOLE_TARGET}")
+    endif()
+
+    if(DEFINED VCPKG_CMAKE_SYSTEM_VERSION)
+        vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_SYSTEM_VERSION=${VCPKG_CMAKE_SYSTEM_VERSION}")
+    endif()
+
+    if("${VCPKG_LIBRARY_LINKAGE}" STREQUAL "dynamic")
+        vcpkg_list(APPEND arg_OPTIONS -DBUILD_SHARED_LIBS=ON)
+    elseif("${VCPKG_LIBRARY_LINKAGE}" STREQUAL "static")
+        vcpkg_list(APPEND arg_OPTIONS -DBUILD_SHARED_LIBS=OFF)
+    else()
+        message(FATAL_ERROR
+            "Invalid setting for VCPKG_LIBRARY_LINKAGE: \"${VCPKG_LIBRARY_LINKAGE}\".
+    It must be \"static\" or \"dynamic\"")
+    endif()
+
+    z_vcpkg_configure_cmake_both_or_neither_set(VCPKG_CXX_FLAGS_DEBUG VCPKG_C_FLAGS_DEBUG)
+    z_vcpkg_configure_cmake_both_or_neither_set(VCPKG_CXX_FLAGS_RELEASE VCPKG_C_FLAGS_RELEASE)
+    z_vcpkg_configure_cmake_both_or_neither_set(VCPKG_CXX_FLAGS VCPKG_C_FLAGS)
+
+    set(vcpkg_set_charset_flag ON)
+    if(arg_NO_CHARSET_FLAG)
+        set(vcpkg_set_charset_flag OFF)
+    endif()
+
+    if(NOT VCPKG_CHAINLOAD_TOOLCHAIN_FILE)
+        z_vcpkg_select_default_vcpkg_chainload_toolchain()
+    endif()
+
+    vcpkg_list(APPEND arg_OPTIONS
+        "-DVCPKG_CHAINLOAD_TOOLCHAIN_FILE=${VCPKG_CHAINLOAD_TOOLCHAIN_FILE}"
+        "-DVCPKG_TARGET_TRIPLET=${TARGET_TRIPLET}"
+        "-DVCPKG_SET_CHARSET_FLAG=${vcpkg_set_charset_flag}"
+        "-DVCPKG_PLATFORM_TOOLSET=${VCPKG_PLATFORM_TOOLSET}"
+        "-DCMAKE_EXPORT_NO_PACKAGE_REGISTRY=ON"
+        "-DCMAKE_FIND_PACKAGE_NO_PACKAGE_REGISTRY=ON"
+        "-DCMAKE_FIND_PACKAGE_NO_SYSTEM_PACKAGE_REGISTRY=ON"
+        "-DCMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP=TRUE"
+        "-DCMAKE_VERBOSE_MAKEFILE=ON"
+        "-DVCPKG_APPLOCAL_DEPS=OFF"
+        "-DCMAKE_TOOLCHAIN_FILE=${SCRIPTS}/buildsystems/vcpkg.cmake"
+        "-DCMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION=ON"
+        "-DVCPKG_CXX_FLAGS=${VCPKG_CXX_FLAGS}"
+        "-DVCPKG_CXX_FLAGS_RELEASE=${VCPKG_CXX_FLAGS_RELEASE}"
+        "-DVCPKG_CXX_FLAGS_DEBUG=${VCPKG_CXX_FLAGS_DEBUG}"
+        "-DVCPKG_C_FLAGS=${VCPKG_C_FLAGS}"
+        "-DVCPKG_C_FLAGS_RELEASE=${VCPKG_C_FLAGS_RELEASE}"
+        "-DVCPKG_C_FLAGS_DEBUG=${VCPKG_C_FLAGS_DEBUG}"
+        "-DVCPKG_CRT_LINKAGE=${VCPKG_CRT_LINKAGE}"
+        "-DVCPKG_LINKER_FLAGS=${VCPKG_LINKER_FLAGS}"
+        "-DVCPKG_LINKER_FLAGS_RELEASE=${VCPKG_LINKER_FLAGS_RELEASE}"
+        "-DVCPKG_LINKER_FLAGS_DEBUG=${VCPKG_LINKER_FLAGS_DEBUG}"
+        "-DVCPKG_TARGET_ARCHITECTURE=${VCPKG_TARGET_ARCHITECTURE}"
+        "-DCMAKE_INSTALL_LIBDIR:STRING=lib"
+        "-DCMAKE_INSTALL_BINDIR:STRING=bin"
+        "-D_VCPKG_ROOT_DIR=${VCPKG_ROOT_DIR}"
+        "-DZ_VCPKG_ROOT_DIR=${VCPKG_ROOT_DIR}"
+        "-D_VCPKG_INSTALLED_DIR=${_VCPKG_INSTALLED_DIR}"
+        "-DVCPKG_MANIFEST_INSTALL=OFF"
+    )
+
+    if(NOT "${generator_arch}" STREQUAL "")
+        vcpkg_list(APPEND arg_OPTIONS "-A${generator_arch}")
+    endif()
+
+    # Sets configuration variables for macOS builds
+    foreach(config_var IN ITEMS INSTALL_NAME_DIR OSX_DEPLOYMENT_TARGET OSX_SYSROOT OSX_ARCHITECTURES)
+        if(DEFINED "VCPKG_${config_var}")
+            vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_${config_var}=${VCPKG_${config_var}}")
+        endif()
+    endforeach()
+
+    # Allow overrides / additional configuration variables from triplets
+    if(DEFINED VCPKG_CMAKE_CONFIGURE_OPTIONS)
+        vcpkg_list(APPEND arg_OPTIONS ${VCPKG_CMAKE_CONFIGURE_OPTIONS})
+    endif()
+    if(DEFINED VCPKG_CMAKE_CONFIGURE_OPTIONS_RELEASE)
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE ${VCPKG_CMAKE_CONFIGURE_OPTIONS_RELEASE})
+    endif()
+    if(DEFINED VCPKG_CMAKE_CONFIGURE_OPTIONS_DEBUG)
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG ${VCPKG_CMAKE_CONFIGURE_OPTIONS_DEBUG})
+    endif()
+
+    vcpkg_list(SET rel_command
+        "${CMAKE_COMMAND}" "${arg_SOURCE_PATH}" 
+        -G "${generator}"
+        "-DCMAKE_BUILD_TYPE=Release"
+        "-DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR}"
+        ${arg_OPTIONS} ${arg_OPTIONS_RELEASE})
+    vcpkg_list(SET dbg_command
+        "${CMAKE_COMMAND}" "${arg_SOURCE_PATH}" 
+        -G "${generator}"
+        "-DCMAKE_BUILD_TYPE=Debug"
+        "-DCMAKE_INSTALL_PREFIX=${CURRENT_PACKAGES_DIR}/debug"
+        ${arg_OPTIONS} ${arg_OPTIONS_DEBUG})
+
+    if(ninja_host AND CMAKE_HOST_WIN32 AND NOT arg_DISABLE_PARALLEL_CONFIGURE)
+        vcpkg_list(APPEND arg_OPTIONS "-DCMAKE_DISABLE_SOURCE_CHANGES=ON")
+
+        vcpkg_find_acquire_program(NINJA)
+        if(NOT DEFINED ninja_path)
+            # if ninja_path was defined above, we've already done this
+            get_filename_component(ninja_path "${NINJA}" DIRECTORY)
+            vcpkg_add_to_path("${ninja_path}")
+        endif()
+
+        #parallelize the configure step
+        set(ninja_configure_contents
+            "rule CreateProcess\n  command = \$process\n\n"
+        )
+
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "release")
+            z_vcpkg_configure_cmake_build_cmakecache(ninja_configure_contents ".." "rel")
+        endif()
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "debug")
+            z_vcpkg_configure_cmake_build_cmakecache(ninja_configure_contents "../../${TARGET_TRIPLET}-dbg" "dbg")
+        endif()
+
+        file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure")
+        file(WRITE
+            "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure/build.ninja"
+            "${ninja_configure_contents}")
+
+        message(STATUS "${configuring_message}")
+        vcpkg_execute_required_process(
+            COMMAND "${NINJA}" -v
+            WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel/vcpkg-parallel-configure"
+            LOGNAME "${arg_LOGNAME}"
+            SAVE_LOG_FILES
+                "../../${TARGET_TRIPLET}-dbg/CMakeCache.txt" ALIAS "dbg-CMakeCache.txt.log"
+                "../CMakeCache.txt" ALIAS "rel-CMakeCache.txt.log"
+        )
+        
+        vcpkg_list(APPEND config_logs
+            "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out.log"
+            "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-err.log")
+    else()
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "debug")
+            message(STATUS "${configuring_message}-dbg")
+            file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
+            vcpkg_execute_required_process(
+                COMMAND ${dbg_command}
+                WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg"
+                LOGNAME "${arg_LOGNAME}-dbg"
+                SAVE_LOG_FILES CMakeCache.txt
+            )
+            vcpkg_list(APPEND config_logs
+                "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-dbg-out.log"
+                "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-dbg-err.log")
+        endif()
+
+        if(NOT DEFINED VCPKG_BUILD_TYPE OR "${VCPKG_BUILD_TYPE}" STREQUAL "release")
+            message(STATUS "${configuring_message}-rel")
+            file(MAKE_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
+            vcpkg_execute_required_process(
+                COMMAND ${rel_command}
+                WORKING_DIRECTORY "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel"
+                LOGNAME "${arg_LOGNAME}-rel"
+                SAVE_LOG_FILES CMakeCache.txt
+            )
+            vcpkg_list(APPEND config_logs
+                "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-rel-out.log"
+                "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-rel-err.log")
+        endif()
+    endif()
+    
+    # Check unused variables
+    vcpkg_list(SET all_unused_variables)
+    foreach(config_log IN LISTS config_logs)
+        if(NOT EXISTS "${config_log}")
+            continue()
+        endif()
+        file(READ "${config_log}" log_contents)
+        debug_message("Reading configure log ${config_log}...")
+        if(NOT "${log_contents}" MATCHES "Manually-specified variables were not used by the project:\n\n((    [^\n]*\n)*)")
+            continue()
+        endif()
+        string(STRIP "${CMAKE_MATCH_1}" unused_variables) # remove leading `    ` and trailing `\n`
+        string(REPLACE "\n    " ";" unused_variables "${unused_variables}")
+        debug_message("unused variables: ${unused_variables}")
+
+        foreach(unused_variable IN LISTS unused_variables)
+            if("${unused_variable}" IN_LIST manually_specified_variables)
+                debug_message("manually specified unused variable: ${unused_variable}")
+                vcpkg_list(APPEND all_unused_variables "${unused_variable}")
+            else()
+                debug_message("unused variable (not manually specified): ${unused_variable}")
+            endif()
+        endforeach()
+    endforeach()
+
+    if(NOT "${all_unused_variables}" STREQUAL "")
+        vcpkg_list(REMOVE_DUPLICATES all_unused_variables)
+        vcpkg_list(JOIN all_unused_variables "\n    " all_unused_variables)
+        message(WARNING "The following variables are not used in CMakeLists.txt:
+    ${all_unused_variables}
+Please recheck them and remove the unnecessary options from the `vcpkg_configure_cmake` call.
+If these options should still be passed for whatever reason, please use the `MAYBE_UNUSED_VARIABLES` argument.")
+    endif()
+
+    if(NOT arg_Z_GET_CMAKE_VARS_USAGE)
+        set(Z_VCPKG_CMAKE_GENERATOR "${generator}" PARENT_SCOPE)
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_make.cmake

@@ -0,0 +1,912 @@
+macro(z_vcpkg_determine_autotools_host_cpu out_var)
+    # TODO: the host system processor architecture can differ from the host triplet target architecture
+    if(DEFINED ENV{PROCESSOR_ARCHITEW6432})
+        set(host_arch $ENV{PROCESSOR_ARCHITEW6432})
+    elseif(DEFINED ENV{PROCESSOR_ARCHITECTURE})
+        set(host_arch $ENV{PROCESSOR_ARCHITECTURE})
+    else()
+        set(host_arch "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
+    endif()
+    if(host_arch MATCHES "(amd|AMD)64")
+        set(${out_var} x86_64)
+    elseif(host_arch MATCHES "(x|X)86")
+        set(${out_var} i686)
+    elseif(host_arch MATCHES "^(ARM|arm)64$")
+        set(${out_var} aarch64)
+    elseif(host_arch MATCHES "^(ARM|arm)$")
+        set(${out_var} arm)
+    else()
+        message(FATAL_ERROR "Unsupported host architecture ${host_arch} in z_vcpkg_determine_autotools_host_cpu!" )
+    endif()
+    unset(host_arch)
+endmacro()
+
+macro(z_vcpkg_determine_autotools_target_cpu out_var)
+    if(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)64")
+        set(${out_var} x86_64)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "(x|X)86")
+        set(${out_var} i686)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)64$")
+        set(${out_var} aarch64)
+    elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^(ARM|arm)$")
+        set(${out_var} arm)
+    else()
+        message(FATAL_ERROR "Unsupported VCPKG_TARGET_ARCHITECTURE architecture ${VCPKG_TARGET_ARCHITECTURE} in z_vcpkg_determine_autotools_target_cpu!" )
+    endif()
+endmacro()
+
+macro(z_vcpkg_set_arch_mac out_var value)
+    # Better match the arch behavior of config.guess
+    # See: https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+    if("${value}" MATCHES "^(ARM|arm)64$")
+        set(${out_var} "aarch64")
+    else()
+        set(${out_var} "${value}")
+    endif()
+endmacro()
+
+macro(z_vcpkg_determine_autotools_host_arch_mac out_var)
+    z_vcpkg_set_arch_mac(${out_var} "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
+endmacro()
+
+macro(z_vcpkg_determine_autotools_target_arch_mac out_var)
+    list(LENGTH VCPKG_OSX_ARCHITECTURES osx_archs_num)
+    if(osx_archs_num EQUAL 0)
+        z_vcpkg_set_arch_mac(${out_var} "${VCPKG_DETECTED_CMAKE_HOST_SYSTEM_PROCESSOR}")
+    elseif(osx_archs_num GREATER_EQUAL 2)
+        set(${out_var} "universal")
+    else()
+        z_vcpkg_set_arch_mac(${out_var} "${VCPKG_OSX_ARCHITECTURES}")
+    endif()
+    unset(osx_archs_num)
+endmacro()
+
+# Define variables used in both vcpkg_configure_make and vcpkg_build_make:
+# short_name_<CONFIG>:           unique abbreviation for the given build type (rel, dbg)
+# path_suffix_<CONFIG>:          installation path suffix for the given build type ('', /debug)
+# current_installed_dir_escaped: CURRENT_INSTALLED_DIR with escaped space characters
+# current_installed_dir_msys:    CURRENT_INSTALLED_DIR with unprotected spaces, but drive letters transformed for msys
+macro(z_vcpkg_configure_make_common_definitions)
+    set(short_name_RELEASE "rel")
+    set(short_name_DEBUG "dbg")
+
+    set(path_suffix_RELEASE "")
+    set(path_suffix_DEBUG "/debug")
+
+    # Some PATH handling for dealing with spaces....some tools will still fail with that!
+    # In particular, the libtool install command is unable to install correctly to paths with spaces.
+    string(REPLACE " " "\\ " current_installed_dir_escaped "${CURRENT_INSTALLED_DIR}")
+    set(current_installed_dir_msys "${CURRENT_INSTALLED_DIR}")
+    if(CMAKE_HOST_WIN32)
+        string(REGEX REPLACE "^([a-zA-Z]):/" "/\\1/" current_installed_dir_msys "${current_installed_dir_msys}")
+    endif()
+endmacro()
+
+# Initializes well-known and auxiliary variables for flags
+# - CPPFLAGS_<CONFIG>: preprocessor flags common to C and CXX
+# - CFLAGS_<CONFIG>
+# - CXXFLAGS_<CONFIG>
+# - LDFLAGS_<CONFIG>
+# - ARFLAGS_<CONFIG>
+# - LINK_ENV_${var_suffix}
+# Prerequisite: VCPKG_DETECTED_CMAKE_... vars loaded
+function(z_vcpkg_configure_make_process_flags var_suffix)
+    # separate_arguments is needed to remove outer quotes from detected cmake variables.
+    # (e.g. Android NDK has "--sysroot=...")
+    separate_arguments(CFLAGS NATIVE_COMMAND "Z_VCM_WRAP ${VCPKG_DETECTED_CMAKE_C_FLAGS_${var_suffix}} Z_VCM_WRAP")
+    separate_arguments(CXXFLAGS NATIVE_COMMAND "Z_VCM_WRAP ${VCPKG_DETECTED_CMAKE_CXX_FLAGS_${var_suffix}} Z_VCM_WRAP")
+    separate_arguments(LDFLAGS NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${var_suffix}}")
+    separate_arguments(ARFLAGS NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${var_suffix}}")
+    foreach(var IN ITEMS CFLAGS CXXFLAGS LDFLAGS ARFLAGS)
+        vcpkg_list(APPEND z_vcm_all_flags ${${var}})
+    endforeach()
+    set(z_vcm_all_flags "${z_vcm_all_flags}" PARENT_SCOPE)
+
+    # Filter common CPPFLAGS out of CFLAGS and CXXFLAGS
+    vcpkg_list(SET CPPFLAGS)
+    vcpkg_list(SET pattern)
+    foreach(arg IN LISTS CXXFLAGS)
+        if(arg STREQUAL "Z_VCM_WRAP")
+            continue()
+        elseif(NOT pattern STREQUAL "")
+            vcpkg_list(APPEND pattern "${arg}")
+        elseif(arg MATCHES "^-(D|isystem).")
+            vcpkg_list(SET pattern "${arg}")
+        elseif(arg MATCHES "^-(D|isystem)\$")
+            vcpkg_list(SET pattern "${arg}")
+            continue()
+        elseif(arg MATCHES "^-(-sysroot|-target|m?[Aa][Rr][Cc][Hh])=.")
+            vcpkg_list(SET pattern "${arg}")
+        elseif(arg MATCHES "^-(isysroot|m32|m64|m?[Aa][Rr][Cc][Hh]|target)\$")
+            vcpkg_list(SET pattern "${arg}")
+            continue()
+        else()
+            continue()
+        endif()
+        string(FIND "${CFLAGS}" ";${pattern};" index)
+        if(NOT index STREQUAL "-1")
+            vcpkg_list(APPEND CPPFLAGS ${pattern})
+            string(REPLACE ";${pattern};" ";" CFLAGS "${CFLAGS}")
+            string(REPLACE ";${pattern};" ";" CXXFLAGS "${CXXFLAGS}")
+        endif()
+        vcpkg_list(SET pattern)
+    endforeach()
+    vcpkg_list(SET pattern)
+    foreach(arg IN LISTS CFLAGS)
+        if(arg STREQUAL "Z_VCM_WRAP")
+            continue()
+        elseif(NOT pattern STREQUAL "")
+            vcpkg_list(APPEND pattern "${arg}")
+        elseif(arg MATCHES "^-(D|isystem)\$")
+            vcpkg_list(SET pattern "${arg}")
+            continue()
+        elseif(arg MATCHES "^-(D|isystem).")
+            vcpkg_list(SET pattern "${arg}")
+        elseif(arg MATCHES "^-(-sysroot|-target|m?[Aa][Rr][Cc][Hh])=.")
+            vcpkg_list(SET pattern "${arg}")
+        elseif(arg MATCHES "^-(isysroot|m32|m64|m?[Aa][Rr][Cc][Hh]|target)\$")
+            vcpkg_list(SET pattern "${arg}")
+            continue()
+        else()
+            continue()
+        endif()
+        string(FIND "${CXXFLAGS}" ";${pattern};" index)
+        if(NOT index STREQUAL "-1")
+            vcpkg_list(APPEND CPPFLAGS ${pattern})
+            string(REPLACE ";${pattern};" ";" CFLAGS "${CFLAGS}")
+            string(REPLACE ";${pattern};" ";" CXXFLAGS "${CXXFLAGS}")
+        endif()
+        vcpkg_list(SET pattern)
+    endforeach()
+
+    # Remove start/end placeholders
+    foreach(list IN ITEMS CFLAGS CXXFLAGS)
+        vcpkg_list(REMOVE_ITEM ${list} "Z_VCM_WRAP")
+    endforeach()
+
+    # libtool tries to filter CFLAGS passed to the link stage via a whitelist.
+    # This approach is flawed since it fails to pass flags unknown to libtool
+    # but required for linking to the link stage (e.g. -fsanitize=<x>).
+    # libtool has an -R option so we need to guard against -RTC by using -Xcompiler.
+    # While configuring there might be a lot of unknown compiler option warnings
+    # due to that; just ignore them.
+    set(compiler_flag_escape "")
+    if(VCPKG_DETECTED_CMAKE_C_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC" OR VCPKG_DETECTED_CMAKE_C_COMPILER_ID STREQUAL "MSVC")
+        set(compiler_flag_escape "-Xcompiler ")
+    endif()
+    if(compiler_flag_escape)
+        list(TRANSFORM CFLAGS PREPEND "${compiler_flag_escape}")
+        list(TRANSFORM CXXFLAGS PREPEND "${compiler_flag_escape}")
+    endif()
+
+    # Could use a future VCPKG_DETECTED_CMAKE_LIBRARY_PATH_FLAG
+    set(library_path_flag "-L")
+    # Could use a future VCPKG_DETECTED_MSVC
+    if(VCPKG_TARGET_IS_WINDOWS AND VCPKG_DETECTED_CMAKE_LINKER MATCHES [[link\.exe$]])
+        set(library_path_flag "-LIBPATH:")
+    endif()
+    set(linker_flag_escape "")
+    if(VCPKG_TARGET_IS_WINDOWS AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES [[cl\.exe$]])
+        # Removed by libtool
+        set(linker_flag_escape "-Xlinker ")
+        if(arg_USE_WRAPPERS)
+            # 1st and 3rd are removed by libtool, 2nd by wrapper
+            set(linker_flag_escape "-Xlinker -Xlinker -Xlinker ")
+        endif()
+        if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
+            string(STRIP "$ENV{_LINK_} ${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_${var_suffix}}" LINK_ENV)
+        else()
+            string(STRIP "$ENV{_LINK_} ${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_${var_suffix}}" LINK_ENV)
+        endif()
+    endif()
+    if(linker_flag_escape)
+        list(TRANSFORM LDFLAGS PREPEND "${linker_flag_escape}")
+    endif()
+    if(EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${var_suffix}}/lib/manual-link")
+        vcpkg_list(PREPEND LDFLAGS "${linker_flag_escape}${library_path_flag}${current_installed_dir_escaped}${path_suffix_${var_suffix}}/lib/manual-link")
+    endif()
+    if(EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${var_suffix}}/lib")
+        vcpkg_list(PREPEND LDFLAGS "${linker_flag_escape}${library_path_flag}${current_installed_dir_escaped}${path_suffix_${var_suffix}}/lib")
+    endif()
+
+    if(ARFLAGS)
+        # ARFLAGS need to know the command for creating an archive (Maybe needs user customization?)
+        # or extract it from CMake via CMAKE_${lang}_ARCHIVE_CREATE ?
+        # or from CMAKE_${lang}_${rule} with rule being one of CREATE_SHARED_MODULE CREATE_SHARED_LIBRARY LINK_EXECUTABLE
+        vcpkg_list(PREPEND ARFLAGS "cr")
+    endif()
+
+    foreach(var IN ITEMS CPPFLAGS CFLAGS CXXFLAGS LDFLAGS ARFLAGS)
+        list(JOIN ${var} " " string)
+        set(${var}_${var_suffix} "${string}" PARENT_SCOPE)
+    endforeach()
+endfunction()
+
+macro(z_vcpkg_append_to_configure_environment inoutstring var defaultval)
+    # Allows to overwrite settings in custom triplets via the environment on windows
+    if(CMAKE_HOST_WIN32 AND DEFINED ENV{${var}})
+        string(APPEND ${inoutstring} " ${var}='$ENV{${var}}'")
+    else()
+        string(APPEND ${inoutstring} " ${var}='${defaultval}'")
+    endif()
+endmacro()
+
+function(vcpkg_configure_make)
+    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "AUTOCONFIG;SKIP_CONFIGURE;COPY_SOURCE;DISABLE_VERBOSE_FLAGS;NO_ADDITIONAL_PATHS;ADD_BIN_TO_PATH;NO_DEBUG;USE_WRAPPERS;NO_WRAPPERS;DETERMINE_BUILD_TRIPLET"
+        "SOURCE_PATH;PROJECT_SUBPATH;PRERUN_SHELL;BUILD_TRIPLET"
+        "OPTIONS;OPTIONS_DEBUG;OPTIONS_RELEASE;CONFIGURE_ENVIRONMENT_VARIABLES;CONFIG_DEPENDENT_ENVIRONMENT;ADDITIONAL_MSYS_PACKAGES"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+
+    if(arg_USE_WRAPPERS AND arg_NO_WRAPPERS)
+        message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed conflicting options USE_WRAPPERS and NO_WRAPPERS. Please remove one of them!")
+    endif()
+
+    z_vcpkg_get_cmake_vars(cmake_vars_file)
+    debug_message("Including cmake vars from: ${cmake_vars_file}")
+    include("${cmake_vars_file}")
+
+    if(DEFINED VCPKG_MAKE_BUILD_TRIPLET)
+        set(arg_BUILD_TRIPLET ${VCPKG_MAKE_BUILD_TRIPLET}) # Triplet overwrite for crosscompiling
+    endif()
+
+    set(src_dir "${arg_SOURCE_PATH}/${arg_PROJECT_SUBPATH}")
+
+    set(requires_autogen OFF) # use autogen.sh
+    set(requires_autoconfig OFF) # use autotools and configure.ac
+    if(EXISTS "${src_dir}/configure" AND EXISTS "${src_dir}/configure.ac" AND arg_AUTOCONFIG) # remove configure; rerun autoconf
+        set(requires_autoconfig ON)
+        file(REMOVE "${SRC_DIR}/configure") # remove possible outdated configure scripts
+    elseif(arg_SKIP_CONFIGURE)
+        # no action requested
+    elseif(EXISTS "${src_dir}/configure")
+        # run normally; no autoconf or autogen required
+    elseif(EXISTS "${src_dir}/configure.ac") # Run autoconfig
+        set(requires_autoconfig ON)
+        set(arg_AUTOCONFIG ON)
+    elseif(EXISTS "${src_dir}/autogen.sh") # Run autogen
+        set(requires_autogen ON)
+    else()
+        message(FATAL_ERROR "Could not determine method to configure make")
+    endif()
+
+    debug_message("requires_autogen:${requires_autogen}")
+    debug_message("requires_autoconfig:${requires_autoconfig}")
+
+    if(CMAKE_HOST_WIN32 AND VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "cl.exe") #only applies to windows (clang-)cl and lib
+        if(arg_AUTOCONFIG)
+            set(arg_USE_WRAPPERS ON)
+        else()
+            # Keep the setting from portfiles.
+            # Without autotools we assume a custom configure script which correctly handles cl and lib.
+            # Otherwise the port needs to set CC|CXX|AR and probably CPP.
+        endif()
+    else()
+        set(arg_USE_WRAPPERS OFF)
+    endif()
+    if(arg_NO_WRAPPERS)
+        set(arg_USE_WRAPPERS OFF)
+    endif()
+
+    # Backup environment variables
+    # CCAS CC C CPP CXX FC FF GC LD LF LIBTOOL OBJC OBJCXX R UPC Y 
+    set(cm_FLAGS AR AS CCAS CC C CPP CXX FC FF GC LD LF LIBTOOL OBJC OBJXX R UPC Y RC)
+    list(TRANSFORM cm_FLAGS APPEND "FLAGS")
+    vcpkg_backup_env_variables(VARS ${cm_FLAGS})
+
+
+    # FC fotran compiler | FF Fortran 77 compiler 
+    # LDFLAGS -> pass -L flags
+    # LIBS -> pass -l flags
+
+    # Used by gcc/linux
+    vcpkg_backup_env_variables(VARS C_INCLUDE_PATH CPLUS_INCLUDE_PATH LIBRARY_PATH LD_LIBRARY_PATH)
+
+    # Used by cl
+    vcpkg_backup_env_variables(VARS INCLUDE LIB LIBPATH)
+
+    vcpkg_list(SET z_vcm_paths_with_spaces)
+    if(CURRENT_PACKAGES_DIR MATCHES " ")
+        vcpkg_list(APPEND z_vcm_paths_with_spaces "${CURRENT_PACKAGES_DIR}")
+    endif()
+    if(CURRENT_INSTALLED_DIR MATCHES " ")
+        vcpkg_list(APPEND z_vcm_paths_with_spaces "${CURRENT_INSTALLED_DIR}")
+    endif()
+    if(z_vcm_paths_with_spaces)
+        # Don't bother with whitespace. The tools will probably fail and I tried very hard trying to make it work (no success so far)!
+        vcpkg_list(APPEND z_vcm_paths_with_spaces "Please move the path to one without whitespaces!")
+        list(JOIN z_vcm_paths_with_spaces "\n   " z_vcm_paths_with_spaces)
+        message(STATUS "Warning: Paths with embedded space may be handled incorrectly by configure:\n   ${z_vcm_paths_with_spaces}")
+    endif()
+
+    set(configure_env "V=1")
+
+    # Establish a bash environment as expected by autotools.
+    if(CMAKE_HOST_WIN32)
+        list(APPEND msys_require_packages autoconf-wrapper automake-wrapper binutils libtool make pkgconf which)
+        vcpkg_acquire_msys(MSYS_ROOT PACKAGES ${msys_require_packages} ${arg_ADDITIONAL_MSYS_PACKAGES})
+        set(base_cmd "${MSYS_ROOT}/usr/bin/bash.exe" --noprofile --norc --debug)
+        vcpkg_list(SET add_to_env)
+        if(arg_USE_WRAPPERS AND VCPKG_TARGET_IS_WINDOWS)
+            vcpkg_list(APPEND add_to_env "${SCRIPTS}/buildsystems/make_wrapper") # Other required wrappers are also located there
+            vcpkg_list(APPEND add_to_env "${MSYS_ROOT}/usr/share/automake-1.16")
+        endif()
+        cmake_path(CONVERT "$ENV{PATH}" TO_CMAKE_PATH_LIST path_list NORMALIZE)
+        cmake_path(CONVERT "$ENV{SystemRoot}" TO_CMAKE_PATH_LIST system_root NORMALIZE)
+        cmake_path(CONVERT "$ENV{LOCALAPPDATA}" TO_CMAKE_PATH_LIST local_app_data NORMALIZE)
+        file(REAL_PATH "${system_root}" system_root)
+
+        message(DEBUG "path_list:${path_list}") # Just to have --trace-expand output
+
+        vcpkg_list(SET find_system_dirs 
+            "${system_root}/System32"
+            "${system_root}/System32/"
+            "${local_app_data}/Microsoft/WindowsApps"
+            "${local_app_data}/Microsoft/WindowsApps/"
+        )
+
+        string(TOUPPER "${find_system_dirs}" find_system_dirs_upper)
+
+        set(index 0)
+        set(appending TRUE)
+        foreach(item IN LISTS path_list)
+            string(TOUPPER "${item}" item_upper)
+            if(item_upper IN_LIST find_system_dirs_upper)
+                set(appending FALSE)
+                break()
+            endif()
+            math(EXPR index "${index} + 1")
+        endforeach()
+
+        if(appending)
+            message(WARNING "Unable to find system dir in the PATH variable! Appending required msys paths!")
+        endif()
+        vcpkg_list(INSERT path_list "${index}" ${add_to_env} "${MSYS_ROOT}/usr/bin")
+
+        cmake_path(CONVERT "${path_list}" TO_NATIVE_PATH_LIST native_path_list)
+        set(ENV{PATH} "${native_path_list}")
+    else()
+        find_program(base_cmd bash REQUIRED)
+    endif()
+
+   # macOS - cross-compiling support
+    if(VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_IOS)
+        if (requires_autoconfig AND NOT arg_BUILD_TRIPLET OR arg_DETERMINE_BUILD_TRIPLET)
+            z_vcpkg_determine_autotools_host_arch_mac(BUILD_ARCH) # machine you are building on => --build=
+            z_vcpkg_determine_autotools_target_arch_mac(TARGET_ARCH)
+            # --build: the machine you are building on
+            # --host: the machine you are building for
+            # --target: the machine that CC will produce binaries for
+            # https://stackoverflow.com/questions/21990021/how-to-determine-host-value-for-configure-when-using-cross-compiler
+            # Only for ports using autotools so we can assume that they follow the common conventions for build/target/host
+            if(NOT "${TARGET_ARCH}" STREQUAL "${BUILD_ARCH}" OR NOT VCPKG_TARGET_IS_OSX) # we don't need to specify the additional flags if we build natively.
+                set(arg_BUILD_TRIPLET "--host=${TARGET_ARCH}-apple-darwin") # (Host activates crosscompilation; The name given here is just the prefix of the host tools for the target)
+            endif()
+            debug_message("Using make triplet: ${arg_BUILD_TRIPLET}")
+        endif()
+    endif()
+
+    # Linux - cross-compiling support
+    if(VCPKG_TARGET_IS_LINUX)
+        if (requires_autoconfig AND NOT arg_BUILD_TRIPLET OR arg_DETERMINE_BUILD_TRIPLET)
+            # The regex below takes the prefix from the resulting CMAKE_C_COMPILER variable eg. arm-linux-gnueabihf-gcc 
+            # set in the common toolchains/linux.cmake
+            # This is used via --host as a prefix for all other bin tools as well. 
+            # Setting the compiler directly via CC=arm-linux-gnueabihf-gcc does not work acording to: 
+            # https://www.gnu.org/software/autoconf/manual/autoconf-2.65/html_node/Specifying-Target-Triplets.html
+            if(VCPKG_DETECTED_CMAKE_C_COMPILER MATCHES "([^\/]*)-gcc$" AND CMAKE_MATCH_1)
+                set(arg_BUILD_TRIPLET "--host=${CMAKE_MATCH_1}") # (Host activates crosscompilation; The name given here is just the prefix of the host tools for the target)
+            endif()
+            debug_message("Using make triplet: ${arg_BUILD_TRIPLET}")
+        endif()
+    endif()
+
+    # Pre-processing windows configure requirements
+    if (VCPKG_TARGET_IS_WINDOWS)
+        if (arg_DETERMINE_BUILD_TRIPLET OR NOT arg_BUILD_TRIPLET)
+            z_vcpkg_determine_autotools_host_cpu(BUILD_ARCH) # VCPKG_HOST => machine you are building on => --build=
+            z_vcpkg_determine_autotools_target_cpu(TARGET_ARCH)
+            # --build: the machine you are building on
+            # --host: the machine you are building for
+            # --target: the machine that CC will produce binaries for
+            # https://stackoverflow.com/questions/21990021/how-to-determine-host-value-for-configure-when-using-cross-compiler
+            # Only for ports using autotools so we can assume that they follow the common conventions for build/target/host
+            if(CMAKE_HOST_WIN32)
+                # Respect host triplet when determining --build
+                if(NOT VCPKG_CROSSCOMPILING)
+                    set(_win32_build_arch "${TARGET_ARCH}")
+                else()
+                    set(_win32_build_arch "${BUILD_ARCH}")
+                endif()
+
+                # This is required since we are running in a msys
+                # shell which will be otherwise identified as ${BUILD_ARCH}-pc-msys
+                set(arg_BUILD_TRIPLET "--build=${_win32_build_arch}-pc-mingw32")
+            endif()
+            if(NOT TARGET_ARCH MATCHES "${BUILD_ARCH}" OR NOT CMAKE_HOST_WIN32) # we don't need to specify the additional flags if we build nativly, this does not hold when we are not on windows
+                string(APPEND arg_BUILD_TRIPLET " --host=${TARGET_ARCH}-pc-mingw32") # (Host activates crosscompilation; The name given here is just the prefix of the host tools for the target)
+            endif()
+            if(VCPKG_TARGET_IS_UWP AND NOT arg_BUILD_TRIPLET MATCHES "--host")
+                # Needs to be different from --build to enable cross builds.
+                string(APPEND arg_BUILD_TRIPLET " --host=${TARGET_ARCH}-unknown-mingw32")
+            endif()
+            debug_message("Using make triplet: ${arg_BUILD_TRIPLET}")
+        endif()
+
+        # Remove full filepaths due to spaces and prepend filepaths to PATH (cross-compiling tools are unlikely on path by default)
+        set(progs VCPKG_DETECTED_CMAKE_C_COMPILER VCPKG_DETECTED_CMAKE_CXX_COMPILER VCPKG_DETECTED_CMAKE_AR
+                  VCPKG_DETECTED_CMAKE_LINKER VCPKG_DETECTED_CMAKE_RANLIB VCPKG_DETECTED_CMAKE_OBJDUMP
+                  VCPKG_DETECTED_CMAKE_STRIP VCPKG_DETECTED_CMAKE_NM VCPKG_DETECTED_CMAKE_DLLTOOL VCPKG_DETECTED_CMAKE_RC_COMPILER)
+        foreach(prog IN LISTS progs)
+            set(filepath "${${prog}}")
+            if(filepath MATCHES " ")
+                cmake_path(GET filepath FILENAME ${prog})
+                find_program(z_vcm_prog_found NAMES "${${prog}}" PATHS ENV PATH NO_DEFAULT_PATH NO_CACHE)
+                if(NOT z_vcm_prog_found STREQUAL filepath)
+                    cmake_path(GET filepath PARENT_PATH dir)
+                    vcpkg_add_to_path(PREPEND "${dir}")
+                endif()
+            endif()
+        endforeach()
+        if (arg_USE_WRAPPERS)
+            z_vcpkg_append_to_configure_environment(configure_env CPP "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER} -E")
+
+            z_vcpkg_append_to_configure_environment(configure_env CC "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER}")
+            if(NOT arg_BUILD_TRIPLET MATCHES "--host")
+                z_vcpkg_append_to_configure_environment(configure_env CC_FOR_BUILD "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER}")
+                z_vcpkg_append_to_configure_environment(configure_env CPP_FOR_BUILD "compile ${VCPKG_DETECTED_CMAKE_C_COMPILER} -E")
+                z_vcpkg_append_to_configure_environment(configure_env CXX_FOR_BUILD "compile ${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
+            else()
+                # Silly trick to make configure accept CC_FOR_BUILD but in reallity CC_FOR_BUILD is deactivated. 
+                z_vcpkg_append_to_configure_environment(configure_env CC_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true")
+                z_vcpkg_append_to_configure_environment(configure_env CPP_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true")
+                z_vcpkg_append_to_configure_environment(configure_env CXX_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true")
+            endif()
+            z_vcpkg_append_to_configure_environment(configure_env CXX "compile ${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
+            z_vcpkg_append_to_configure_environment(configure_env RC "windres-rc ${VCPKG_DETECTED_CMAKE_RC_COMPILER}")
+            z_vcpkg_append_to_configure_environment(configure_env WINDRES "windres-rc ${VCPKG_DETECTED_CMAKE_RC_COMPILER}")
+            if(VCPKG_DETECTED_CMAKE_AR)
+                z_vcpkg_append_to_configure_environment(configure_env AR "ar-lib ${VCPKG_DETECTED_CMAKE_AR}")
+            else()
+                z_vcpkg_append_to_configure_environment(configure_env AR "ar-lib lib.exe -verbose")
+            endif()
+        else()
+            z_vcpkg_append_to_configure_environment(configure_env CPP "${VCPKG_DETECTED_CMAKE_C_COMPILER} -E")
+            z_vcpkg_append_to_configure_environment(configure_env CC "${VCPKG_DETECTED_CMAKE_C_COMPILER}")
+            if(NOT arg_BUILD_TRIPLET MATCHES "--host")
+                z_vcpkg_append_to_configure_environment(configure_env CC_FOR_BUILD "${VCPKG_DETECTED_CMAKE_C_COMPILER}")
+                z_vcpkg_append_to_configure_environment(configure_env CPP_FOR_BUILD "${VCPKG_DETECTED_CMAKE_C_COMPILER} -E")
+                z_vcpkg_append_to_configure_environment(configure_env CXX_FOR_BUILD "${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
+            else()
+                z_vcpkg_append_to_configure_environment(configure_env CC_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true")
+                z_vcpkg_append_to_configure_environment(configure_env CPP_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true")
+                z_vcpkg_append_to_configure_environment(configure_env CXX_FOR_BUILD "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true")
+            endif()
+            z_vcpkg_append_to_configure_environment(configure_env CXX "${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
+            z_vcpkg_append_to_configure_environment(configure_env RC "${VCPKG_DETECTED_CMAKE_RC_COMPILER}")
+            z_vcpkg_append_to_configure_environment(configure_env WINDRES "${VCPKG_DETECTED_CMAKE_RC_COMPILER}")
+            if(VCPKG_DETECTED_CMAKE_AR)
+                z_vcpkg_append_to_configure_environment(configure_env AR "${VCPKG_DETECTED_CMAKE_AR}")
+            else()
+                z_vcpkg_append_to_configure_environment(configure_env AR "lib.exe -verbose")
+            endif()
+        endif()
+        z_vcpkg_append_to_configure_environment(configure_env LD "${VCPKG_DETECTED_CMAKE_LINKER} -verbose")
+        if(VCPKG_DETECTED_CMAKE_RANLIB)
+            z_vcpkg_append_to_configure_environment(configure_env RANLIB "${VCPKG_DETECTED_CMAKE_RANLIB}") # Trick to ignore the RANLIB call
+        else()
+            z_vcpkg_append_to_configure_environment(configure_env RANLIB ":")
+        endif()
+        if(VCPKG_DETECTED_CMAKE_OBJDUMP) #Objdump is required to make shared libraries. Otherwise define lt_cv_deplibs_check_method=pass_all
+            z_vcpkg_append_to_configure_environment(configure_env OBJDUMP "${VCPKG_DETECTED_CMAKE_OBJDUMP}") # Trick to ignore the RANLIB call
+        endif()
+        if(VCPKG_DETECTED_CMAKE_STRIP) # If required set the ENV variable STRIP in the portfile correctly
+            z_vcpkg_append_to_configure_environment(configure_env STRIP "${VCPKG_DETECTED_CMAKE_STRIP}") 
+        else()
+            z_vcpkg_append_to_configure_environment(configure_env STRIP ":")
+            list(APPEND arg_OPTIONS ac_cv_prog_ac_ct_STRIP=:)
+        endif()
+        if(VCPKG_DETECTED_CMAKE_NM) # If required set the ENV variable NM in the portfile correctly
+            z_vcpkg_append_to_configure_environment(configure_env NM "${VCPKG_DETECTED_CMAKE_NM}") 
+        else()
+            # Would be better to have a true nm here! Some symbols (mainly exported variables) get not properly imported with dumpbin as nm 
+            # and require __declspec(dllimport) for some reason (same problem CMake has with WINDOWS_EXPORT_ALL_SYMBOLS)
+            z_vcpkg_append_to_configure_environment(configure_env NM "dumpbin.exe -symbols -headers")
+        endif()
+        if(VCPKG_DETECTED_CMAKE_DLLTOOL) # If required set the ENV variable DLLTOOL in the portfile correctly
+            z_vcpkg_append_to_configure_environment(configure_env DLLTOOL "${VCPKG_DETECTED_CMAKE_DLLTOOL}") 
+        else()
+            z_vcpkg_append_to_configure_environment(configure_env DLLTOOL "link.exe -verbose -dll")
+        endif()
+        z_vcpkg_append_to_configure_environment(configure_env CCAS ":")   # If required set the ENV variable CCAS in the portfile correctly
+        z_vcpkg_append_to_configure_environment(configure_env AS ":")   # If required set the ENV variable AS in the portfile correctly
+
+        foreach(_env IN LISTS arg_CONFIGURE_ENVIRONMENT_VARIABLES)
+            z_vcpkg_append_to_configure_environment(configure_env ${_env} "${${_env}}")
+        endforeach()
+        debug_message("configure_env: '${configure_env}'")
+        # Other maybe interesting variables to control
+        # COMPILE This is the command used to actually compile a C source file. The file name is appended to form the complete command line. 
+        # LINK This is the command used to actually link a C program.
+        # CXXCOMPILE The command used to actually compile a C++ source file. The file name is appended to form the complete command line. 
+        # CXXLINK  The command used to actually link a C++ program. 
+
+        # Variables not correctly detected by configure. In release builds.
+        list(APPEND arg_OPTIONS gl_cv_double_slash_root=yes
+                                 ac_cv_func_memmove=yes)
+        #list(APPEND arg_OPTIONS lt_cv_deplibs_check_method=pass_all) # Just ignore libtool checks 
+        if(VCPKG_TARGET_ARCHITECTURE MATCHES "^[Aa][Rr][Mm]64$")
+            list(APPEND arg_OPTIONS gl_cv_host_cpu_c_abi=no)
+            # Currently needed for arm64 because objdump yields: "unrecognised machine type (0xaa64) in Import Library Format archive"
+            list(APPEND arg_OPTIONS lt_cv_deplibs_check_method=pass_all)
+        elseif(VCPKG_TARGET_ARCHITECTURE MATCHES "^[Aa][Rr][Mm]$")
+            # Currently needed for arm because objdump yields: "unrecognised machine type (0x1c4) in Import Library Format archive"
+            list(APPEND arg_OPTIONS lt_cv_deplibs_check_method=pass_all)
+        endif()
+    else()
+        # OSX dosn't like CMAKE_C(XX)_COMPILER (cc) in CC/CXX and rather wants to have gcc/g++
+        vcpkg_list(SET z_vcm_all_tools)
+        function(z_vcpkg_make_set_env envvar cmakevar)
+            set(prog "${VCPKG_DETECTED_CMAKE_${cmakevar}}")
+            if(NOT DEFINED ENV{${envvar}} AND NOT prog STREQUAL "")
+                vcpkg_list(APPEND z_vcm_all_tools "${prog}")
+                if(ARGN)
+                    string(APPEND prog " ${ARGN}")
+                endif()
+                set(z_vcm_all_tools "${z_vcm_all_tools}" PARENT_SCOPE)
+                set(ENV{${envvar}} "${prog}")
+            endif()
+        endfunction()
+        z_vcpkg_make_set_env(CC C_COMPILER)
+        if(NOT arg_BUILD_TRIPLET MATCHES "--host")
+            z_vcpkg_make_set_env(CC_FOR_BUILD C_COMPILER)
+            z_vcpkg_make_set_env(CPP_FOR_BUILD C_COMPILER "-E")
+            z_vcpkg_make_set_env(CXX_FOR_BUILD C_COMPILER)
+        else()
+            set(ENV{CC_FOR_BUILD} "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true")
+            set(ENV{CPP_FOR_BUILD} "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true")
+            set(ENV{CXX_FOR_BUILD} "touch a.out | touch conftest${VCPKG_HOST_EXECUTABLE_SUFFIX} | true")
+        endif()
+        z_vcpkg_make_set_env(CXX CXX_COMPILER)
+        z_vcpkg_make_set_env(NM NM)
+        z_vcpkg_make_set_env(RC RC)
+        z_vcpkg_make_set_env(WINDRES RC)
+        z_vcpkg_make_set_env(DLLTOOL DLLTOOL)
+        z_vcpkg_make_set_env(STRIP STRIP)
+        z_vcpkg_make_set_env(OBJDUMP OBJDUMP)
+        z_vcpkg_make_set_env(RANLIB RANLIB)
+        z_vcpkg_make_set_env(AR AR)
+        z_vcpkg_make_set_env(LD LINKER)
+        unset(z_vcpkg_make_set_env)
+    endif()
+
+    list(FILTER z_vcm_all_tools INCLUDE REGEX " ")
+    if(z_vcm_all_tools)
+        list(REMOVE_DUPLICATES z_vcm_all_tools)
+        list(JOIN z_vcm_all_tools "\n   " tools)
+        message(STATUS "Warning: Tools with embedded space may be handled incorrectly by configure:\n   ${tools}")
+    endif()
+
+    z_vcpkg_configure_make_common_definitions()
+
+    # Cleanup previous build dirs
+    file(REMOVE_RECURSE "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_name_RELEASE}"
+                        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_name_DEBUG}"
+                        "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}")
+
+    # Set configure paths
+    vcpkg_list(APPEND arg_OPTIONS_RELEASE "--prefix=${current_installed_dir_msys}")
+    vcpkg_list(APPEND arg_OPTIONS_DEBUG "--prefix=${current_installed_dir_msys}${path_suffix_DEBUG}")
+    if(NOT arg_NO_ADDITIONAL_PATHS)
+        # ${prefix} has an extra backslash to prevent early expansion when calling `bash -c configure "..."`.
+        vcpkg_list(APPEND arg_OPTIONS_RELEASE
+                            # Important: These should all be relative to prefix!
+                            "--bindir=\\\${prefix}/tools/${PORT}/bin"
+                            "--sbindir=\\\${prefix}/tools/${PORT}/sbin"
+                            "--libdir=\\\${prefix}/lib" # On some Linux distributions lib64 is the default
+                            #"--includedir='\${prefix}'/include" # already the default!
+                            "--mandir=\\\${prefix}/share/${PORT}"
+                            "--docdir=\\\${prefix}/share/${PORT}"
+                            "--datarootdir=\\\${prefix}/share/${PORT}")
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG
+                            # Important: These should all be relative to prefix!
+                            "--bindir=\\\${prefix}/../tools/${PORT}${path_suffix_DEBUG}/bin"
+                            "--sbindir=\\\${prefix}/../tools/${PORT}${path_suffix_DEBUG}/sbin"
+                            "--libdir=\\\${prefix}/lib" # On some Linux distributions lib64 is the default
+                            "--includedir=\\\${prefix}/../include"
+                            "--datarootdir=\\\${prefix}/share/${PORT}")
+    endif()
+    # Setup common options
+    if(NOT arg_DISABLE_VERBOSE_FLAGS)
+        list(APPEND arg_OPTIONS --disable-silent-rules --verbose)
+    endif()
+
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL dynamic)
+        list(APPEND arg_OPTIONS --enable-shared --disable-static)
+    else()
+        list(APPEND arg_OPTIONS --disable-shared --enable-static)
+    endif()
+
+    # Can be set in the triplet to append options for configure
+    if(DEFINED VCPKG_CONFIGURE_MAKE_OPTIONS)
+        list(APPEND arg_OPTIONS ${VCPKG_CONFIGURE_MAKE_OPTIONS})
+    endif()
+    if(DEFINED VCPKG_CONFIGURE_MAKE_OPTIONS_RELEASE)
+        list(APPEND arg_OPTIONS_RELEASE ${VCPKG_CONFIGURE_MAKE_OPTIONS_RELEASE})
+    endif()
+    if(DEFINED VCPKG_CONFIGURE_MAKE_OPTIONS_DEBUG)
+        list(APPEND arg_OPTIONS_DEBUG ${VCPKG_CONFIGURE_MAKE_OPTIONS_DEBUG})
+    endif()
+
+    file(RELATIVE_PATH relative_build_path "${CURRENT_BUILDTREES_DIR}" "${arg_SOURCE_PATH}/${arg_PROJECT_SUBPATH}")
+
+    # Used by CL 
+    vcpkg_host_path_list(PREPEND ENV{INCLUDE} "${CURRENT_INSTALLED_DIR}/include")
+    # Used by GCC
+    vcpkg_host_path_list(PREPEND ENV{C_INCLUDE_PATH} "${CURRENT_INSTALLED_DIR}/include")
+    vcpkg_host_path_list(PREPEND ENV{CPLUS_INCLUDE_PATH} "${CURRENT_INSTALLED_DIR}/include")
+
+    # Flags should be set in the toolchain instead (Setting this up correctly requires a function named vcpkg_determined_cmake_compiler_flags which can also be used to setup CC and CXX etc.)
+    if(VCPKG_TARGET_IS_WINDOWS)
+        vcpkg_backup_env_variables(VARS _CL_ _LINK_)
+        # TODO: Should be CPP flags instead -> rewrite when vcpkg_determined_cmake_compiler_flags defined
+        if(VCPKG_TARGET_IS_UWP)
+            # Be aware that configure thinks it is crosscompiling due to: 
+            # error while loading shared libraries: VCRUNTIME140D_APP.dll: 
+            # cannot open shared object file: No such file or directory
+            # IMPORTANT: The only way to pass linker flags through libtool AND the compile wrapper 
+            # is to use the CL and LINK environment variables !!!
+            # (This is due to libtool and compiler wrapper using the same set of options to pass those variables around)
+            file(TO_CMAKE_PATH "$ENV{VCToolsInstallDir}" VCToolsInstallDir)
+            set(_replacement -FU\"${VCToolsInstallDir}/lib/x86/store/references/platform.winmd\")
+            string(REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_CXX_FLAGS_DEBUG "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_DEBUG}")
+            string(REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_C_FLAGS_DEBUG "${VCPKG_DETECTED_CMAKE_C_FLAGS_DEBUG}")
+            string(REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_CXX_FLAGS_RELEASE "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_RELEASE}")
+            string(REPLACE "${_replacement}" "" VCPKG_DETECTED_CMAKE_C_FLAGS_RELEASE "${VCPKG_DETECTED_CMAKE_C_FLAGS_RELEASE}")
+            # Can somebody please check if CMake's compiler flags for UWP are correct?
+            set(ENV{_CL_} "$ENV{_CL_} -FU\"${VCToolsInstallDir}/lib/x86/store/references/platform.winmd\"")
+            set(ENV{_LINK_} "$ENV{_LINK_} ${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES} ${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
+        endif()
+    endif()
+
+    # Remove outer quotes from cmake variables which will be forwarded via makefile/shell variables
+    # substituted into makefile commands (e.g. Android NDK has "--sysroot=...")
+    separate_arguments(c_libs_list NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES}")
+    separate_arguments(cxx_libs_list NATIVE_COMMAND "${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
+    list(REMOVE_ITEM cxx_libs_list ${c_libs_list})
+    set(all_libs_list ${cxx_libs_list} ${c_libs_list})
+    #Do lib list transformation from name.lib to -lname if necessary
+    set(x_vcpkg_transform_libs ON)
+    if(VCPKG_TARGET_IS_UWP)
+        set(x_vcpkg_transform_libs OFF)
+        # Avoid libtool choke: "Warning: linker path does not have real file for library -lWindowsApp."
+        # The problem with the choke is that libtool always falls back to built a static library even if a dynamic was requested. 
+        # Note: Env LIBPATH;LIB are on the search path for libtool by default on windows. 
+        # It even does unix/dos-short/unix transformation with the path to get rid of spaces. 
+    endif()
+    if(x_vcpkg_transform_libs)
+        list(TRANSFORM all_libs_list REPLACE "[.](dll[.]lib|lib|a|so)$" "")
+        if(VCPKG_TARGET_IS_WINDOWS)
+            list(REMOVE_ITEM all_libs_list "uuid")
+        endif()
+        list(TRANSFORM all_libs_list REPLACE "^([^-].*)" "-l\\1")
+        if(VCPKG_TARGET_IS_MINGW AND VCPKG_LIBRARY_LINKAGE STREQUAL "dynamic")
+            # libtool must be told explicitly that there is no dynamic linkage for uuid.
+            # The "-Wl,..." syntax is understood by libtool and gcc, but no by ld.
+            list(TRANSFORM all_libs_list REPLACE "^-luuid\$" "-Wl,-Bstatic,-luuid,-Bdynamic")
+        endif()
+    endif()
+    if(all_libs_list)
+        list(JOIN all_libs_list " " all_libs_string)
+        if(DEFINED ENV{LIBS})
+            set(ENV{LIBS} "$ENV{LIBS} ${all_libs_string}")
+        else()
+            set(ENV{LIBS} "${all_libs_string}")
+        endif()
+    endif()
+    debug_message("ENV{LIBS}:$ENV{LIBS}")
+
+    # Run autoconf if necessary
+    if (arg_AUTOCONFIG OR requires_autoconfig AND NOT arg_NO_AUTOCONFIG)
+        find_program(AUTORECONF autoreconf)
+        if(NOT AUTORECONF)
+            message(FATAL_ERROR "${PORT} requires autoconf from the system package manager (example: \"sudo apt-get install autoconf\")")
+        endif()
+        message(STATUS "Generating configure for ${TARGET_TRIPLET}")
+        if (CMAKE_HOST_WIN32)
+            vcpkg_execute_required_process(
+                COMMAND ${base_cmd} -c "autoreconf -vfi"
+                WORKING_DIRECTORY "${src_dir}"
+                LOGNAME "autoconf-${TARGET_TRIPLET}"
+            )
+        else()
+            vcpkg_execute_required_process(
+                COMMAND "${AUTORECONF}" -vfi
+                WORKING_DIRECTORY "${src_dir}"
+                LOGNAME "autoconf-${TARGET_TRIPLET}"
+            )
+        endif()
+        message(STATUS "Finished generating configure for ${TARGET_TRIPLET}")
+    endif()
+    if(requires_autogen)
+        message(STATUS "Generating configure for ${TARGET_TRIPLET} via autogen.sh")
+        if (CMAKE_HOST_WIN32)
+            vcpkg_execute_required_process(
+                COMMAND ${base_cmd} -c "./autogen.sh"
+                WORKING_DIRECTORY "${src_dir}"
+                LOGNAME "autoconf-${TARGET_TRIPLET}"
+            )
+        else()
+            vcpkg_execute_required_process(
+                COMMAND "./autogen.sh"
+                WORKING_DIRECTORY "${src_dir}"
+                LOGNAME "autoconf-${TARGET_TRIPLET}"
+            )
+        endif()
+        message(STATUS "Finished generating configure for ${TARGET_TRIPLET}")
+    endif()
+
+    if (arg_PRERUN_SHELL)
+        message(STATUS "Prerun shell with ${TARGET_TRIPLET}")
+        if (CMAKE_HOST_WIN32)
+            vcpkg_execute_required_process(
+                COMMAND ${base_cmd} -c "${arg_PRERUN_SHELL}"
+                WORKING_DIRECTORY "${src_dir}"
+                LOGNAME "prerun-${TARGET_TRIPLET}"
+            )
+        else()
+            vcpkg_execute_required_process(
+                COMMAND "${base_cmd}" -c "${arg_PRERUN_SHELL}"
+                WORKING_DIRECTORY "${src_dir}"
+                LOGNAME "prerun-${TARGET_TRIPLET}"
+            )
+        endif()
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug" AND NOT arg_NO_DEBUG)
+        list(APPEND all_buildtypes DEBUG)
+        z_vcpkg_configure_make_process_flags(DEBUG)
+    endif()
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        list(APPEND all_buildtypes RELEASE)
+        z_vcpkg_configure_make_process_flags(RELEASE)
+    endif()
+    list(FILTER z_vcm_all_flags INCLUDE REGEX " ")
+    if(z_vcm_all_flags)
+        list(REMOVE_DUPLICATES z_vcm_all_flags)
+        list(JOIN z_vcm_all_flags "\n   " flags)
+        message(STATUS "Warning: Arguments with embedded space may be handled incorrectly by configure:\n   ${flags}")
+    endif()
+
+    foreach(var IN ITEMS arg_OPTIONS arg_OPTIONS_RELEASE arg_OPTIONS_DEBUG)
+        vcpkg_list(SET tmp)
+        foreach(element IN LISTS "${var}")
+            string(REPLACE [["]] [[\"]] element "${element}")
+            vcpkg_list(APPEND tmp "\"${element}\"")
+        endforeach()
+        vcpkg_list(JOIN tmp " " "${var}")
+    endforeach()
+
+    foreach(current_buildtype IN LISTS all_buildtypes)
+        foreach(ENV_VAR ${arg_CONFIG_DEPENDENT_ENVIRONMENT})
+            if(DEFINED ENV{${ENV_VAR}})
+                set(backup_config_${ENV_VAR} "$ENV{${ENV_VAR}}")
+            endif()
+            set(ENV{${ENV_VAR}} "${${ENV_VAR}_${current_buildtype}}")
+        endforeach()
+
+        set(target_dir "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-${short_name_${current_buildtype}}")
+        file(MAKE_DIRECTORY "${target_dir}")
+        file(RELATIVE_PATH relative_build_path "${target_dir}" "${src_dir}")
+
+        if(arg_COPY_SOURCE)
+            file(COPY "${src_dir}/" DESTINATION "${target_dir}")
+            set(relative_build_path .)
+        endif()
+
+        # Setup PKG_CONFIG_PATH
+        z_vcpkg_setup_pkgconfig_path(CONFIG "${current_buildtype}")
+
+        # Setup environment
+        set(ENV{CPPFLAGS} "${CPPFLAGS_${current_buildtype}}")
+        set(ENV{CPPFLAGS_FOR_BUILD} "${CPPFLAGS_${current_buildtype}}")
+        set(ENV{CFLAGS} "${CFLAGS_${current_buildtype}}")
+        set(ENV{CFLAGS_FOR_BUILD} "${CFLAGS_${current_buildtype}}")
+        set(ENV{CXXFLAGS} "${CXXFLAGS_${current_buildtype}}")
+        #set(ENV{CXXFLAGS_FOR_BUILD} "${CXXFLAGS_${current_buildtype}}") -> doesn't exist officially
+        set(ENV{RCFLAGS} "${VCPKG_DETECTED_CMAKE_RC_FLAGS_${current_buildtype}}")
+        set(ENV{LDFLAGS} "${LDFLAGS_${current_buildtype}}")
+        set(ENV{LDFLAGS_FOR_BUILD} "${LDFLAGS_${current_buildtype}}")
+        if(ARFLAGS_${current_buildtype} AND NOT (arg_USE_WRAPPERS AND VCPKG_TARGET_IS_WINDOWS))
+            # Target windows with wrappers enabled cannot forward ARFLAGS since it breaks the wrapper
+            set(ENV{ARFLAGS} "${ARFLAGS_${current_buildtype}}")
+        endif()
+
+        if(VCPKG_TARGET_IS_OSX OR VCPKG_TARGET_IS_IOS)
+            # configure not using all flags to check if compiler works ...
+            set(ENV{CC} "$ENV{CC} $ENV{CPPFLAGS} $ENV{CFLAGS}")
+            set(ENV{CC_FOR_BUILD} "$ENV{CC_FOR_BUILD} $ENV{CPPFLAGS} $ENV{CFLAGS}")
+        endif()
+
+        if(LINK_ENV_${current_buildtype})
+            set(link_config_backup "$ENV{_LINK_}")
+            set(ENV{_LINK_} "${LINK_ENV_${current_buildtype}}")
+        else()
+            unset(link_config_backup)
+        endif()
+
+        vcpkg_list(APPEND lib_env_vars LIB LIBPATH LIBRARY_PATH) # LD_LIBRARY_PATH)
+        foreach(lib_env_var IN LISTS lib_env_vars)
+            if(EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib")
+                vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib")
+            endif()
+            if(EXISTS "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib/manual-link")
+                vcpkg_host_path_list(PREPEND ENV{${lib_env_var}} "${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/lib/manual-link")
+            endif()
+        endforeach()
+        unset(lib_env_vars)
+
+        set(command "${base_cmd}" -c "${configure_env} ./${relative_build_path}/configure ${arg_BUILD_TRIPLET} ${arg_OPTIONS} ${arg_OPTIONS_${current_buildtype}}")
+        
+        if(arg_ADD_BIN_TO_PATH)
+            set(path_backup $ENV{PATH})
+            vcpkg_add_to_path("${CURRENT_INSTALLED_DIR}${path_suffix_${current_buildtype}}/bin")
+        endif()
+        debug_message("Configure command:'${command}'")
+        if (NOT arg_SKIP_CONFIGURE)
+            message(STATUS "Configuring ${TARGET_TRIPLET}-${short_name_${current_buildtype}}")
+            vcpkg_execute_required_process(
+                COMMAND ${command}
+                WORKING_DIRECTORY "${target_dir}"
+                LOGNAME "config-${TARGET_TRIPLET}-${short_name_${current_buildtype}}"
+                SAVE_LOG_FILES config.log
+            )
+            if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW AND VCPKG_LIBRARY_LINKAGE STREQUAL dynamic)
+                file(GLOB_RECURSE libtool_files "${target_dir}*/libtool")
+                foreach(lt_file IN LISTS libtool_files)
+                    file(READ "${lt_file}" _contents)
+                    string(REPLACE ".dll.lib" ".lib" _contents "${_contents}")
+                    file(WRITE "${lt_file}" "${_contents}")
+                endforeach()
+            endif()
+        endif()
+        z_vcpkg_restore_pkgconfig_path()
+        
+        if(DEFINED link_config_backup)
+            set(ENV{_LINK_} "${link_config_backup}")
+        endif()
+        
+        if(arg_ADD_BIN_TO_PATH)
+            set(ENV{PATH} "${path_backup}")
+        endif()
+        # Restore environment (config dependent)
+        foreach(ENV_VAR IN LISTS ${arg_CONFIG_DEPENDENT_ENVIRONMENT})
+            if(backup_config_${ENV_VAR})
+                set(ENV{${ENV_VAR}} "${backup_config_${ENV_VAR}}")
+            else()
+                unset(ENV{${ENV_VAR}})
+            endif()
+        endforeach()
+    endforeach()
+
+    # Export matching make program for vcpkg_build_make (cache variable)
+    if(CMAKE_HOST_WIN32 AND MSYS_ROOT)
+        find_program(Z_VCPKG_MAKE make PATHS "${MSYS_ROOT}/usr/bin" NO_DEFAULT_PATH REQUIRED)
+    elseif(VCPKG_HOST_IS_FREEBSD OR VCPKG_HOST_IS_OPENBSD)
+        find_program(Z_VCPKG_MAKE gmake REQUIRED)
+    else()
+        find_program(Z_VCPKG_MAKE make REQUIRED)
+    endif()
+
+    # Restore environment
+    vcpkg_restore_env_variables(VARS ${cm_FLAGS} LIB LIBPATH LIBRARY_PATH LD_LIBRARY_PATH)
+
+    set(_VCPKG_PROJECT_SOURCE_PATH ${arg_SOURCE_PATH} PARENT_SCOPE)
+    set(_VCPKG_PROJECT_SUBPATH ${arg_PROJECT_SUBPATH} PARENT_SCOPE)
+    set(_VCPKG_MAKE_NO_DEBUG ${arg_NO_DEBUG} PARENT_SCOPE)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_configure_qmake.cmake

@@ -0,0 +1,167 @@
+function(vcpkg_configure_qmake)
+    # parse parameters such that semicolons in options arguments to COMMAND don't get erased
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        ""
+        "SOURCE_PATH"
+        "OPTIONS;OPTIONS_RELEASE;OPTIONS_DEBUG;BUILD_OPTIONS;BUILD_OPTIONS_RELEASE;BUILD_OPTIONS_DEBUG"
+    )
+
+    # Find qmake executable
+    find_program(qmake_executable NAMES qmake PATHS "${CURRENT_HOST_INSTALLED_DIR}/tools/qt5/bin" NO_DEFAULT_PATH)
+
+    if(NOT qmake_executable)
+        message(FATAL_ERROR "vcpkg_configure_qmake: unable to find qmake.")
+    endif()
+
+    z_vcpkg_get_cmake_vars(cmake_vars_file)
+    include("${cmake_vars_file}")
+
+    function(qmake_append_program var qmake_var value)
+        get_filename_component(prog "${value}" NAME)
+        # QMake assumes everything is on PATH?
+        vcpkg_list(APPEND ${var} "${qmake_var}=${prog}")
+        find_program(${qmake_var} NAMES "${prog}")
+        cmake_path(COMPARE "${${qmake_var}}" EQUAL "${value}" correct_prog_on_path)
+        if(NOT correct_prog_on_path AND NOT "${value}" MATCHES "|:")
+            message(FATAL_ERROR "Detect path mismatch for '${qmake_var}'. '${value}' is not the same as '${${qmake_var}}'. Please correct your PATH!")
+        endif()
+        unset(${qmake_var})
+        unset(${qmake_var} CACHE)
+        set(${var} "${${var}}" PARENT_SCOPE)
+    endfunction()
+    # Setup Build tools
+    set(qmake_build_tools "")
+    qmake_append_program(qmake_build_tools "QMAKE_CC" "${VCPKG_DETECTED_CMAKE_C_COMPILER}")
+    qmake_append_program(qmake_build_tools "QMAKE_CXX" "${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
+    qmake_append_program(qmake_build_tools "QMAKE_AR" "${VCPKG_DETECTED_CMAKE_AR}")
+    qmake_append_program(qmake_build_tools "QMAKE_RANLIB" "${VCPKG_DETECTED_CMAKE_RANLIB}")
+    qmake_append_program(qmake_build_tools "QMAKE_STRIP" "${VCPKG_DETECTED_CMAKE_STRIP}")
+    qmake_append_program(qmake_build_tools "QMAKE_NM" "${VCPKG_DETECTED_CMAKE_NM}")
+    qmake_append_program(qmake_build_tools "QMAKE_RC" "${VCPKG_DETECTED_CMAKE_RC_COMPILER}")
+    qmake_append_program(qmake_build_tools "QMAKE_MT" "${VCPKG_DETECTED_CMAKE_MT}")
+    if(NOT VCPKG_TARGET_IS_WINDOWS OR VCPKG_DETECTED_CMAKE_AR MATCHES "ar$")
+        vcpkg_list(APPEND qmake_build_tools "QMAKE_AR+=qc")
+    endif()
+    if(VCPKG_TARGET_IS_WINDOWS AND NOT VCPKG_TARGET_IS_MINGW)
+        qmake_append_program(qmake_build_tools "QMAKE_LIB" "${VCPKG_DETECTED_CMAKE_AR}")
+        qmake_append_program(qmake_build_tools "QMAKE_LINK" "${VCPKG_DETECTED_CMAKE_LINKER}")
+    else()
+        qmake_append_program(qmake_build_tools "QMAKE_LINK" "${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
+        qmake_append_program(qmake_build_tools "QMAKE_LINK_SHLIB" "${VCPKG_DETECTED_CMAKE_CXX_COMPILER}")
+        qmake_append_program(qmake_build_tools "QMAKE_LINK_C" "${VCPKG_DETECTED_CMAKE_C_COMPILER}")
+        qmake_append_program(qmake_build_tools "QMAKE_LINK_C_SHLIB" "${VCPKG_DETECTED_CMAKE_C_COMPILER}")
+    endif()
+    set(qmake_comp_flags "")
+    macro(qmake_add_flags qmake_var operation flags)
+        string(STRIP "${flags}" striped_flags)
+        if(striped_flags)
+            vcpkg_list(APPEND qmake_comp_flags "${qmake_var}${operation}${striped_flags}")
+        endif()
+    endmacro()
+
+    if(VCPKG_LIBRARY_LINKAGE STREQUAL "static")
+        vcpkg_list(APPEND arg_OPTIONS "CONFIG-=shared" "CONFIG*=static")
+    else()
+        vcpkg_list(APPEND arg_OPTIONS "CONFIG-=static" "CONFIG*=shared")
+        vcpkg_list(APPEND arg_OPTIONS_DEBUG "CONFIG*=separate_debug_info")
+    endif()
+
+    if(VCPKG_TARGET_IS_WINDOWS AND VCPKG_CRT_LINKAGE STREQUAL "static")
+        vcpkg_list(APPEND arg_OPTIONS "CONFIG*=static-runtime")
+    endif()
+
+    if(DEFINED VCPKG_OSX_DEPLOYMENT_TARGET)
+        set(ENV{QMAKE_MACOSX_DEPLOYMENT_TARGET} "${VCPKG_OSX_DEPLOYMENT_TARGET}")
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "release")
+        z_vcpkg_setup_pkgconfig_path(CONFIG RELEASE)
+
+        set(current_binary_dir "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-rel")
+
+        # Cleanup build directories
+        file(REMOVE_RECURSE "${current_binary_dir}")
+
+        configure_file("${CURRENT_INSTALLED_DIR}/tools/qt5/qt_release.conf" "${current_binary_dir}/qt.conf")
+    
+        message(STATUS "Configuring ${TARGET_TRIPLET}-rel")
+        file(MAKE_DIRECTORY "${current_binary_dir}")
+
+        qmake_add_flags("QMAKE_LIBS" "+=" "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES} ${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
+        qmake_add_flags("QMAKE_RC" "+=" "${VCPKG_DETECTED_CMAKE_RC_FLAGS_RELEASE}")
+        qmake_add_flags("QMAKE_CFLAGS_RELEASE" "+=" "${VCPKG_DETECTED_CMAKE_C_FLAGS_RELEASE}")
+        qmake_add_flags("QMAKE_CXXFLAGS_RELEASE" "+=" "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_RELEASE}")
+        qmake_add_flags("QMAKE_LFLAGS" "+=" "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
+        qmake_add_flags("QMAKE_LFLAGS_SHLIB" "+=" "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_RELEASE}")
+        qmake_add_flags("QMAKE_LFLAGS_PLUGIN" "+=" "${VCPKG_DETECTED_CMAKE_MODULE_LINKER_FLAGS_RELEASE}")
+        qmake_add_flags("QMAKE_LIBFLAGS_RELEASE" "+=" "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_RELEASE}")
+
+        vcpkg_list(SET build_opt_param)
+        if(DEFINED arg_BUILD_OPTIONS OR DEFINED arg_BUILD_OPTIONS_RELEASE)
+            vcpkg_list(SET build_opt_param -- ${arg_BUILD_OPTIONS} ${arg_BUILD_OPTIONS_RELEASE})
+        endif()
+
+        vcpkg_execute_required_process(
+            COMMAND "${qmake_executable}" CONFIG-=debug CONFIG+=release ${qmake_build_tools} ${qmake_comp_flags}
+                    ${arg_OPTIONS} ${arg_OPTIONS_RELEASE} ${arg_SOURCE_PATH}
+                    -qtconf "${current_binary_dir}/qt.conf"
+                    ${build_opt_param}
+            WORKING_DIRECTORY "${current_binary_dir}"
+            LOGNAME "config-${TARGET_TRIPLET}-rel"
+            SAVE_LOG_FILES config.log
+        )
+        message(STATUS "Configuring ${TARGET_TRIPLET}-rel done")
+        if(EXISTS "${current_binary_dir}/config.log")
+            file(REMOVE "${CURRENT_BUILDTREES_DIR}/internal-config-${TARGET_TRIPLET}-rel.log")
+            file(RENAME "${current_binary_dir}/config.log" "${CURRENT_BUILDTREES_DIR}/internal-config-${TARGET_TRIPLET}-rel.log")
+        endif()
+
+        z_vcpkg_restore_pkgconfig_path()
+    endif()
+
+    if(NOT DEFINED VCPKG_BUILD_TYPE OR VCPKG_BUILD_TYPE STREQUAL "debug")
+        z_vcpkg_setup_pkgconfig_path(CONFIG DEBUG)
+
+        set(current_binary_dir "${CURRENT_BUILDTREES_DIR}/${TARGET_TRIPLET}-dbg")
+
+        # Cleanup build directories
+        file(REMOVE_RECURSE "${current_binary_dir}")
+
+        configure_file("${CURRENT_INSTALLED_DIR}/tools/qt5/qt_debug.conf" "${current_binary_dir}/qt.conf")
+
+        message(STATUS "Configuring ${TARGET_TRIPLET}-dbg")
+        file(MAKE_DIRECTORY "${current_binary_dir}")
+
+        set(qmake_comp_flags "")
+        qmake_add_flags("QMAKE_LIBS" "+=" "${VCPKG_DETECTED_CMAKE_C_STANDARD_LIBRARIES} ${VCPKG_DETECTED_CMAKE_CXX_STANDARD_LIBRARIES}")
+        qmake_add_flags("QMAKE_RC" "+=" "${VCPKG_DETECTED_CMAKE_RC_FLAGS_DEBUG}")
+        qmake_add_flags("QMAKE_CFLAGS_DEBUG" "+=" "${VCPKG_DETECTED_CMAKE_C_FLAGS_DEBUG}")
+        qmake_add_flags("QMAKE_CXXFLAGS_DEBUG" "+=" "${VCPKG_DETECTED_CMAKE_CXX_FLAGS_DEBUG}")
+        qmake_add_flags("QMAKE_LFLAGS" "+=" "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
+        qmake_add_flags("QMAKE_LFLAGS_SHLIB" "+=" "${VCPKG_DETECTED_CMAKE_SHARED_LINKER_FLAGS_DEBUG}")
+        qmake_add_flags("QMAKE_LFLAGS_PLUGIN" "+=" "${VCPKG_DETECTED_CMAKE_MODULE_LINKER_FLAGS_DEBUG}")
+        qmake_add_flags("QMAKE_LIBFLAGS_DEBUG" "+=" "${VCPKG_DETECTED_CMAKE_STATIC_LINKER_FLAGS_DEBUG}")
+
+        vcpkg_list(SET build_opt_param)
+        if(DEFINED arg_BUILD_OPTIONS OR DEFINED arg_BUILD_OPTIONS_DEBUG)
+            vcpkg_list(SET build_opt_param -- ${arg_BUILD_OPTIONS} ${arg_BUILD_OPTIONS_DEBUG})
+        endif()
+        vcpkg_execute_required_process(
+            COMMAND "${qmake_executable}" CONFIG-=release CONFIG+=debug ${qmake_build_tools} ${qmake_comp_flags}
+                    ${arg_OPTIONS} ${arg_OPTIONS_DEBUG} ${arg_SOURCE_PATH}
+                    -qtconf "${current_binary_dir}/qt.conf"
+                    ${build_opt_param}
+            WORKING_DIRECTORY "${current_binary_dir}"
+            LOGNAME "config-${TARGET_TRIPLET}-dbg"
+            SAVE_LOG_FILES config.log
+        )
+        message(STATUS "Configuring ${TARGET_TRIPLET}-dbg done")
+        if(EXISTS "${current_binary_dir}/config.log")
+            file(REMOVE "${CURRENT_BUILDTREES_DIR}/internal-config-${TARGET_TRIPLET}-dbg.log")
+            file(RENAME "${current_binary_dir}/config.log" "${CURRENT_BUILDTREES_DIR}/internal-config-${TARGET_TRIPLET}-dbg.log")
+        endif()
+        
+        z_vcpkg_restore_pkgconfig_path()
+    endif()
+
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_copy_tool_dependencies.cmake

@@ -0,0 +1,45 @@
+function(z_vcpkg_copy_tool_dependencies_search tool_dir path_to_search)
+    if(DEFINED Z_VCPKG_COPY_TOOL_DEPENDENCIES_COUNT)
+        set(count ${Z_VCPKG_COPY_TOOL_DEPENDENCIES_COUNT})
+    else()
+        set(count 0)
+    endif()
+    file(GLOB tools "${tool_dir}/*.exe" "${tool_dir}/*.dll" "${tool_dir}/*.pyd")
+    foreach(tool IN LISTS tools)
+        vcpkg_execute_required_process(
+            COMMAND "${Z_VCPKG_POWERSHELL_CORE}" -noprofile -executionpolicy Bypass -nologo
+                -file "${SCRIPTS}/buildsystems/msbuild/applocal.ps1"
+                -targetBinary "${tool}"
+                -installedDir "${path_to_search}"
+                -verbose
+            WORKING_DIRECTORY "${VCPKG_ROOT_DIR}"
+            LOGNAME copy-tool-dependencies-${count}
+        )
+        math(EXPR count "${count} + 1")
+    endforeach()
+    set(Z_VCPKG_COPY_TOOL_DEPENDENCIES_COUNT ${count} CACHE INTERNAL "")
+endfunction()
+
+function(vcpkg_copy_tool_dependencies tool_dir)
+    if(ARGC GREATER 1)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${ARGN}")
+    endif()
+
+    if(VCPKG_TARGET_IS_WINDOWS)
+        find_program(Z_VCPKG_POWERSHELL_CORE pwsh)
+        if (NOT Z_VCPKG_POWERSHELL_CORE)
+            message(FATAL_ERROR "Could not find PowerShell Core; please open an issue to report this.")
+        endif()
+        cmake_path(RELATIVE_PATH tool_dir
+            BASE_DIRECTORY "${CURRENT_PACKAGES_DIR}"
+            OUTPUT_VARIABLE relative_tool_dir
+        )
+        if(relative_tool_dir MATCHES "/debug/")
+            z_vcpkg_copy_tool_dependencies_search("${tool_dir}" "${CURRENT_PACKAGES_DIR}/debug/bin")
+            z_vcpkg_copy_tool_dependencies_search("${tool_dir}" "${CURRENT_INSTALLED_DIR}/debug/bin")
+        else()
+            z_vcpkg_copy_tool_dependencies_search("${tool_dir}" "${CURRENT_PACKAGES_DIR}/bin")
+            z_vcpkg_copy_tool_dependencies_search("${tool_dir}" "${CURRENT_INSTALLED_DIR}/bin")
+        endif()
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_download_distfile.cmake

@@ -0,0 +1,275 @@
+function(z_vcpkg_check_hash result file_path sha512)
+    file(SHA512 "${file_path}" file_hash)
+    string(TOLOWER "${sha512}" sha512_lower)
+    string(COMPARE EQUAL "${file_hash}" "${sha512_lower}" hash_match)
+    set("${result}" "${hash_match}" PARENT_SCOPE)
+endfunction()
+
+function(z_vcpkg_download_distfile_test_hash file_path kind error_advice sha512 skip_sha512)
+    if(_VCPKG_INTERNAL_NO_HASH_CHECK)
+        # When using the internal hash skip, do not output an explicit message.
+        return()
+    endif()
+    if(skip_sha512)
+        message(STATUS "Skipping hash check for ${file_path}.")
+        return()
+    endif()
+
+    set(hash_match OFF)
+    z_vcpkg_check_hash(hash_match "${file_path}" "${sha512}")
+
+    if(NOT hash_match)
+        message(FATAL_ERROR
+            "\nFile does not have expected hash:\n"
+            "        File path: [ ${file_path} ]\n"
+            "    Expected hash: [ ${sha512} ]\n"
+            "      Actual hash: [ ${file_hash} ]\n"
+            "${error_advice}\n")
+    endif()
+endfunction()
+
+function(z_vcpkg_download_distfile_show_proxy_and_fail error_code)
+    message(FATAL_ERROR
+        "    \n"
+        "    Failed to download file with error: ${error_code}\n"  
+        "    If you are using a proxy, please check your proxy setting. Possible causes are:\n"
+        "    \n"
+        "    1. You are actually using an HTTP proxy, but setting HTTPS_PROXY variable\n"
+        "       to `https://address:port`. This is not correct, because `https://` prefix\n"
+        "       claims the proxy is an HTTPS proxy, while your proxy (v2ray, shadowsocksr\n"
+        "       , etc..) is an HTTP proxy. Try setting `http://address:port` to both\n"
+        "       HTTP_PROXY and HTTPS_PROXY instead.\n"
+        "    \n"
+        "    2. If you are using Windows, vcpkg will automatically use your Windows IE Proxy Settings\n"
+        "       set by your proxy software. See https://github.com/microsoft/vcpkg-tool/pull/77\n"
+        "       The value set by your proxy might be wrong, or have same `https://` prefix issue.\n"
+        "    \n"
+        "    3. Your proxy's remote server is out of service.\n"
+        "    \n"
+        "    If you've tried directly download the link, and believe this is not a temporary\n"
+        "    download server failure, please submit an issue at https://github.com/Microsoft/vcpkg/issues\n"
+        "    to report this upstream download server failure.\n"
+        "    \n")
+endfunction()
+
+function(z_vcpkg_download_distfile_via_aria)
+    cmake_parse_arguments(PARSE_ARGV 1 arg
+        "SKIP_SHA512"
+        "FILENAME;SHA512"
+        "URLS;HEADERS"
+    )
+
+    message(STATUS "Downloading ${arg_FILENAME}...")
+
+    vcpkg_list(SET headers_param)
+    foreach(header IN LISTS arg_HEADERS)
+        vcpkg_list(APPEND headers_param "--header=${header}")
+    endforeach()
+
+    foreach(URL IN LISTS arg_URLS)
+        debug_message("Download Command: ${ARIA2} ${URL} -o temp/${filename} -l download-${filename}-detailed.log ${headers_param}")
+        vcpkg_execute_in_download_mode(
+            COMMAND ${ARIA2} ${URL}
+            -o temp/${arg_FILENAME}
+            -l download-${arg_FILENAME}-detailed.log
+            ${headers_param}
+            OUTPUT_FILE download-${arg_FILENAME}-out.log
+            ERROR_FILE download-${arg_FILENAME}-err.log
+            RESULT_VARIABLE error_code
+            WORKING_DIRECTORY "${DOWNLOADS}"
+        )
+        
+        if ("${error_code}" STREQUAL "0")
+            break()
+        endif()
+    endforeach()
+    if (NOT "${error_code}" STREQUAL "0")
+        message(STATUS
+            "Downloading ${arg_FILENAME}... Failed.\n"
+            "    Exit Code: ${error_code}\n"
+            "    See logs for more information:\n"
+            "        ${DOWNLOADS}/download-${arg_FILENAME}-out.log\n"
+            "        ${DOWNLOADS}/download-${arg_FILENAME}-err.log\n"
+            "        ${DOWNLOADS}/download-${arg_FILENAME}-detailed.log\n"
+        )
+        z_vcpkg_download_distfile_show_proxy_and_fail("${error_code}")
+    else()
+        z_vcpkg_download_distfile_test_hash(
+            "${DOWNLOADS}/temp/${arg_FILENAME}"
+            "downloaded file"
+            "The file may have been corrupted in transit."
+            "${arg_SHA512}"
+            ${arg_SKIP_SHA512}
+        )
+        file(REMOVE
+            ${DOWNLOADS}/download-${arg_FILENAME}-out.log
+            ${DOWNLOADS}/download-${arg_FILENAME}-err.log
+            ${DOWNLOADS}/download-${arg_FILENAME}-detailed.log
+        )
+        get_filename_component(downloaded_file_dir "${downloaded_file_path}" DIRECTORY)
+        file(MAKE_DIRECTORY "${downloaded_file_dir}")
+        file(RENAME "${DOWNLOADS}/temp/${arg_FILENAME}" "${downloaded_file_path}")
+    endif()
+endfunction()
+
+function(vcpkg_download_distfile out_var)
+    cmake_parse_arguments(PARSE_ARGV 1 arg
+        "SKIP_SHA512;SILENT_EXIT;QUIET;ALWAYS_REDOWNLOAD"
+        "FILENAME;SHA512"
+        "URLS;HEADERS"
+    )
+
+    if(NOT DEFINED arg_URLS)
+        message(FATAL_ERROR "vcpkg_download_distfile requires a URLS argument.")
+    endif()
+    if(NOT DEFINED arg_FILENAME)
+        message(FATAL_ERROR "vcpkg_download_distfile requires a FILENAME argument.")
+    endif()
+    if(arg_SILENT_EXIT)
+        message(WARNING "SILENT_EXIT has been deprecated as an argument to vcpkg_download_distfile -- remove the argument to resolve this warning")
+    endif()
+    if(arg_ALWAYS_REDOWNLOAD AND NOT arg_SKIP_SHA512)
+        message(FATAL_ERROR "ALWAYS_REDOWNLOAD option requires SKIP_SHA512 as well")
+    endif()
+
+    if(NOT arg_SKIP_SHA512 AND NOT DEFINED arg_SHA512)
+        message(FATAL_ERROR "vcpkg_download_distfile requires a SHA512 argument.
+If you do not know the SHA512, add it as 'SHA512 0' and re-run this command.")
+    elseif(arg_SKIP_SHA512 AND DEFINED arg_SHA512)
+        message(FATAL_ERROR "vcpkg_download_distfile must not be passed both SHA512 and SKIP_SHA512.")
+    endif()
+
+    if(_VCPKG_INTERNAL_NO_HASH_CHECK)
+        set(arg_SKIP_SHA512 1)
+    endif()
+
+    if(NOT arg_SKIP_SHA512)
+        if("${arg_SHA512}" STREQUAL "0")
+            string(REPEAT 0 128 arg_SHA512)
+        else()
+            string(LENGTH "${arg_SHA512}" arg_SHA512_length)
+            if(NOT "${arg_SHA512_length}" EQUAL "128" OR NOT "${arg_SHA512}" MATCHES "^[a-zA-Z0-9]*$")
+                message(FATAL_ERROR "Invalid SHA512: ${arg_SHA512}.
+    If you do not know the file's SHA512, set this to \"0\".")
+            endif()
+        endif()
+    endif()
+
+    set(downloaded_file_path "${DOWNLOADS}/${arg_FILENAME}")
+
+    if(EXISTS "${downloaded_file_path}" AND NOT arg_SKIP_SHA512)
+        set(hash_match OFF)
+        z_vcpkg_check_hash(hash_match "${downloaded_file_path}" "${arg_SHA512}")
+        
+        if(NOT hash_match)
+            get_filename_component(filename_component "${arg_FILENAME}" NAME_WE)
+            get_filename_component(extension_component "${arg_FILENAME}" EXT)
+            get_filename_component(directory_component "${arg_FILENAME}" DIRECTORY)
+
+            string(SUBSTRING "${arg_SHA512}" 0 8 hash)
+            set(arg_FILENAME "${directory_component}${filename_component}-${hash}${extension_component}")
+            set(downloaded_file_path "${DOWNLOADS}/${arg_FILENAME}")
+        endif()
+    endif()
+
+    set(download_file_path_part "${DOWNLOADS}/temp/${arg_FILENAME}")
+
+    # Works around issue #3399
+    # Delete "temp0" directory created by the old version of vcpkg
+    file(REMOVE_RECURSE "${DOWNLOADS}/temp0")
+    file(REMOVE_RECURSE "${DOWNLOADS}/temp")
+    file(MAKE_DIRECTORY "${DOWNLOADS}/temp")
+
+    # check if file with same name already exists in downloads
+    if(EXISTS "${downloaded_file_path}" AND NOT arg_ALWAYS_REDOWNLOAD)
+        set(advice_message "The cached file SHA512 doesn't match. The file may have been corrupted.")
+        if(_VCPKG_NO_DOWNLOADS)
+            string(APPEND advice_message " Downloads are disabled please provide a valid file at path ${downloaded_file_path} and retry.")
+        else()
+            string(APPEND advice_message " To re-download this file please delete cached file at path ${downloaded_file_path} and retry.")
+        endif()
+
+        z_vcpkg_download_distfile_test_hash(
+            "${downloaded_file_path}"
+            "cached file"
+            "${advice_message}"
+            "${arg_SHA512}"
+            "${arg_SKIP_SHA512}"
+        )
+
+        if(NOT vcpkg_download_distfile_QUIET)
+            message(STATUS "Using cached ${arg_FILENAME}.")
+        endif()
+        
+        # Suppress the "Downloading ${arg_URLS} -> ${arg_FILENAME}..." message
+        set(vcpkg_download_distfile_QUIET TRUE)
+    endif()
+
+    # vcpkg_download_distfile_ALWAYS_REDOWNLOAD only triggers when NOT _VCPKG_NO_DOWNLOADS
+    # this could be de-morgan'd out but it's more clear this way
+    if(_VCPKG_NO_DOWNLOADS)
+        if(NOT EXISTS "${downloaded_file_path}")
+            message(FATAL_ERROR "Downloads are disabled, but '${downloaded_file_path}' does not exist.")
+        endif()
+
+        set("${out_var}" "${downloaded_file_path}" PARENT_SCOPE)
+        return()
+    endif()
+
+    if(NOT arg_DISABLE_ARIA2 AND _VCPKG_DOWNLOAD_TOOL STREQUAL "ARIA2" AND NOT EXISTS "${downloaded_file_path}")
+        if (arg_SKIP_SHA512)
+            set(OPTION_SKIP_SHA512 "SKIP_SHA512")
+        endif()
+        z_vcpkg_download_distfile_via_aria(
+            "${OPTION_SKIP_SHA512}"
+            FILENAME "${arg_FILENAME}"
+            SHA512 "${arg_SHA512}"
+            URLS "${arg_URLS}"
+            HEADERS "${arg_HEADERS}"
+        )
+        set("${out_var}" "${downloaded_file_path}" PARENT_SCOPE)
+        return()
+    endif()
+
+    vcpkg_list(SET urls_param)
+    foreach(url IN LISTS arg_URLS)
+        vcpkg_list(APPEND urls_param "--url=${url}")
+    endforeach()
+    if(NOT vcpkg_download_distfile_QUIET)
+        message(STATUS "Downloading ${arg_URLS} -> ${arg_FILENAME}...")
+    endif()
+
+    vcpkg_list(SET headers_param)
+    foreach(header IN LISTS arg_HEADERS)
+        list(APPEND headers_param "--header=${header}")
+    endforeach()
+
+    if(arg_SKIP_SHA512)
+        vcpkg_list(SET sha512_param "--skip-sha512")
+    else()
+        vcpkg_list(SET sha512_param "--sha512=${arg_SHA512}")
+    endif()
+
+    if(NOT EXISTS "${downloaded_file_path}" OR arg_ALWAYS_REDOWNLOAD)
+        vcpkg_execute_in_download_mode(
+            COMMAND "$ENV{VCPKG_COMMAND}" x-download
+                "${downloaded_file_path}"
+                ${sha512_param}
+                ${urls_param}
+                ${headers_param}
+                --debug
+                --feature-flags=-manifests # there's a bug in vcpkg x-download when it finds a manifest-root
+            OUTPUT_VARIABLE output
+            ERROR_VARIABLE output
+            RESULT_VARIABLE error_code
+            WORKING_DIRECTORY "${DOWNLOADS}"
+        )
+
+        if(NOT "${error_code}" EQUAL "0")
+            message("${output}")
+            z_vcpkg_download_distfile_show_proxy_and_fail("${error_code}")
+        endif()
+    endif()
+
+    set("${out_var}" "${downloaded_file_path}" PARENT_SCOPE)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_execute_required_process.cmake

@@ -0,0 +1,129 @@
+function(vcpkg_execute_required_process)
+    cmake_parse_arguments(PARSE_ARGV 0 arg
+        "ALLOW_IN_DOWNLOAD_MODE"
+        "WORKING_DIRECTORY;LOGNAME;TIMEOUT;OUTPUT_VARIABLE;ERROR_VARIABLE"
+        "COMMAND;SAVE_LOG_FILES"
+    )
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(WARNING "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    foreach(required_arg IN ITEMS WORKING_DIRECTORY COMMAND)
+        if(NOT DEFINED arg_${required_arg})
+            message(FATAL_ERROR "${required_arg} must be specified.")
+        endif()
+    endforeach()
+
+    if(NOT DEFINED arg_LOGNAME)
+        message(WARNING "LOGNAME should be specified.")
+        set(arg_LOGNAME "required")
+    endif()
+
+    if (VCPKG_DOWNLOAD_MODE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
+        message(FATAL_ERROR
+[[
+This command cannot be executed in Download Mode.
+Halting portfile execution.
+]])
+    endif()
+
+    set(log_out "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-out.log")
+    set(log_err "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-err.log")
+
+    set(timeout_param "")
+    set(output_and_error_same OFF)
+    set(output_variable_param "")
+    set(error_variable_param "")
+
+    if(DEFINED arg_TIMEOUT)
+        set(timeout_param TIMEOUT "${arg_TIMEOUT}")
+    endif()
+    if(DEFINED arg_OUTPUT_VARIABLE AND DEFINED arg_ERROR_VARIABLE AND arg_OUTPUT_VARIABLE STREQUAL arg_ERROR_VARIABLE)
+        set(output_variable_param OUTPUT_VARIABLE out_err_var)
+        set(error_variable_param ERROR_VARIABLE out_err_var)
+        set(output_and_error_same ON)
+    else()
+        if(DEFINED arg_OUTPUT_VARIABLE)
+            set(output_variable_param OUTPUT_VARIABLE out_var)
+        endif()
+        if(DEFINED arg_ERROR_VARIABLE)
+            set(error_variable_param ERROR_VARIABLE err_var)
+        endif()
+    endif()
+
+    if(X_PORT_PROFILE AND NOT arg_ALLOW_IN_DOWNLOAD_MODE)
+        vcpkg_list(PREPEND arg_COMMAND "${CMAKE_COMMAND}" "-E" "time")
+    endif()
+
+    vcpkg_execute_in_download_mode(
+        COMMAND ${arg_COMMAND}
+        OUTPUT_FILE "${log_out}"
+        ERROR_FILE "${log_err}"
+        RESULT_VARIABLE error_code
+        WORKING_DIRECTORY "${arg_WORKING_DIRECTORY}"
+        ${timeout_param}
+        ${output_variable_param}
+        ${error_variable_param}
+    )
+    vcpkg_list(SET logfiles)
+    vcpkg_list(SET logfile_copies)
+    set(expect_alias FALSE)
+    foreach(item IN LISTS arg_SAVE_LOG_FILES)
+        if(expect_alias)
+            vcpkg_list(POP_BACK logfile_copies)
+            vcpkg_list(APPEND logfile_copies "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-${item}")
+            set(expect_alias FALSE)
+        elseif(item STREQUAL "ALIAS")
+            if(NOT logfiles)
+                message(FATAL_ERROR "ALIAS used without source file")
+            endif()
+            set(expect_alias TRUE)
+        else()
+            vcpkg_list(APPEND logfiles "${arg_WORKING_DIRECTORY}/${item}")
+            cmake_path(GET item FILENAME filename)
+            if(NOT filename MATCHES "[.]log\$")
+                string(APPEND filename ".log")
+            endif()
+            vcpkg_list(APPEND logfile_copies "${CURRENT_BUILDTREES_DIR}/${arg_LOGNAME}-${filename}")
+        endif()
+    endforeach()
+    vcpkg_list(SET saved_logs)
+    foreach(logfile logfile_copy IN ZIP_LISTS logfiles logfile_copies)
+        if(EXISTS "${logfile}")
+            configure_file("${logfile}" "${logfile_copy}" COPYONLY)
+            vcpkg_list(APPEND saved_logs "${logfile_copy}")
+        endif()
+    endforeach()
+    if(NOT error_code EQUAL 0)
+        set(stringified_logs "")
+        foreach(log IN LISTS saved_logs ITEMS "${log_out}" "${log_err}")
+            if(NOT EXISTS "${log}")
+                continue()
+            endif()
+            file(SIZE "${log}" log_size)
+            if(NOT log_size EQUAL "0")
+                file(TO_NATIVE_PATH "${log}" native_log)
+                string(APPEND stringified_logs "    ${native_log}\n")
+                file(APPEND "${Z_VCPKG_ERROR_LOG_COLLECTION_FILE}" "${native_log}\n")
+            endif()
+        endforeach()
+
+        z_vcpkg_prettify_command_line(pretty_command ${arg_COMMAND})
+        message(FATAL_ERROR
+            "  Command failed: ${pretty_command}\n"
+            "  Working Directory: ${arg_WORKING_DIRECTORY}\n"
+            "  Error code: ${error_code}\n"
+            "  See logs for more information:\n"
+            "${stringified_logs}"
+        )
+    endif()
+
+    # pass output parameters back to caller's scope
+    if(output_and_error_same)
+        z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_err_var)
+        # arg_ERROR_VARIABLE = arg_OUTPUT_VARIABLE, so no need to set it again
+    else()
+        z_vcpkg_forward_output_variable(arg_OUTPUT_VARIABLE out_var)
+        z_vcpkg_forward_output_variable(arg_ERROR_VARIABLE err_var)
+    endif()
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_extract_source_archive.cmake

@@ -0,0 +1,158 @@
+function(z_vcpkg_extract_source_archive_deprecated_mode archive working_directory)
+    cmake_path(GET archive FILENAME archive_filename)
+    if(NOT EXISTS "${working_directory}/${archive_filename}.extracted")
+        message(STATUS "Extracting source ${archive}")
+        vcpkg_extract_archive(ARCHIVE "${archive}" DESTINATION "${working_directory}")
+        file(TOUCH "${working_directory}/${archive_filename}.extracted")
+    endif()
+endfunction()
+
+function(vcpkg_extract_source_archive)
+    if(ARGC LESS_EQUAL "2")
+        z_vcpkg_deprecation_message( "Deprecated form of vcpkg_extract_source_archive used:
+    Please use the `vcpkg_extract_source_archive(<out-var> ARCHIVE <archive>)` form.")
+        if(ARGC EQUAL "0")
+            message(FATAL_ERROR "vcpkg_extract_source_archive requires at least one argument.")
+        endif()
+
+        set(archive "${ARGV0}")
+        if(ARGC EQUAL "1")
+            set(working_directory "${CURRENT_BUILDTREES_DIR}/src")
+        else()
+            set(working_directory "${ARGV1}")
+        endif()
+
+        z_vcpkg_extract_source_archive_deprecated_mode("${archive}" "${working_directory}")
+        return()
+    endif()
+
+    set(out_source_path "${ARGV0}")
+    cmake_parse_arguments(PARSE_ARGV 1 "arg"
+        "NO_REMOVE_ONE_LEVEL;SKIP_PATCH_CHECK;Z_ALLOW_OLD_PARAMETER_NAMES"
+        "ARCHIVE;SOURCE_BASE;BASE_DIRECTORY;WORKING_DIRECTORY;REF"
+        "PATCHES"
+    )
+
+    if(DEFINED arg_REF)
+        if(NOT arg_Z_ALLOW_OLD_PARAMETER_NAMES)
+            message(FATAL_ERROR "Unexpected argument REF")
+        elseif(DEFINED arg_SOURCE_BASE)
+            message(FATAL_ERROR "Cannot specify both REF and SOURCE_BASE")
+        else()
+            string(REPLACE "/" "-" arg_SOURCE_BASE "${arg_REF}")
+        endif()
+    endif()
+
+    if(DEFINED arg_UNPARSED_ARGUMENTS)
+        message(FATAL_ERROR "${CMAKE_CURRENT_FUNCTION} was passed extra arguments: ${arg_UNPARSED_ARGUMENTS}")
+    endif()
+    if(NOT DEFINED arg_ARCHIVE)
+        message(FATAL_ERROR "ARCHIVE must be specified")
+    endif()
+
+    if(DEFINED arg_WORKING_DIRECTORY)
+        if(DEFINED arg_BASE_DIRECTORY)
+            message(FATAL_ERROR "Cannot specify both BASE_DIRECTORY and WORKING_DIRECTORY")
+        elseif(NOT IS_ABSOLUTE "${arg_WORKING_DIRECTORY}")
+            message(FATAL_ERROR "WORKING_DIRECTORY (${arg_WORKING_DIRECTORY}) must be an absolute path")
+        endif()
+        set(working_directory "${arg_WORKING_DIRECTORY}")
+    else()
+        if(NOT DEFINED arg_BASE_DIRECTORY)
+            set(arg_BASE_DIRECTORY "src")
+        elseif(IS_ABSOLUTE "${arg_BASE_DIRECTORY}")
+            message(FATAL_ERROR "BASE_DIRECTORY (${arg_BASE_DIRECTORY}) must be a relative path")
+        endif()
+        cmake_path(APPEND CURRENT_BUILDTREES_DIR "${arg_BASE_DIRECTORY}"
+            OUTPUT_VARIABLE working_directory)
+    endif()
+
+    if(NOT DEFINED arg_SOURCE_BASE)
+        cmake_path(GET arg_ARCHIVE STEM arg_SOURCE_BASE)
+    elseif(arg_SOURCE_BASE MATCHES [[\\|/]])
+        message(FATAL_ERROR "SOURCE_BASE (${arg_SOURCE_BASE}) must not contain slashes")
+    endif()
+
+    # Take the last 10 chars of the base
+    set(base_max_length 10)
+    string(LENGTH "${arg_SOURCE_BASE}" source_base_length)
+    if(source_base_length GREATER base_max_length)
+        math(EXPR start "${source_base_length} - ${base_max_length}")
+        string(SUBSTRING "${arg_SOURCE_BASE}" "${start}" -1 arg_SOURCE_BASE)
+    endif()
+
+    # Hash the archive hash along with the patches. Take the first 10 chars of the hash
+    file(SHA512 "${arg_ARCHIVE}" patchset_hash)
+    foreach(patch IN LISTS arg_PATCHES)
+        cmake_path(ABSOLUTE_PATH patch
+            BASE_DIRECTORY "${CURRENT_PORT_DIR}"
+            OUTPUT_VARIABLE absolute_patch
+        )
+        if(NOT EXISTS "${absolute_patch}")
+            message(FATAL_ERROR "Could not find patch: '${patch}'")
+        endif()
+        file(SHA512 "${absolute_patch}" current_hash)
+        string(APPEND patchset_hash "${current_hash}")
+    endforeach()
+
+    string(SHA512 patchset_hash "${patchset_hash}")
+    string(SUBSTRING "${patchset_hash}" 0 10 patchset_hash)
+    cmake_path(APPEND working_directory "${arg_SOURCE_BASE}-${patchset_hash}"
+        OUTPUT_VARIABLE source_path
+    )
+
+    if(_VCPKG_EDITABLE AND EXISTS "${source_path}")
+        set("${out_source_path}" "${source_path}" PARENT_SCOPE)
+        message(STATUS "Using source at ${source_path}")
+        return()
+    elseif(NOT _VCPKG_EDITABLE)
+        cmake_path(APPEND_STRING source_path ".clean")
+        if(EXISTS "${source_path}")
+            message(STATUS "Cleaning sources at ${source_path}. Use --editable to skip cleaning for the packages you specify.")
+            file(REMOVE_RECURSE "${source_path}")
+        endif()
+    endif()
+
+    message(STATUS "Extracting source ${arg_ARCHIVE}")
+    cmake_path(APPEND_STRING source_path ".tmp" OUTPUT_VARIABLE temp_dir)
+    file(REMOVE_RECURSE "${temp_dir}")
+    file(MAKE_DIRECTORY "${temp_dir}")
+    vcpkg_execute_required_process(
+        ALLOW_IN_DOWNLOAD_MODE
+        COMMAND "${CMAKE_COMMAND}" -E tar xjf "${arg_ARCHIVE}"
+        WORKING_DIRECTORY "${temp_dir}"
+        LOGNAME extract
+    )
+
+    if(arg_NO_REMOVE_ONE_LEVEL)
+        cmake_path(SET temp_source_path "${temp_dir}")
+    else()
+        file(GLOB archive_directory "${temp_dir}/*")
+        # Exclude .DS_Store entries created by the finder on macOS
+        list(FILTER archive_directory EXCLUDE REGEX ".*/.DS_Store$")
+        # make sure `archive_directory` is only a single file
+        if(NOT archive_directory MATCHES ";" AND IS_DIRECTORY "${archive_directory}")
+            cmake_path(SET temp_source_path "${archive_directory}")
+        else()
+            message(FATAL_ERROR "Could not unwrap top level directory from archive. Pass NO_REMOVE_ONE_LEVEL to disable this.")
+        endif()
+    endif()
+
+    if (arg_SKIP_PATCH_CHECK)
+        set(quiet_param QUIET)
+    else()
+        set(quiet_param "")
+    endif()
+
+    z_vcpkg_apply_patches(
+        SOURCE_PATH "${temp_source_path}"
+        PATCHES ${arg_PATCHES}
+        ${quiet_param}
+    )
+
+    file(RENAME "${temp_source_path}" "${source_path}")
+    file(REMOVE_RECURSE "${temp_dir}")
+
+    set("${out_source_path}" "${source_path}" PARENT_SCOPE)
+    message(STATUS "Using source at ${source_path}")
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_extract_source_archive_ex.cmake

@@ -0,0 +1,11 @@
+function(vcpkg_extract_source_archive_ex)
+    # OUT_SOURCE_PATH is an out-parameter so we need to parse it
+    cmake_parse_arguments(PARSE_ARGV 0 "arg" "" "OUT_SOURCE_PATH" "")
+    if(NOT DEFINED arg_OUT_SOURCE_PATH)
+        message(FATAL_ERROR "OUT_SOURCE_PATH must be specified")
+    endif()
+
+    vcpkg_extract_source_archive(source_path ${arg_UNPARSED_ARGUMENTS} Z_ALLOW_OLD_PARAMETER_NAMES)
+
+    set("${arg_OUT_SOURCE_PATH}" "${source_path}" PARENT_SCOPE)
+endfunction()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(DOXYGEN).cmake

@@ -0,0 +1,11 @@
+set(program_name doxygen)
+set(program_version 1.9.1)
+if(CMAKE_HOST_WIN32)
+    set(download_filename "doxygen-${program_version}.windows.bin.zip")
+    set(download_sha512 "c3eeb6b9fa4eab70fb6b0864fbbf94fb8050f3fee38d117cf470921a80e3569cc1c8b0272604d6731e05f01790cfaa70e159bec5d0882fc4f2d8ae4a5d52a21b")
+    vcpkg_list(SET sourceforge_args
+        REPO doxygen
+        REF "rel-${program_version}"
+        )
+    set(tool_subdirectory c3eeb6b9fa-76d69c6db5)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GIT).cmake

@@ -0,0 +1,15 @@
+set(program_name git)
+if(CMAKE_HOST_WIN32)
+    set(base_version 2.32.0)
+    set(program_version 2.32.0.2)
+    set(tool_subdirectory "git-${program_version}-2-windows")
+    set(download_urls "https://github.com/git-for-windows/git/releases/download/v${base_version}.windows.2/PortableGit-${program_version}-32-bit.7z.exe")
+    set(download_filename "PortableGit-${program_version}-32-bit.7z.exe")
+    set(download_sha512 867d8534972cbaf7a4224e25a14d484f8d17ef186f8d79e9a758afb90cf69541375cb7615a39702311f4809cb8371ef85c2b1a15bfffe9e48f0e597ac011b348)
+    set(paths_to_search
+        "${DOWNLOADS}/tools/${tool_subdirectory}/mingw32/bin"
+        "${DOWNLOADS}/tools/git/${tool_subdirectory}/mingw32/bin")
+else()
+    set(brew_package_name "git")
+    set(apt_package_name "git")
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(GPERF).cmake

@@ -0,0 +1,8 @@
+set(program_name gperf)
+set(program_version 3.0.1)
+if(CMAKE_HOST_WIN32)
+    set(download_filename "gperf-${program_version}-bin.zip")
+    set(download_sha512 3f2d3418304390ecd729b85f65240a9e4d204b218345f82ea466ca3d7467789f43d0d2129fcffc18eaad3513f49963e79775b10cc223979540fa2e502fe7d4d9)
+    set(download_urls "https://sourceforge.net/projects/gnuwin32/files/gperf/${program_version}/gperf-${program_version}-bin.zip/download")
+    set(paths_to_search "${DOWNLOADS}/tools/gperf/bin")
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(JOM).cmake

@@ -0,0 +1,13 @@
+set(program_name jom)
+set(program_version_string 1_1_4)
+if(CMAKE_HOST_WIN32)
+    set(download_urls
+        "https://download.qt.io/official_releases/jom/jom_${program_version_string}.zip"
+        "https://mirrors.ocf.berkeley.edu/qt/official_releases/jom/jom_${program_version_string}.zip"
+        "https://mirrors.ukfast.co.uk/sites/qt.io/official_releases/jom/jom_${program_version_string}.zip"
+    )
+    set(download_filename "jom_${program_version_string}.zip")
+    set(download_sha512 a683bd829c84942223a791dae8abac5cfc2e3fa7de84c6fdc490ad3aa996a26c9fa0be0636890f02c9d56948bbe3225b43497cb590d1cb01e70c6fac447fa17b)
+    set(tool_subdirectory "jom-${program_version_string}")
+    set(paths_to_search "${DOWNLOADS}/tools/jom/${tool_subdirectory}")
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(MESON).cmake

@@ -0,0 +1,18 @@
+set(program_name meson)
+set(search_names meson meson.py)
+set(interpreter PYTHON3)
+set(apt_package_name "meson")
+set(brew_package_name "meson")
+set(version_command --version)
+set(extra_search_args EXACT_VERSION_MATCH)
+if(EXISTS "${CURRENT_HOST_INSTALLED_DIR}/share/meson/version.txt")
+    file(READ "${CURRENT_HOST_INSTALLED_DIR}/share/meson/version.txt" program_version)
+    set(paths_to_search "${DOWNLOADS}/tools/meson-${program_version};${CURRENT_HOST_INSTALLED_DIR}/tools/meson")
+else() # Old behavior
+    set(program_version 0.58.1)
+    set(ref aeda7f249c4a5dbbecc52e44f382246a2377b5b0)
+    set(paths_to_search "${DOWNLOADS}/tools/meson/meson-${ref}")
+    set(download_urls "https://github.com/mesonbuild/meson/archive/${ref}.tar.gz")
+    set(download_filename "meson-${ref}.tar.gz")
+    set(download_sha512 18a012a45274dbb4582e99fd69d920f38831e788d9860f9553c64847bedb1c2010ae0b5c0ef4a4350c03f5e0f95aaa0395378e1208109b59640c1a70b1e202d2)
+endif()

cc-multilingual-main/cc_net/vcpkg/scripts/cmake/vcpkg_find_acquire_program(NINJA).cmake

@@ -0,0 +1,28 @@
+set(program_name ninja)
+set(program_version 1.10.2)
+set(version_command --version)
+if(CMAKE_HOST_WIN32)
+    set(download_filename "ninja-win-${program_version}.zip")
+    set(tool_subdirectory "${program_version}-windows")
+    set(download_urls "https://github.com/ninja-build/ninja/releases/download/v${program_version}/ninja-win.zip")
+    set(download_sha512 6004140d92e86afbb17b49c49037ccd0786ce238f340f7d0e62b4b0c29ed0d6ad0bab11feda2094ae849c387d70d63504393714ed0a1f4d3a1f155af7a4f1ba3)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "Darwin")
+    set(download_filename "ninja-mac-${program_version}.zip")
+    set(download_urls "https://github.com/ninja-build/ninja/releases/download/v${program_version}/ninja-mac.zip")
+    set(tool_subdirectory "${program_version}-osx")
+    set(paths_to_search "${DOWNLOADS}/tools/ninja-${program_version}-osx")
+    set(download_sha512 bcd12f6a3337591306d1b99a7a25a6933779ba68db79f17c1d3087d7b6308d245daac08df99087ff6be8dc7dd0dcdbb3a50839a144745fa719502b3a7a07260b)
+elseif(CMAKE_HOST_SYSTEM_NAME STREQUAL "FreeBSD")
+    set(paths_to_search "${DOWNLOADS}/tools/${tool_subdirectory}-freebsd")
+else()
+    vcpkg_execute_in_download_mode(COMMAND "uname" "-m" OUTPUT_VARIABLE HOST_ARCH OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if(HOST_ARCH MATCHES "x86_64|amd64|AMD64")
+        set(download_filename "ninja-linux-${program_version}.zip")
+        set(download_urls "https://github.com/ninja-build/ninja/releases/download/v${program_version}/ninja-linux.zip")
+        set(tool_subdirectory "${program_version}-linux")
+        set(paths_to_search "${DOWNLOADS}/tools/ninja-${program_version}-linux")
+        set(download_sha512 93e802e9c17fb59636cddde4bad1ddaadad624f4ecfee00d5c78790330a4e9d433180e795718cda27da57215ce643c3929cf72c85337ee019d868c56f2deeef3)
+    else()
+        set(version_command "") # somewhat hacky way to skip version check and use system binary
+    endif()
+endif()