max_stars_repo_path stringlengths 3 173 | max_stars_repo_name stringlengths 5 75 | max_stars_count float64 0 191k | id stringlengths 5 7 | text stringlengths 19 518k | lang stringclasses 1
value |
|---|---|---|---|---|---|
gcc7/gcc_root/lib/gcc/x86_64-pc-linux-gnu/7.3.0/plugin/include/insn-codes.h | reedtlr/mediaInfo-python-lambda | 2 | 5765306 | /* Generated automatically by the program `gencodes'
from the machine description file `md'. */
#ifndef GCC_INSN_CODES_H
#define GCC_INSN_CODES_H
enum insn_code {
CODE_FOR_nothing = 0,
CODE_FOR_x86_fnstsw_1 = 47,
CODE_FOR_x86_sahf_1 = 48,
CODE_FOR_insvhi_1 = 108,
CODE_FOR_insvsi_1 = 109,
CODE_FOR_insvdi_1 = 110,
CODE_FOR_swapxf = 128,
CODE_FOR_zero_extendqidi2 = 132,
CODE_FOR_zero_extendhidi2 = 133,
CODE_FOR_zero_extendqisi2_and = 134,
CODE_FOR_zero_extendhisi2_and = 135,
CODE_FOR_zero_extendqihi2_and = 138,
CODE_FOR_extendsidi2_1 = 146,
CODE_FOR_extendqidi2 = 147,
CODE_FOR_extendhidi2 = 148,
CODE_FOR_extendhisi2 = 149,
CODE_FOR_extendqisi2 = 151,
CODE_FOR_extendqihi2 = 153,
CODE_FOR_truncxfsf2_i387_noop = 164,
CODE_FOR_truncxfdf2_i387_noop = 165,
CODE_FOR_fix_truncsfsi_sse = 170,
CODE_FOR_fix_truncsfdi_sse = 171,
CODE_FOR_fix_truncdfsi_sse = 172,
CODE_FOR_fix_truncdfdi_sse = 173,
CODE_FOR_fix_trunchi_fisttp_i387_1 = 174,
CODE_FOR_fix_truncsi_fisttp_i387_1 = 175,
CODE_FOR_fix_truncdi_fisttp_i387_1 = 176,
CODE_FOR_fix_trunchi_i387_fisttp = 177,
CODE_FOR_fix_truncsi_i387_fisttp = 178,
CODE_FOR_fix_truncdi_i387_fisttp = 179,
CODE_FOR_fix_trunchi_i387_fisttp_with_temp = 180,
CODE_FOR_fix_truncsi_i387_fisttp_with_temp = 181,
CODE_FOR_fix_truncdi_i387_fisttp_with_temp = 182,
CODE_FOR_fix_truncdi_i387 = 186,
CODE_FOR_fix_truncdi_i387_with_temp = 187,
CODE_FOR_fix_trunchi_i387 = 188,
CODE_FOR_fix_truncsi_i387 = 189,
CODE_FOR_fix_trunchi_i387_with_temp = 190,
CODE_FOR_fix_truncsi_i387_with_temp = 191,
CODE_FOR_x86_fnstcw_1 = 192,
CODE_FOR_x86_fldcw_1 = 193,
CODE_FOR_floathisf2 = 194,
CODE_FOR_floathidf2 = 195,
CODE_FOR_floathixf2 = 196,
CODE_FOR_floatsixf2 = 197,
CODE_FOR_floatdixf2 = 198,
CODE_FOR_floatdisf2_i387_with_xmm = 207,
CODE_FOR_floatdidf2_i387_with_xmm = 208,
CODE_FOR_floatdixf2_i387_with_xmm = 209,
CODE_FOR_addsi_1_zext = 219,
CODE_FOR_addqi_ext_1 = 241,
CODE_FOR_addqi3_carry = 295,
CODE_FOR_addhi3_carry = 296,
CODE_FOR_addsi3_carry = 297,
CODE_FOR_adddi3_carry = 298,
CODE_FOR_addcarrysi = 300,
CODE_FOR_addcarrydi = 301,
CODE_FOR_subqi3_carry = 302,
CODE_FOR_subhi3_carry = 303,
CODE_FOR_subsi3_carry = 304,
CODE_FOR_subdi3_carry = 305,
CODE_FOR_subborrowsi = 307,
CODE_FOR_subborrowdi = 308,
CODE_FOR_divmodsi4_1 = 357,
CODE_FOR_divmoddi4_1 = 358,
CODE_FOR_divmodhiqi3 = 365,
CODE_FOR_udivmodsi4_1 = 366,
CODE_FOR_udivmoddi4_1 = 367,
CODE_FOR_udivmodhiqi3 = 376,
CODE_FOR_andqi_ext_1 = 401,
CODE_FOR_copysignsf3_const = 486,
CODE_FOR_copysigndf3_const = 487,
CODE_FOR_copysigntf3_const = 488,
CODE_FOR_copysignsf3_var = 489,
CODE_FOR_copysigndf3_var = 490,
CODE_FOR_copysigntf3_var = 491,
CODE_FOR_x86_64_shld = 505,
CODE_FOR_x86_shld = 506,
CODE_FOR_x86_64_shrd = 535,
CODE_FOR_x86_shrd = 536,
CODE_FOR_ashrdi3_cvt = 537,
CODE_FOR_ashrsi3_cvt = 539,
CODE_FOR_ix86_rotldi3_doubleword = 580,
CODE_FOR_ix86_rotlti3_doubleword = 581,
CODE_FOR_ix86_rotrdi3_doubleword = 582,
CODE_FOR_ix86_rotrti3_doubleword = 583,
CODE_FOR_setcc_sf_sse = 615,
CODE_FOR_setcc_df_sse = 616,
CODE_FOR_jump = 649,
CODE_FOR_blockage = 676,
CODE_FOR_prologue_use = 678,
CODE_FOR_simple_return_internal = 679,
CODE_FOR_interrupt_return = 680,
CODE_FOR_simple_return_internal_long = 681,
CODE_FOR_simple_return_pop_internal = 682,
CODE_FOR_simple_return_indirect_internal = 683,
CODE_FOR_nop = 684,
CODE_FOR_nops = 685,
CODE_FOR_pad = 686,
CODE_FOR_set_got_rex64 = 689,
CODE_FOR_set_rip_rex64 = 690,
CODE_FOR_set_got_offset_rex64 = 691,
CODE_FOR_eh_return_internal = 692,
CODE_FOR_leave = 693,
CODE_FOR_leave_rex64 = 694,
CODE_FOR_split_stack_return = 695,
CODE_FOR_ffssi2_no_cmove = 696,
CODE_FOR_ctzsi2 = 703,
CODE_FOR_ctzdi2 = 704,
CODE_FOR_bsr_rex64 = 707,
CODE_FOR_bsr = 708,
CODE_FOR_clzsi2_lzcnt = 710,
CODE_FOR_clzdi2_lzcnt = 711,
CODE_FOR_tzcnt_si = 714,
CODE_FOR_lzcnt_si = 715,
CODE_FOR_tzcnt_di = 716,
CODE_FOR_lzcnt_di = 717,
CODE_FOR_tzcnt_hi = 722,
CODE_FOR_lzcnt_hi = 723,
CODE_FOR_bmi_bextr_si = 724,
CODE_FOR_bmi_bextr_di = 725,
CODE_FOR_bmi2_pdep_si3 = 740,
CODE_FOR_bmi2_pdep_di3 = 741,
CODE_FOR_bmi2_pext_si3 = 742,
CODE_FOR_bmi2_pext_di3 = 743,
CODE_FOR_tbm_bextri_si = 744,
CODE_FOR_tbm_bextri_di = 745,
CODE_FOR_popcountsi2 = 764,
CODE_FOR_popcountdi2 = 765,
CODE_FOR_popcounthi2 = 769,
CODE_FOR_bswaphi_lowpart = 775,
CODE_FOR_paritydi2_cmp = 776,
CODE_FOR_paritysi2_cmp = 777,
CODE_FOR_tls_initial_exec_64_sun = CODE_FOR_nothing,
CODE_FOR_truncxfsf2_i387_noop_unspec = 830,
CODE_FOR_truncxfdf2_i387_noop_unspec = 831,
CODE_FOR_sqrtxf2 = 832,
CODE_FOR_sqrt_extendsfxf2_i387 = 833,
CODE_FOR_sqrt_extenddfxf2_i387 = 834,
CODE_FOR_fpremxf4_i387 = 838,
CODE_FOR_fprem1xf4_i387 = 839,
CODE_FOR_sincosxf3 = 846,
CODE_FOR_sincos_extendsfxf3_i387 = 847,
CODE_FOR_sincos_extenddfxf3_i387 = 848,
CODE_FOR_fptanxf4_i387 = 849,
CODE_FOR_fptan_extendsfxf4_i387 = 850,
CODE_FOR_fptan_extenddfxf4_i387 = 851,
CODE_FOR_fpatan_extendsfxf3_i387 = 853,
CODE_FOR_fpatan_extenddfxf3_i387 = 854,
CODE_FOR_fyl2xxf3_i387 = 855,
CODE_FOR_fyl2x_extendsfxf3_i387 = 856,
CODE_FOR_fyl2x_extenddfxf3_i387 = 857,
CODE_FOR_fyl2xp1xf3_i387 = 858,
CODE_FOR_fyl2xp1_extendsfxf3_i387 = 859,
CODE_FOR_fyl2xp1_extenddfxf3_i387 = 860,
CODE_FOR_fxtractxf3_i387 = 861,
CODE_FOR_fxtract_extendsfxf3_i387 = 862,
CODE_FOR_fxtract_extenddfxf3_i387 = 863,
CODE_FOR_fscalexf4_i387 = 865,
CODE_FOR_sse4_1_roundsf2 = 866,
CODE_FOR_sse4_1_rounddf2 = 867,
CODE_FOR_rintxf2 = 868,
CODE_FOR_rintsf2_frndint = 869,
CODE_FOR_rintdf2_frndint = 870,
CODE_FOR_fistdi2 = 872,
CODE_FOR_fistdi2_with_temp = 873,
CODE_FOR_fisthi2 = 876,
CODE_FOR_fistsi2 = 877,
CODE_FOR_fisthi2_with_temp = 878,
CODE_FOR_fistsi2_with_temp = 879,
CODE_FOR_frndintsf2_floor = 880,
CODE_FOR_frndintsf2_ceil = 881,
CODE_FOR_frndintsf2_trunc = 882,
CODE_FOR_frndintdf2_floor = 883,
CODE_FOR_frndintdf2_ceil = 884,
CODE_FOR_frndintdf2_trunc = 885,
CODE_FOR_frndintxf2_floor = 886,
CODE_FOR_frndintxf2_ceil = 887,
CODE_FOR_frndintxf2_trunc = 888,
CODE_FOR_frndintsf2_floor_i387 = 889,
CODE_FOR_frndintsf2_ceil_i387 = 890,
CODE_FOR_frndintsf2_trunc_i387 = 891,
CODE_FOR_frndintdf2_floor_i387 = 892,
CODE_FOR_frndintdf2_ceil_i387 = 893,
CODE_FOR_frndintdf2_trunc_i387 = 894,
CODE_FOR_frndintxf2_floor_i387 = 895,
CODE_FOR_frndintxf2_ceil_i387 = 896,
CODE_FOR_frndintxf2_trunc_i387 = 897,
CODE_FOR_frndintxf2_mask_pm = 898,
CODE_FOR_frndintxf2_mask_pm_i387 = 899,
CODE_FOR_fistdi2_floor = 906,
CODE_FOR_fistdi2_ceil = 907,
CODE_FOR_fistdi2_floor_with_temp = 908,
CODE_FOR_fistdi2_ceil_with_temp = 909,
CODE_FOR_fisthi2_floor = 910,
CODE_FOR_fisthi2_ceil = 911,
CODE_FOR_fistsi2_floor = 912,
CODE_FOR_fistsi2_ceil = 913,
CODE_FOR_fisthi2_floor_with_temp = 914,
CODE_FOR_fisthi2_ceil_with_temp = 915,
CODE_FOR_fistsi2_floor_with_temp = 916,
CODE_FOR_fistsi2_ceil_with_temp = 917,
CODE_FOR_fxamsf2_i387 = 918,
CODE_FOR_fxamdf2_i387 = 919,
CODE_FOR_fxamxf2_i387 = 920,
CODE_FOR_fxamsf2_i387_with_temp = 921,
CODE_FOR_fxamdf2_i387_with_temp = 922,
CODE_FOR_movmsk_df = 923,
CODE_FOR_cld = 924,
CODE_FOR_smaxsf3 = 975,
CODE_FOR_sminsf3 = 976,
CODE_FOR_smaxdf3 = 977,
CODE_FOR_smindf3 = 978,
CODE_FOR_pro_epilogue_adjust_stack_si_add = 983,
CODE_FOR_pro_epilogue_adjust_stack_di_add = 984,
CODE_FOR_pro_epilogue_adjust_stack_si_sub = 985,
CODE_FOR_pro_epilogue_adjust_stack_di_sub = 986,
CODE_FOR_allocate_stack_worker_probe_si = 987,
CODE_FOR_allocate_stack_worker_probe_di = 988,
CODE_FOR_probe_stack_si = 989,
CODE_FOR_probe_stack_di = 990,
CODE_FOR_adjust_stack_and_probesi = 991,
CODE_FOR_adjust_stack_and_probedi = 992,
CODE_FOR_probe_stack_rangesi = 993,
CODE_FOR_probe_stack_rangedi = 994,
CODE_FOR_trap = 995,
CODE_FOR_stack_protect_set_si = 999,
CODE_FOR_stack_protect_set_di = 1000,
CODE_FOR_stack_tls_protect_set_si = 1001,
CODE_FOR_stack_tls_protect_set_di = 1002,
CODE_FOR_stack_protect_test_si = 1003,
CODE_FOR_stack_protect_test_di = 1004,
CODE_FOR_stack_tls_protect_test_si = 1005,
CODE_FOR_stack_tls_protect_test_di = 1006,
CODE_FOR_sse4_2_crc32qi = 1007,
CODE_FOR_sse4_2_crc32hi = 1008,
CODE_FOR_sse4_2_crc32si = 1009,
CODE_FOR_sse4_2_crc32di = 1010,
CODE_FOR_rdpmc = 1011,
CODE_FOR_rdpmc_rex64 = 1012,
CODE_FOR_rdtsc = 1013,
CODE_FOR_rdtsc_rex64 = 1014,
CODE_FOR_rdtscp = 1015,
CODE_FOR_rdtscp_rex64 = 1016,
CODE_FOR_fxsave = 1017,
CODE_FOR_fxsave64 = 1018,
CODE_FOR_fxrstor = 1019,
CODE_FOR_fxrstor64 = 1020,
CODE_FOR_xsave = 1021,
CODE_FOR_xsaveopt = 1022,
CODE_FOR_xsavec = 1023,
CODE_FOR_xsaves = 1024,
CODE_FOR_xsave_rex64 = 1025,
CODE_FOR_xsaveopt_rex64 = 1026,
CODE_FOR_xsavec_rex64 = 1027,
CODE_FOR_xsaves_rex64 = 1028,
CODE_FOR_xsave64 = 1029,
CODE_FOR_xsaveopt64 = 1030,
CODE_FOR_xsavec64 = 1031,
CODE_FOR_xsaves64 = 1032,
CODE_FOR_xrstor = 1033,
CODE_FOR_xrstors = 1034,
CODE_FOR_xrstor_rex64 = 1035,
CODE_FOR_xrstors_rex64 = 1036,
CODE_FOR_xrstor64 = 1037,
CODE_FOR_xrstors64 = 1038,
CODE_FOR_fnstenv = 1039,
CODE_FOR_fldenv = 1040,
CODE_FOR_fnstsw = 1041,
CODE_FOR_fnclex = 1042,
CODE_FOR_lwp_slwpcbsi = 1045,
CODE_FOR_lwp_slwpcbdi = 1046,
CODE_FOR_rdfsbasesi = 1051,
CODE_FOR_rdgsbasesi = 1052,
CODE_FOR_rdfsbasedi = 1053,
CODE_FOR_rdgsbasedi = 1054,
CODE_FOR_wrfsbasesi = 1055,
CODE_FOR_wrgsbasesi = 1056,
CODE_FOR_wrfsbasedi = 1057,
CODE_FOR_wrgsbasedi = 1058,
CODE_FOR_rdrandhi_1 = 1059,
CODE_FOR_rdrandsi_1 = 1060,
CODE_FOR_rdranddi_1 = 1061,
CODE_FOR_rdseedhi_1 = 1062,
CODE_FOR_rdseedsi_1 = 1063,
CODE_FOR_rdseeddi_1 = 1064,
CODE_FOR_xbegin_1 = 1066,
CODE_FOR_xend = 1067,
CODE_FOR_xabort = 1068,
CODE_FOR_xtest_1 = 1069,
CODE_FOR_clwb = 1070,
CODE_FOR_clflushopt = 1071,
CODE_FOR_mwaitx = 1072,
CODE_FOR_monitorx_si = 1073,
CODE_FOR_monitorx_di = 1074,
CODE_FOR_clzero_si = 1075,
CODE_FOR_clzero_di = 1076,
CODE_FOR_move_size_reloc_si = 1091,
CODE_FOR_move_size_reloc_di = 1092,
CODE_FOR_rdpid = 1095,
CODE_FOR_sse_movntq = 1101,
CODE_FOR_mmx_ieee_maxv2sf3 = 1107,
CODE_FOR_mmx_ieee_minv2sf3 = 1108,
CODE_FOR_mmx_rcpv2sf2 = 1109,
CODE_FOR_mmx_rcpit1v2sf3 = 1110,
CODE_FOR_mmx_rcpit2v2sf3 = 1111,
CODE_FOR_mmx_rsqrtv2sf2 = 1112,
CODE_FOR_mmx_rsqit1v2sf3 = 1113,
CODE_FOR_mmx_haddv2sf3 = 1114,
CODE_FOR_mmx_hsubv2sf3 = 1115,
CODE_FOR_mmx_addsubv2sf3 = 1116,
CODE_FOR_mmx_gtv2sf3 = 1118,
CODE_FOR_mmx_gev2sf3 = 1119,
CODE_FOR_mmx_pf2id = 1120,
CODE_FOR_mmx_pf2iw = 1121,
CODE_FOR_mmx_pi2fw = 1122,
CODE_FOR_mmx_floatv2si2 = 1123,
CODE_FOR_mmx_pswapdv2sf2 = 1124,
CODE_FOR_mmx_ashrv4hi3 = 1155,
CODE_FOR_mmx_ashrv2si3 = 1156,
CODE_FOR_mmx_ashlv4hi3 = 1157,
CODE_FOR_mmx_lshrv4hi3 = 1158,
CODE_FOR_mmx_ashlv2si3 = 1159,
CODE_FOR_mmx_lshrv2si3 = 1160,
CODE_FOR_mmx_ashlv1di3 = 1161,
CODE_FOR_mmx_lshrv1di3 = 1162,
CODE_FOR_mmx_gtv8qi3 = 1166,
CODE_FOR_mmx_gtv4hi3 = 1167,
CODE_FOR_mmx_gtv2si3 = 1168,
CODE_FOR_mmx_andnotv8qi3 = 1169,
CODE_FOR_mmx_andnotv4hi3 = 1170,
CODE_FOR_mmx_andnotv2si3 = 1171,
CODE_FOR_mmx_packsswb = 1181,
CODE_FOR_mmx_packssdw = 1182,
CODE_FOR_mmx_packuswb = 1183,
CODE_FOR_mmx_punpckhbw = 1184,
CODE_FOR_mmx_punpcklbw = 1185,
CODE_FOR_mmx_punpckhwd = 1186,
CODE_FOR_mmx_punpcklwd = 1187,
CODE_FOR_mmx_punpckhdq = 1188,
CODE_FOR_mmx_punpckldq = 1189,
CODE_FOR_mmx_pextrw = 1191,
CODE_FOR_mmx_pshufw_1 = 1192,
CODE_FOR_mmx_pswapdv2si2 = 1193,
CODE_FOR_mmx_psadbw = 1202,
CODE_FOR_mmx_pmovmskb = 1203,
CODE_FOR_movv64qi_internal = 1208,
CODE_FOR_movv32qi_internal = 1209,
CODE_FOR_movv16qi_internal = 1210,
CODE_FOR_movv32hi_internal = 1211,
CODE_FOR_movv16hi_internal = 1212,
CODE_FOR_movv8hi_internal = 1213,
CODE_FOR_movv16si_internal = 1214,
CODE_FOR_movv8si_internal = 1215,
CODE_FOR_movv4si_internal = 1216,
CODE_FOR_movv8di_internal = 1217,
CODE_FOR_movv4di_internal = 1218,
CODE_FOR_movv2di_internal = 1219,
CODE_FOR_movv4ti_internal = 1220,
CODE_FOR_movv2ti_internal = 1221,
CODE_FOR_movv1ti_internal = 1222,
CODE_FOR_movv16sf_internal = 1223,
CODE_FOR_movv8sf_internal = 1224,
CODE_FOR_movv4sf_internal = 1225,
CODE_FOR_movv8df_internal = 1226,
CODE_FOR_movv4df_internal = 1227,
CODE_FOR_movv2df_internal = 1228,
CODE_FOR_avx512f_loadv16si_mask = 1229,
CODE_FOR_avx512vl_loadv8si_mask = 1230,
CODE_FOR_avx512vl_loadv4si_mask = 1231,
CODE_FOR_avx512f_loadv8di_mask = 1232,
CODE_FOR_avx512vl_loadv4di_mask = 1233,
CODE_FOR_avx512vl_loadv2di_mask = 1234,
CODE_FOR_avx512f_loadv16sf_mask = 1235,
CODE_FOR_avx512vl_loadv8sf_mask = 1236,
CODE_FOR_avx512vl_loadv4sf_mask = 1237,
CODE_FOR_avx512f_loadv8df_mask = 1238,
CODE_FOR_avx512vl_loadv4df_mask = 1239,
CODE_FOR_avx512vl_loadv2df_mask = 1240,
CODE_FOR_avx512bw_loadv64qi_mask = 1241,
CODE_FOR_avx512vl_loadv16qi_mask = 1242,
CODE_FOR_avx512vl_loadv32qi_mask = 1243,
CODE_FOR_avx512bw_loadv32hi_mask = 1244,
CODE_FOR_avx512vl_loadv16hi_mask = 1245,
CODE_FOR_avx512vl_loadv8hi_mask = 1246,
CODE_FOR_avx512f_blendmv16si = 1247,
CODE_FOR_avx512vl_blendmv8si = 1248,
CODE_FOR_avx512vl_blendmv4si = 1249,
CODE_FOR_avx512f_blendmv8di = 1250,
CODE_FOR_avx512vl_blendmv4di = 1251,
CODE_FOR_avx512vl_blendmv2di = 1252,
CODE_FOR_avx512f_blendmv16sf = 1253,
CODE_FOR_avx512vl_blendmv8sf = 1254,
CODE_FOR_avx512vl_blendmv4sf = 1255,
CODE_FOR_avx512f_blendmv8df = 1256,
CODE_FOR_avx512vl_blendmv4df = 1257,
CODE_FOR_avx512vl_blendmv2df = 1258,
CODE_FOR_avx512bw_blendmv64qi = 1259,
CODE_FOR_avx512vl_blendmv16qi = 1260,
CODE_FOR_avx512vl_blendmv32qi = 1261,
CODE_FOR_avx512bw_blendmv32hi = 1262,
CODE_FOR_avx512vl_blendmv16hi = 1263,
CODE_FOR_avx512vl_blendmv8hi = 1264,
CODE_FOR_avx512f_storev16si_mask = 1265,
CODE_FOR_avx512vl_storev8si_mask = 1266,
CODE_FOR_avx512vl_storev4si_mask = 1267,
CODE_FOR_avx512f_storev8di_mask = 1268,
CODE_FOR_avx512vl_storev4di_mask = 1269,
CODE_FOR_avx512vl_storev2di_mask = 1270,
CODE_FOR_avx512f_storev16sf_mask = 1271,
CODE_FOR_avx512vl_storev8sf_mask = 1272,
CODE_FOR_avx512vl_storev4sf_mask = 1273,
CODE_FOR_avx512f_storev8df_mask = 1274,
CODE_FOR_avx512vl_storev4df_mask = 1275,
CODE_FOR_avx512vl_storev2df_mask = 1276,
CODE_FOR_avx512bw_storev64qi_mask = 1277,
CODE_FOR_avx512vl_storev16qi_mask = 1278,
CODE_FOR_avx512vl_storev32qi_mask = 1279,
CODE_FOR_avx512bw_storev32hi_mask = 1280,
CODE_FOR_avx512vl_storev16hi_mask = 1281,
CODE_FOR_avx512vl_storev8hi_mask = 1282,
CODE_FOR_sse2_movq128 = 1283,
CODE_FOR_movdi_to_sse = 1284,
CODE_FOR_avx_lddqu256 = 1285,
CODE_FOR_sse3_lddqu = 1286,
CODE_FOR_sse2_movntisi = 1287,
CODE_FOR_sse2_movntidi = 1288,
CODE_FOR_avx512f_movntv16sf = 1289,
CODE_FOR_avx_movntv8sf = 1290,
CODE_FOR_sse_movntv4sf = 1291,
CODE_FOR_avx512f_movntv8df = 1292,
CODE_FOR_avx_movntv4df = 1293,
CODE_FOR_sse2_movntv2df = 1294,
CODE_FOR_avx512f_movntv8di = 1295,
CODE_FOR_avx_movntv4di = 1296,
CODE_FOR_sse2_movntv2di = 1297,
CODE_FOR_kandqi = 1298,
CODE_FOR_kiorqi = 1299,
CODE_FOR_kxorqi = 1300,
CODE_FOR_kandhi = 1301,
CODE_FOR_kiorhi = 1302,
CODE_FOR_kxorhi = 1303,
CODE_FOR_kandsi = 1304,
CODE_FOR_kiorsi = 1305,
CODE_FOR_kxorsi = 1306,
CODE_FOR_kanddi = 1307,
CODE_FOR_kiordi = 1308,
CODE_FOR_kxordi = 1309,
CODE_FOR_kandnqi = 1310,
CODE_FOR_kandnhi = 1311,
CODE_FOR_kandnsi = 1312,
CODE_FOR_kandndi = 1313,
CODE_FOR_kxnorqi = 1314,
CODE_FOR_kxnorhi = 1315,
CODE_FOR_kxnorsi = 1316,
CODE_FOR_kxnordi = 1317,
CODE_FOR_knotqi = 1318,
CODE_FOR_knothi = 1319,
CODE_FOR_knotsi = 1320,
CODE_FOR_knotdi = 1321,
CODE_FOR_kaddqi = 1322,
CODE_FOR_kaddhi = 1323,
CODE_FOR_kaddsi = 1324,
CODE_FOR_kadddi = 1325,
CODE_FOR_kashiftqi = 1326,
CODE_FOR_klshiftrtqi = 1327,
CODE_FOR_kashifthi = 1328,
CODE_FOR_klshiftrthi = 1329,
CODE_FOR_kashiftsi = 1330,
CODE_FOR_klshiftrtsi = 1331,
CODE_FOR_kashiftdi = 1332,
CODE_FOR_klshiftrtdi = 1333,
CODE_FOR_ktestqi = 1334,
CODE_FOR_ktesthi = 1335,
CODE_FOR_ktestsi = 1336,
CODE_FOR_ktestdi = 1337,
CODE_FOR_kortestqi = 1338,
CODE_FOR_kortesthi = 1339,
CODE_FOR_kortestsi = 1340,
CODE_FOR_kortestdi = 1341,
CODE_FOR_kunpckhi = 1342,
CODE_FOR_kunpcksi = 1343,
CODE_FOR_kunpckdi = 1344,
CODE_FOR_sse_vmaddv4sf3 = 1399,
CODE_FOR_sse_vmaddv4sf3_round = 1400,
CODE_FOR_sse_vmsubv4sf3 = 1401,
CODE_FOR_sse_vmsubv4sf3_round = 1402,
CODE_FOR_sse2_vmaddv2df3 = 1403,
CODE_FOR_sse2_vmaddv2df3_round = 1404,
CODE_FOR_sse2_vmsubv2df3 = 1405,
CODE_FOR_sse2_vmsubv2df3_round = 1406,
CODE_FOR_sse_vmmulv4sf3 = 1431,
CODE_FOR_sse_vmmulv4sf3_round = 1432,
CODE_FOR_sse_vmdivv4sf3 = 1433,
CODE_FOR_sse_vmdivv4sf3_round = 1434,
CODE_FOR_sse2_vmmulv2df3 = 1435,
CODE_FOR_sse2_vmmulv2df3_round = 1436,
CODE_FOR_sse2_vmdivv2df3 = 1437,
CODE_FOR_sse2_vmdivv2df3_round = 1438,
CODE_FOR_avx512f_divv16sf3 = 1439,
CODE_FOR_avx512f_divv16sf3_round = 1440,
CODE_FOR_avx512f_divv16sf3_mask = 1441,
CODE_FOR_avx512f_divv16sf3_mask_round = 1442,
CODE_FOR_avx_divv8sf3 = 1443,
CODE_FOR_avx_divv8sf3_round = CODE_FOR_nothing,
CODE_FOR_avx_divv8sf3_mask = 1444,
CODE_FOR_avx_divv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_sse_divv4sf3 = 1445,
CODE_FOR_sse_divv4sf3_round = CODE_FOR_nothing,
CODE_FOR_sse_divv4sf3_mask = 1446,
CODE_FOR_sse_divv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_divv8df3 = 1447,
CODE_FOR_avx512f_divv8df3_round = 1448,
CODE_FOR_avx512f_divv8df3_mask = 1449,
CODE_FOR_avx512f_divv8df3_mask_round = 1450,
CODE_FOR_avx_divv4df3 = 1451,
CODE_FOR_avx_divv4df3_round = CODE_FOR_nothing,
CODE_FOR_avx_divv4df3_mask = 1452,
CODE_FOR_avx_divv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sse2_divv2df3 = 1453,
CODE_FOR_sse2_divv2df3_round = CODE_FOR_nothing,
CODE_FOR_sse2_divv2df3_mask = 1454,
CODE_FOR_sse2_divv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx_rcpv8sf2 = 1455,
CODE_FOR_sse_rcpv4sf2 = 1456,
CODE_FOR_sse_vmrcpv4sf2 = 1457,
CODE_FOR_rcp14v16sf_mask = 1459,
CODE_FOR_rcp14v8sf_mask = 1461,
CODE_FOR_rcp14v4sf_mask = 1463,
CODE_FOR_rcp14v8df_mask = 1465,
CODE_FOR_rcp14v4df_mask = 1467,
CODE_FOR_rcp14v2df_mask = 1469,
CODE_FOR_srcp14v4sf = 1470,
CODE_FOR_srcp14v2df = 1471,
CODE_FOR_avx512f_sqrtv16sf2 = 1472,
CODE_FOR_avx512f_sqrtv16sf2_round = 1473,
CODE_FOR_avx512f_sqrtv16sf2_mask = 1474,
CODE_FOR_avx512f_sqrtv16sf2_mask_round = 1475,
CODE_FOR_avx_sqrtv8sf2 = 1476,
CODE_FOR_avx_sqrtv8sf2_round = CODE_FOR_nothing,
CODE_FOR_avx_sqrtv8sf2_mask = 1477,
CODE_FOR_avx_sqrtv8sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_sse_sqrtv4sf2 = 1478,
CODE_FOR_sse_sqrtv4sf2_round = CODE_FOR_nothing,
CODE_FOR_sse_sqrtv4sf2_mask = 1479,
CODE_FOR_sse_sqrtv4sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_sqrtv8df2 = 1480,
CODE_FOR_avx512f_sqrtv8df2_round = 1481,
CODE_FOR_avx512f_sqrtv8df2_mask = 1482,
CODE_FOR_avx512f_sqrtv8df2_mask_round = 1483,
CODE_FOR_avx_sqrtv4df2 = 1484,
CODE_FOR_avx_sqrtv4df2_round = CODE_FOR_nothing,
CODE_FOR_avx_sqrtv4df2_mask = 1485,
CODE_FOR_avx_sqrtv4df2_mask_round = CODE_FOR_nothing,
CODE_FOR_sse2_sqrtv2df2 = 1486,
CODE_FOR_sse2_sqrtv2df2_round = CODE_FOR_nothing,
CODE_FOR_sse2_sqrtv2df2_mask = 1487,
CODE_FOR_sse2_sqrtv2df2_mask_round = CODE_FOR_nothing,
CODE_FOR_sse_vmsqrtv4sf2 = 1488,
CODE_FOR_sse_vmsqrtv4sf2_round = 1489,
CODE_FOR_sse2_vmsqrtv2df2 = 1490,
CODE_FOR_sse2_vmsqrtv2df2_round = 1491,
CODE_FOR_avx_rsqrtv8sf2 = 1492,
CODE_FOR_sse_rsqrtv4sf2 = 1493,
CODE_FOR_rsqrt14v16sf_mask = 1495,
CODE_FOR_rsqrt14v8sf_mask = 1497,
CODE_FOR_rsqrt14v4sf_mask = 1499,
CODE_FOR_rsqrt14v8df_mask = 1501,
CODE_FOR_rsqrt14v4df_mask = 1503,
CODE_FOR_rsqrt14v2df_mask = 1505,
CODE_FOR_rsqrt14v4sf = 1506,
CODE_FOR_rsqrt14v2df = 1507,
CODE_FOR_sse_vmrsqrtv4sf2 = 1508,
CODE_FOR_ieee_maxv16sf3 = 1557,
CODE_FOR_ieee_maxv16sf3_round = 1558,
CODE_FOR_ieee_maxv16sf3_mask = 1559,
CODE_FOR_ieee_maxv16sf3_mask_round = 1560,
CODE_FOR_ieee_minv16sf3 = 1561,
CODE_FOR_ieee_minv16sf3_round = 1562,
CODE_FOR_ieee_minv16sf3_mask = 1563,
CODE_FOR_ieee_minv16sf3_mask_round = 1564,
CODE_FOR_ieee_maxv8sf3 = 1565,
CODE_FOR_ieee_maxv8sf3_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv8sf3_mask = 1566,
CODE_FOR_ieee_maxv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv8sf3 = 1567,
CODE_FOR_ieee_minv8sf3_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv8sf3_mask = 1568,
CODE_FOR_ieee_minv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv4sf3 = 1569,
CODE_FOR_ieee_maxv4sf3_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv4sf3_mask = 1570,
CODE_FOR_ieee_maxv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv4sf3 = 1571,
CODE_FOR_ieee_minv4sf3_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv4sf3_mask = 1572,
CODE_FOR_ieee_minv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv8df3 = 1573,
CODE_FOR_ieee_maxv8df3_round = 1574,
CODE_FOR_ieee_maxv8df3_mask = 1575,
CODE_FOR_ieee_maxv8df3_mask_round = 1576,
CODE_FOR_ieee_minv8df3 = 1577,
CODE_FOR_ieee_minv8df3_round = 1578,
CODE_FOR_ieee_minv8df3_mask = 1579,
CODE_FOR_ieee_minv8df3_mask_round = 1580,
CODE_FOR_ieee_maxv4df3 = 1581,
CODE_FOR_ieee_maxv4df3_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv4df3_mask = 1582,
CODE_FOR_ieee_maxv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv4df3 = 1583,
CODE_FOR_ieee_minv4df3_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv4df3_mask = 1584,
CODE_FOR_ieee_minv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv2df3 = 1585,
CODE_FOR_ieee_maxv2df3_round = CODE_FOR_nothing,
CODE_FOR_ieee_maxv2df3_mask = 1586,
CODE_FOR_ieee_maxv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv2df3 = 1587,
CODE_FOR_ieee_minv2df3_round = CODE_FOR_nothing,
CODE_FOR_ieee_minv2df3_mask = 1588,
CODE_FOR_ieee_minv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sse_vmsmaxv4sf3 = 1589,
CODE_FOR_sse_vmsmaxv4sf3_round = 1590,
CODE_FOR_sse_vmsminv4sf3 = 1591,
CODE_FOR_sse_vmsminv4sf3_round = 1592,
CODE_FOR_sse2_vmsmaxv2df3 = 1593,
CODE_FOR_sse2_vmsmaxv2df3_round = 1594,
CODE_FOR_sse2_vmsminv2df3 = 1595,
CODE_FOR_sse2_vmsminv2df3_round = 1596,
CODE_FOR_avx_addsubv4df3 = 1597,
CODE_FOR_sse3_addsubv2df3 = 1598,
CODE_FOR_avx_addsubv8sf3 = 1599,
CODE_FOR_sse3_addsubv4sf3 = 1600,
CODE_FOR_avx_haddv4df3 = 1601,
CODE_FOR_avx_hsubv4df3 = 1602,
CODE_FOR_sse3_hsubv2df3 = 1604,
CODE_FOR_avx_haddv8sf3 = 1607,
CODE_FOR_avx_hsubv8sf3 = 1608,
CODE_FOR_sse3_haddv4sf3 = 1609,
CODE_FOR_sse3_hsubv4sf3 = 1610,
CODE_FOR_reducepv16sf_mask = 1612,
CODE_FOR_reducepv8sf_mask = 1614,
CODE_FOR_reducepv4sf_mask = 1616,
CODE_FOR_reducepv8df_mask = 1618,
CODE_FOR_reducepv4df_mask = 1620,
CODE_FOR_reducepv2df_mask = 1622,
CODE_FOR_reducesv4sf = 1623,
CODE_FOR_reducesv2df = 1624,
CODE_FOR_avx_cmpv8sf3 = 1625,
CODE_FOR_avx_cmpv4sf3 = 1626,
CODE_FOR_avx_cmpv4df3 = 1627,
CODE_FOR_avx_cmpv2df3 = 1628,
CODE_FOR_avx_vmcmpv4sf3 = 1629,
CODE_FOR_avx_vmcmpv2df3 = 1630,
CODE_FOR_avx_maskcmpv8sf3 = 1635,
CODE_FOR_sse_maskcmpv4sf3 = 1636,
CODE_FOR_avx_maskcmpv4df3 = 1637,
CODE_FOR_sse2_maskcmpv2df3 = 1638,
CODE_FOR_sse_vmmaskcmpv4sf3 = 1639,
CODE_FOR_sse2_vmmaskcmpv2df3 = 1640,
CODE_FOR_avx512f_cmpv16si3 = 1641,
CODE_FOR_avx512f_cmpv16si3_mask = 1642,
CODE_FOR_avx512f_cmpv16si3_round = 1643,
CODE_FOR_avx512f_cmpv16si3_mask_round = 1644,
CODE_FOR_avx512vl_cmpv8si3 = 1645,
CODE_FOR_avx512vl_cmpv8si3_mask = 1646,
CODE_FOR_avx512vl_cmpv8si3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv8si3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4si3 = 1647,
CODE_FOR_avx512vl_cmpv4si3_mask = 1648,
CODE_FOR_avx512vl_cmpv4si3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4si3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_cmpv8di3 = 1649,
CODE_FOR_avx512f_cmpv8di3_mask = 1650,
CODE_FOR_avx512f_cmpv8di3_round = 1651,
CODE_FOR_avx512f_cmpv8di3_mask_round = 1652,
CODE_FOR_avx512vl_cmpv4di3 = 1653,
CODE_FOR_avx512vl_cmpv4di3_mask = 1654,
CODE_FOR_avx512vl_cmpv4di3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4di3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv2di3 = 1655,
CODE_FOR_avx512vl_cmpv2di3_mask = 1656,
CODE_FOR_avx512vl_cmpv2di3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv2di3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_cmpv16sf3 = 1657,
CODE_FOR_avx512f_cmpv16sf3_mask = 1658,
CODE_FOR_avx512f_cmpv16sf3_round = 1659,
CODE_FOR_avx512f_cmpv16sf3_mask_round = 1660,
CODE_FOR_avx512vl_cmpv8sf3 = 1661,
CODE_FOR_avx512vl_cmpv8sf3_mask = 1662,
CODE_FOR_avx512vl_cmpv8sf3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4sf3 = 1663,
CODE_FOR_avx512vl_cmpv4sf3_mask = 1664,
CODE_FOR_avx512vl_cmpv4sf3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_cmpv8df3 = 1665,
CODE_FOR_avx512f_cmpv8df3_mask = 1666,
CODE_FOR_avx512f_cmpv8df3_round = 1667,
CODE_FOR_avx512f_cmpv8df3_mask_round = 1668,
CODE_FOR_avx512vl_cmpv4df3 = 1669,
CODE_FOR_avx512vl_cmpv4df3_mask = 1670,
CODE_FOR_avx512vl_cmpv4df3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv2df3 = 1671,
CODE_FOR_avx512vl_cmpv2df3_mask = 1672,
CODE_FOR_avx512vl_cmpv2df3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_cmpv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512bw_cmpv64qi3 = 1673,
CODE_FOR_avx512bw_cmpv64qi3_mask = 1674,
CODE_FOR_avx512vl_cmpv16qi3 = 1675,
CODE_FOR_avx512vl_cmpv16qi3_mask = 1676,
CODE_FOR_avx512vl_cmpv32qi3 = 1677,
CODE_FOR_avx512vl_cmpv32qi3_mask = 1678,
CODE_FOR_avx512bw_cmpv32hi3 = 1679,
CODE_FOR_avx512bw_cmpv32hi3_mask = 1680,
CODE_FOR_avx512vl_cmpv16hi3 = 1681,
CODE_FOR_avx512vl_cmpv16hi3_mask = 1682,
CODE_FOR_avx512vl_cmpv8hi3 = 1683,
CODE_FOR_avx512vl_cmpv8hi3_mask = 1684,
CODE_FOR_avx512bw_ucmpv64qi3 = 1685,
CODE_FOR_avx512bw_ucmpv64qi3_mask = 1686,
CODE_FOR_avx512vl_ucmpv16qi3 = 1687,
CODE_FOR_avx512vl_ucmpv16qi3_mask = 1688,
CODE_FOR_avx512vl_ucmpv32qi3 = 1689,
CODE_FOR_avx512vl_ucmpv32qi3_mask = 1690,
CODE_FOR_avx512bw_ucmpv32hi3 = 1691,
CODE_FOR_avx512bw_ucmpv32hi3_mask = 1692,
CODE_FOR_avx512vl_ucmpv16hi3 = 1693,
CODE_FOR_avx512vl_ucmpv16hi3_mask = 1694,
CODE_FOR_avx512vl_ucmpv8hi3 = 1695,
CODE_FOR_avx512vl_ucmpv8hi3_mask = 1696,
CODE_FOR_avx512f_ucmpv16si3 = 1697,
CODE_FOR_avx512f_ucmpv16si3_mask = 1698,
CODE_FOR_avx512vl_ucmpv8si3 = 1699,
CODE_FOR_avx512vl_ucmpv8si3_mask = 1700,
CODE_FOR_avx512vl_ucmpv4si3 = 1701,
CODE_FOR_avx512vl_ucmpv4si3_mask = 1702,
CODE_FOR_avx512f_ucmpv8di3 = 1703,
CODE_FOR_avx512f_ucmpv8di3_mask = 1704,
CODE_FOR_avx512vl_ucmpv4di3 = 1705,
CODE_FOR_avx512vl_ucmpv4di3_mask = 1706,
CODE_FOR_avx512vl_ucmpv2di3 = 1707,
CODE_FOR_avx512vl_ucmpv2di3_mask = 1708,
CODE_FOR_avx512f_vmcmpv4sf3 = 1709,
CODE_FOR_avx512f_vmcmpv4sf3_round = 1710,
CODE_FOR_avx512f_vmcmpv2df3 = 1711,
CODE_FOR_avx512f_vmcmpv2df3_round = 1712,
CODE_FOR_avx512f_vmcmpv4sf3_mask = 1713,
CODE_FOR_avx512f_vmcmpv4sf3_mask_round = 1714,
CODE_FOR_avx512f_vmcmpv2df3_mask = 1715,
CODE_FOR_avx512f_vmcmpv2df3_mask_round = 1716,
CODE_FOR_avx512f_maskcmpv16sf3 = 1717,
CODE_FOR_avx512f_maskcmpv8sf3 = 1718,
CODE_FOR_avx512f_maskcmpv4sf3 = 1719,
CODE_FOR_avx512f_maskcmpv8df3 = 1720,
CODE_FOR_avx512f_maskcmpv4df3 = 1721,
CODE_FOR_avx512f_maskcmpv2df3 = 1722,
CODE_FOR_sse_comi = 1723,
CODE_FOR_sse_comi_round = 1724,
CODE_FOR_sse2_comi = 1725,
CODE_FOR_sse2_comi_round = 1726,
CODE_FOR_sse_ucomi = 1727,
CODE_FOR_sse_ucomi_round = 1728,
CODE_FOR_sse2_ucomi = 1729,
CODE_FOR_sse2_ucomi_round = 1730,
CODE_FOR_avx_andnotv8sf3 = 1731,
CODE_FOR_avx_andnotv8sf3_mask = 1732,
CODE_FOR_sse_andnotv4sf3 = 1733,
CODE_FOR_sse_andnotv4sf3_mask = 1734,
CODE_FOR_avx_andnotv4df3 = 1735,
CODE_FOR_avx_andnotv4df3_mask = 1736,
CODE_FOR_sse2_andnotv2df3 = 1737,
CODE_FOR_sse2_andnotv2df3_mask = 1738,
CODE_FOR_avx512f_andnotv16sf3 = 1739,
CODE_FOR_avx512f_andnotv16sf3_mask = 1740,
CODE_FOR_avx512f_andnotv8df3 = 1741,
CODE_FOR_avx512f_andnotv8df3_mask = 1742,
CODE_FOR_fma_fmadd_v16sf_maskz_1 = 1800,
CODE_FOR_fma_fmadd_v16sf_maskz_1_round = 1801,
CODE_FOR_fma_fmadd_v8sf_maskz_1 = 1803,
CODE_FOR_fma_fmadd_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmadd_v4sf_maskz_1 = 1805,
CODE_FOR_fma_fmadd_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmadd_v8df_maskz_1 = 1809,
CODE_FOR_fma_fmadd_v8df_maskz_1_round = 1810,
CODE_FOR_fma_fmadd_v4df_maskz_1 = 1812,
CODE_FOR_fma_fmadd_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmadd_v2df_maskz_1 = 1814,
CODE_FOR_fma_fmadd_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmadd_v16sf_mask = 1815,
CODE_FOR_avx512f_fmadd_v16sf_mask_round = 1816,
CODE_FOR_avx512vl_fmadd_v8sf_mask = 1817,
CODE_FOR_avx512vl_fmadd_v8sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fmadd_v4sf_mask = 1818,
CODE_FOR_avx512vl_fmadd_v4sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmadd_v8df_mask = 1819,
CODE_FOR_avx512f_fmadd_v8df_mask_round = 1820,
CODE_FOR_avx512vl_fmadd_v4df_mask = 1821,
CODE_FOR_avx512vl_fmadd_v4df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fmadd_v2df_mask = 1822,
CODE_FOR_avx512vl_fmadd_v2df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmadd_v16sf_mask3 = 1823,
CODE_FOR_avx512f_fmadd_v16sf_mask3_round = 1824,
CODE_FOR_avx512vl_fmadd_v8sf_mask3 = 1825,
CODE_FOR_avx512vl_fmadd_v8sf_mask3_round = 1826,
CODE_FOR_avx512vl_fmadd_v4sf_mask3 = 1827,
CODE_FOR_avx512vl_fmadd_v4sf_mask3_round = 1828,
CODE_FOR_avx512f_fmadd_v8df_mask3 = 1829,
CODE_FOR_avx512f_fmadd_v8df_mask3_round = 1830,
CODE_FOR_avx512vl_fmadd_v4df_mask3 = 1831,
CODE_FOR_avx512vl_fmadd_v4df_mask3_round = 1832,
CODE_FOR_avx512vl_fmadd_v2df_mask3 = 1833,
CODE_FOR_avx512vl_fmadd_v2df_mask3_round = 1834,
CODE_FOR_fma_fmsub_v16sf_maskz_1 = 1844,
CODE_FOR_fma_fmsub_v16sf_maskz_1_round = 1845,
CODE_FOR_fma_fmsub_v8sf_maskz_1 = 1847,
CODE_FOR_fma_fmsub_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsub_v4sf_maskz_1 = 1849,
CODE_FOR_fma_fmsub_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsub_v8df_maskz_1 = 1853,
CODE_FOR_fma_fmsub_v8df_maskz_1_round = 1854,
CODE_FOR_fma_fmsub_v4df_maskz_1 = 1856,
CODE_FOR_fma_fmsub_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsub_v2df_maskz_1 = 1858,
CODE_FOR_fma_fmsub_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmsub_v16sf_mask = 1859,
CODE_FOR_avx512f_fmsub_v16sf_mask_round = 1860,
CODE_FOR_avx512vl_fmsub_v8sf_mask = 1861,
CODE_FOR_avx512vl_fmsub_v8sf_mask_round = 1862,
CODE_FOR_avx512vl_fmsub_v4sf_mask = 1863,
CODE_FOR_avx512vl_fmsub_v4sf_mask_round = 1864,
CODE_FOR_avx512f_fmsub_v8df_mask = 1865,
CODE_FOR_avx512f_fmsub_v8df_mask_round = 1866,
CODE_FOR_avx512vl_fmsub_v4df_mask = 1867,
CODE_FOR_avx512vl_fmsub_v4df_mask_round = 1868,
CODE_FOR_avx512vl_fmsub_v2df_mask = 1869,
CODE_FOR_avx512vl_fmsub_v2df_mask_round = 1870,
CODE_FOR_avx512f_fmsub_v16sf_mask3 = 1871,
CODE_FOR_avx512f_fmsub_v16sf_mask3_round = 1872,
CODE_FOR_avx512vl_fmsub_v8sf_mask3 = 1873,
CODE_FOR_avx512vl_fmsub_v8sf_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fmsub_v4sf_mask3 = 1874,
CODE_FOR_avx512vl_fmsub_v4sf_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmsub_v8df_mask3 = 1875,
CODE_FOR_avx512f_fmsub_v8df_mask3_round = 1876,
CODE_FOR_avx512vl_fmsub_v4df_mask3 = 1877,
CODE_FOR_avx512vl_fmsub_v4df_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fmsub_v2df_mask3 = 1878,
CODE_FOR_avx512vl_fmsub_v2df_mask3_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmadd_v16sf_maskz_1 = 1888,
CODE_FOR_fma_fnmadd_v16sf_maskz_1_round = 1889,
CODE_FOR_fma_fnmadd_v8sf_maskz_1 = 1891,
CODE_FOR_fma_fnmadd_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmadd_v4sf_maskz_1 = 1893,
CODE_FOR_fma_fnmadd_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmadd_v8df_maskz_1 = 1897,
CODE_FOR_fma_fnmadd_v8df_maskz_1_round = 1898,
CODE_FOR_fma_fnmadd_v4df_maskz_1 = 1900,
CODE_FOR_fma_fnmadd_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmadd_v2df_maskz_1 = 1902,
CODE_FOR_fma_fnmadd_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmadd_v16sf_mask = 1903,
CODE_FOR_avx512f_fnmadd_v16sf_mask_round = 1904,
CODE_FOR_avx512vl_fnmadd_v8sf_mask = 1905,
CODE_FOR_avx512vl_fnmadd_v8sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmadd_v4sf_mask = 1906,
CODE_FOR_avx512vl_fnmadd_v4sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmadd_v8df_mask = 1907,
CODE_FOR_avx512f_fnmadd_v8df_mask_round = 1908,
CODE_FOR_avx512vl_fnmadd_v4df_mask = 1909,
CODE_FOR_avx512vl_fnmadd_v4df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmadd_v2df_mask = 1910,
CODE_FOR_avx512vl_fnmadd_v2df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmadd_v16sf_mask3 = 1911,
CODE_FOR_avx512f_fnmadd_v16sf_mask3_round = 1912,
CODE_FOR_avx512vl_fnmadd_v8sf_mask3 = 1913,
CODE_FOR_avx512vl_fnmadd_v8sf_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmadd_v4sf_mask3 = 1914,
CODE_FOR_avx512vl_fnmadd_v4sf_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmadd_v8df_mask3 = 1915,
CODE_FOR_avx512f_fnmadd_v8df_mask3_round = 1916,
CODE_FOR_avx512vl_fnmadd_v4df_mask3 = 1917,
CODE_FOR_avx512vl_fnmadd_v4df_mask3_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmadd_v2df_mask3 = 1918,
CODE_FOR_avx512vl_fnmadd_v2df_mask3_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmsub_v16sf_maskz_1 = 1942,
CODE_FOR_fma_fnmsub_v16sf_maskz_1_round = 1943,
CODE_FOR_fma_fnmsub_v8sf_maskz_1 = 1945,
CODE_FOR_fma_fnmsub_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmsub_v4sf_maskz_1 = 1947,
CODE_FOR_fma_fnmsub_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmsub_v8df_maskz_1 = 1951,
CODE_FOR_fma_fnmsub_v8df_maskz_1_round = 1952,
CODE_FOR_fma_fnmsub_v4df_maskz_1 = 1954,
CODE_FOR_fma_fnmsub_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fnmsub_v2df_maskz_1 = 1956,
CODE_FOR_fma_fnmsub_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmsub_v16sf_mask = 1957,
CODE_FOR_avx512f_fnmsub_v16sf_mask_round = 1958,
CODE_FOR_avx512vl_fnmsub_v8sf_mask = 1959,
CODE_FOR_avx512vl_fnmsub_v8sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmsub_v4sf_mask = 1960,
CODE_FOR_avx512vl_fnmsub_v4sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmsub_v8df_mask = 1961,
CODE_FOR_avx512f_fnmsub_v8df_mask_round = 1962,
CODE_FOR_avx512vl_fnmsub_v4df_mask = 1963,
CODE_FOR_avx512vl_fnmsub_v4df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512vl_fnmsub_v2df_mask = 1964,
CODE_FOR_avx512vl_fnmsub_v2df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fnmsub_v16sf_mask3 = 1965,
CODE_FOR_avx512f_fnmsub_v16sf_mask3_round = 1966,
CODE_FOR_avx512vl_fnmsub_v8sf_mask3 = 1967,
CODE_FOR_avx512vl_fnmsub_v8sf_mask3_round = 1968,
CODE_FOR_avx512vl_fnmsub_v4sf_mask3 = 1969,
CODE_FOR_avx512vl_fnmsub_v4sf_mask3_round = 1970,
CODE_FOR_avx512f_fnmsub_v8df_mask3 = 1971,
CODE_FOR_avx512f_fnmsub_v8df_mask3_round = 1972,
CODE_FOR_avx512vl_fnmsub_v4df_mask3 = 1973,
CODE_FOR_avx512vl_fnmsub_v4df_mask3_round = 1974,
CODE_FOR_avx512vl_fnmsub_v2df_mask3 = 1975,
CODE_FOR_avx512vl_fnmsub_v2df_mask3_round = 1976,
CODE_FOR_fma_fmaddsub_v16sf_maskz_1 = 1984,
CODE_FOR_fma_fmaddsub_v16sf_maskz_1_round = 1985,
CODE_FOR_fma_fmaddsub_v8sf_maskz_1 = 1987,
CODE_FOR_fma_fmaddsub_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmaddsub_v4sf_maskz_1 = 1989,
CODE_FOR_fma_fmaddsub_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmaddsub_v8df_maskz_1 = 1993,
CODE_FOR_fma_fmaddsub_v8df_maskz_1_round = 1994,
CODE_FOR_fma_fmaddsub_v4df_maskz_1 = 1996,
CODE_FOR_fma_fmaddsub_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmaddsub_v2df_maskz_1 = 1998,
CODE_FOR_fma_fmaddsub_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmaddsub_v16sf_mask = 1999,
CODE_FOR_avx512f_fmaddsub_v16sf_mask_round = 2000,
CODE_FOR_avx512vl_fmaddsub_v8sf_mask = 2001,
CODE_FOR_avx512vl_fmaddsub_v8sf_mask_round = 2002,
CODE_FOR_avx512vl_fmaddsub_v4sf_mask = 2003,
CODE_FOR_avx512vl_fmaddsub_v4sf_mask_round = 2004,
CODE_FOR_avx512f_fmaddsub_v8df_mask = 2005,
CODE_FOR_avx512f_fmaddsub_v8df_mask_round = 2006,
CODE_FOR_avx512vl_fmaddsub_v4df_mask = 2007,
CODE_FOR_avx512vl_fmaddsub_v4df_mask_round = 2008,
CODE_FOR_avx512vl_fmaddsub_v2df_mask = 2009,
CODE_FOR_avx512vl_fmaddsub_v2df_mask_round = 2010,
CODE_FOR_avx512f_fmaddsub_v16sf_mask3 = 2011,
CODE_FOR_avx512f_fmaddsub_v16sf_mask3_round = 2012,
CODE_FOR_avx512vl_fmaddsub_v8sf_mask3 = 2013,
CODE_FOR_avx512vl_fmaddsub_v8sf_mask3_round = 2014,
CODE_FOR_avx512vl_fmaddsub_v4sf_mask3 = 2015,
CODE_FOR_avx512vl_fmaddsub_v4sf_mask3_round = 2016,
CODE_FOR_avx512f_fmaddsub_v8df_mask3 = 2017,
CODE_FOR_avx512f_fmaddsub_v8df_mask3_round = 2018,
CODE_FOR_avx512vl_fmaddsub_v4df_mask3 = 2019,
CODE_FOR_avx512vl_fmaddsub_v4df_mask3_round = 2020,
CODE_FOR_avx512vl_fmaddsub_v2df_mask3 = 2021,
CODE_FOR_avx512vl_fmaddsub_v2df_mask3_round = 2022,
CODE_FOR_fma_fmsubadd_v16sf_maskz_1 = 2030,
CODE_FOR_fma_fmsubadd_v16sf_maskz_1_round = 2031,
CODE_FOR_fma_fmsubadd_v8sf_maskz_1 = 2033,
CODE_FOR_fma_fmsubadd_v8sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsubadd_v4sf_maskz_1 = 2035,
CODE_FOR_fma_fmsubadd_v4sf_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsubadd_v8df_maskz_1 = 2039,
CODE_FOR_fma_fmsubadd_v8df_maskz_1_round = 2040,
CODE_FOR_fma_fmsubadd_v4df_maskz_1 = 2042,
CODE_FOR_fma_fmsubadd_v4df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_fma_fmsubadd_v2df_maskz_1 = 2044,
CODE_FOR_fma_fmsubadd_v2df_maskz_1_round = CODE_FOR_nothing,
CODE_FOR_avx512f_fmsubadd_v16sf_mask = 2045,
CODE_FOR_avx512f_fmsubadd_v16sf_mask_round = 2046,
CODE_FOR_avx512vl_fmsubadd_v8sf_mask = 2047,
CODE_FOR_avx512vl_fmsubadd_v8sf_mask_round = 2048,
CODE_FOR_avx512vl_fmsubadd_v4sf_mask = 2049,
CODE_FOR_avx512vl_fmsubadd_v4sf_mask_round = 2050,
CODE_FOR_avx512f_fmsubadd_v8df_mask = 2051,
CODE_FOR_avx512f_fmsubadd_v8df_mask_round = 2052,
CODE_FOR_avx512vl_fmsubadd_v4df_mask = 2053,
CODE_FOR_avx512vl_fmsubadd_v4df_mask_round = 2054,
CODE_FOR_avx512vl_fmsubadd_v2df_mask = 2055,
CODE_FOR_avx512vl_fmsubadd_v2df_mask_round = 2056,
CODE_FOR_avx512f_fmsubadd_v16sf_mask3 = 2057,
CODE_FOR_avx512f_fmsubadd_v16sf_mask3_round = 2058,
CODE_FOR_avx512vl_fmsubadd_v8sf_mask3 = 2059,
CODE_FOR_avx512vl_fmsubadd_v8sf_mask3_round = 2060,
CODE_FOR_avx512vl_fmsubadd_v4sf_mask3 = 2061,
CODE_FOR_avx512vl_fmsubadd_v4sf_mask3_round = 2062,
CODE_FOR_avx512f_fmsubadd_v8df_mask3 = 2063,
CODE_FOR_avx512f_fmsubadd_v8df_mask3_round = 2064,
CODE_FOR_avx512vl_fmsubadd_v4df_mask3 = 2065,
CODE_FOR_avx512vl_fmsubadd_v4df_mask3_round = 2066,
CODE_FOR_avx512vl_fmsubadd_v2df_mask3 = 2067,
CODE_FOR_avx512vl_fmsubadd_v2df_mask3_round = 2068,
CODE_FOR_sse_cvtpi2ps = 2093,
CODE_FOR_sse_cvtps2pi = 2094,
CODE_FOR_sse_cvttps2pi = 2095,
CODE_FOR_sse_cvtsi2ss = 2096,
CODE_FOR_sse_cvtsi2ss_round = 2097,
CODE_FOR_sse_cvtsi2ssq = 2098,
CODE_FOR_sse_cvtsi2ssq_round = 2099,
CODE_FOR_sse_cvtss2si = 2100,
CODE_FOR_sse_cvtss2si_round = 2101,
CODE_FOR_sse_cvtss2si_2 = 2102,
CODE_FOR_sse_cvtss2siq = 2103,
CODE_FOR_sse_cvtss2siq_round = 2104,
CODE_FOR_sse_cvtss2siq_2 = 2105,
CODE_FOR_sse_cvttss2si = 2106,
CODE_FOR_sse_cvttss2si_round = 2107,
CODE_FOR_sse_cvttss2siq = 2108,
CODE_FOR_sse_cvttss2siq_round = 2109,
CODE_FOR_cvtusi2ss32 = 2110,
CODE_FOR_cvtusi2ss32_round = 2111,
CODE_FOR_cvtusi2sd32 = 2112,
CODE_FOR_cvtusi2sd32_round = CODE_FOR_nothing,
CODE_FOR_cvtusi2ss64 = 2113,
CODE_FOR_cvtusi2ss64_round = 2114,
CODE_FOR_cvtusi2sd64 = 2115,
CODE_FOR_cvtusi2sd64_round = 2116,
CODE_FOR_floatv16siv16sf2 = 2117,
CODE_FOR_floatv16siv16sf2_round = 2118,
CODE_FOR_floatv16siv16sf2_mask = 2119,
CODE_FOR_floatv16siv16sf2_mask_round = 2120,
CODE_FOR_floatv8siv8sf2 = 2121,
CODE_FOR_floatv8siv8sf2_round = CODE_FOR_nothing,
CODE_FOR_floatv8siv8sf2_mask = 2122,
CODE_FOR_floatv8siv8sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_floatv4siv4sf2 = 2123,
CODE_FOR_floatv4siv4sf2_round = CODE_FOR_nothing,
CODE_FOR_floatv4siv4sf2_mask = 2124,
CODE_FOR_floatv4siv4sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufloatv16siv16sf2 = 2125,
CODE_FOR_ufloatv16siv16sf2_round = 2126,
CODE_FOR_ufloatv16siv16sf2_mask = 2127,
CODE_FOR_ufloatv16siv16sf2_mask_round = 2128,
CODE_FOR_ufloatv8siv8sf2 = 2129,
CODE_FOR_ufloatv8siv8sf2_round = 2130,
CODE_FOR_ufloatv8siv8sf2_mask = 2131,
CODE_FOR_ufloatv8siv8sf2_mask_round = 2132,
CODE_FOR_ufloatv4siv4sf2 = 2133,
CODE_FOR_ufloatv4siv4sf2_round = 2134,
CODE_FOR_ufloatv4siv4sf2_mask = 2135,
CODE_FOR_ufloatv4siv4sf2_mask_round = 2136,
CODE_FOR_avx_fix_notruncv8sfv8si = 2137,
CODE_FOR_avx_fix_notruncv8sfv8si_mask = 2138,
CODE_FOR_sse2_fix_notruncv4sfv4si = 2139,
CODE_FOR_sse2_fix_notruncv4sfv4si_mask = 2140,
CODE_FOR_avx512f_fix_notruncv16sfv16si = 2141,
CODE_FOR_avx512f_fix_notruncv16sfv16si_round = 2142,
CODE_FOR_avx512f_fix_notruncv16sfv16si_mask = 2143,
CODE_FOR_avx512f_fix_notruncv16sfv16si_mask_round = 2144,
CODE_FOR_avx512f_ufix_notruncv16sfv16si_mask = 2147,
CODE_FOR_avx512f_ufix_notruncv16sfv16si_mask_round = 2148,
CODE_FOR_avx512vl_ufix_notruncv8sfv8si_mask = 2151,
CODE_FOR_avx512vl_ufix_notruncv8sfv8si_mask_round = 2152,
CODE_FOR_avx512vl_ufix_notruncv4sfv4si_mask = 2155,
CODE_FOR_avx512vl_ufix_notruncv4sfv4si_mask_round = 2156,
CODE_FOR_avx512dq_cvtps2qqv8di_mask = 2159,
CODE_FOR_avx512dq_cvtps2qqv8di_mask_round = 2160,
CODE_FOR_avx512dq_cvtps2qqv4di_mask = 2162,
CODE_FOR_avx512dq_cvtps2qqv4di_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_cvtps2qqv2di_mask = 2164,
CODE_FOR_avx512dq_cvtps2uqqv8di_mask = 2167,
CODE_FOR_avx512dq_cvtps2uqqv8di_mask_round = 2168,
CODE_FOR_avx512dq_cvtps2uqqv4di_mask = 2170,
CODE_FOR_avx512dq_cvtps2uqqv4di_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_cvtps2uqqv2di_mask = 2172,
CODE_FOR_fix_truncv16sfv16si2 = 2173,
CODE_FOR_fix_truncv16sfv16si2_round = 2174,
CODE_FOR_fix_truncv16sfv16si2_mask = 2175,
CODE_FOR_fix_truncv16sfv16si2_mask_round = 2176,
CODE_FOR_ufix_truncv16sfv16si2 = 2177,
CODE_FOR_ufix_truncv16sfv16si2_round = 2178,
CODE_FOR_ufix_truncv16sfv16si2_mask = 2179,
CODE_FOR_ufix_truncv16sfv16si2_mask_round = 2180,
CODE_FOR_fix_truncv8sfv8si2 = 2181,
CODE_FOR_fix_truncv8sfv8si2_mask = 2182,
CODE_FOR_fix_truncv4sfv4si2 = 2183,
CODE_FOR_fix_truncv4sfv4si2_mask = 2184,
CODE_FOR_sse2_cvtpi2pd = 2185,
CODE_FOR_sse2_cvtpd2pi = 2186,
CODE_FOR_sse2_cvttpd2pi = 2187,
CODE_FOR_sse2_cvtsi2sd = 2188,
CODE_FOR_sse2_cvtsi2sdq = 2189,
CODE_FOR_sse2_cvtsi2sdq_round = 2190,
CODE_FOR_avx512f_vcvtss2usi = 2191,
CODE_FOR_avx512f_vcvtss2usi_round = 2192,
CODE_FOR_avx512f_vcvtss2usiq = 2193,
CODE_FOR_avx512f_vcvtss2usiq_round = 2194,
CODE_FOR_avx512f_vcvttss2usi = 2195,
CODE_FOR_avx512f_vcvttss2usi_round = 2196,
CODE_FOR_avx512f_vcvttss2usiq = 2197,
CODE_FOR_avx512f_vcvttss2usiq_round = 2198,
CODE_FOR_avx512f_vcvtsd2usi = 2199,
CODE_FOR_avx512f_vcvtsd2usi_round = 2200,
CODE_FOR_avx512f_vcvtsd2usiq = 2201,
CODE_FOR_avx512f_vcvtsd2usiq_round = 2202,
CODE_FOR_avx512f_vcvttsd2usi = 2203,
CODE_FOR_avx512f_vcvttsd2usi_round = 2204,
CODE_FOR_avx512f_vcvttsd2usiq = 2205,
CODE_FOR_avx512f_vcvttsd2usiq_round = 2206,
CODE_FOR_sse2_cvtsd2si = 2207,
CODE_FOR_sse2_cvtsd2si_round = 2208,
CODE_FOR_sse2_cvtsd2si_2 = 2209,
CODE_FOR_sse2_cvtsd2siq = 2210,
CODE_FOR_sse2_cvtsd2siq_round = 2211,
CODE_FOR_sse2_cvtsd2siq_2 = 2212,
CODE_FOR_sse2_cvttsd2si = 2213,
CODE_FOR_sse2_cvttsd2si_round = 2214,
CODE_FOR_sse2_cvttsd2siq = 2215,
CODE_FOR_sse2_cvttsd2siq_round = 2216,
CODE_FOR_floatv8siv8df2 = 2217,
CODE_FOR_floatv8siv8df2_mask = 2218,
CODE_FOR_floatv4siv4df2 = 2219,
CODE_FOR_floatv4siv4df2_mask = 2220,
CODE_FOR_floatv8div8df2 = 2221,
CODE_FOR_floatv8div8df2_round = 2222,
CODE_FOR_floatv8div8df2_mask = 2223,
CODE_FOR_floatv8div8df2_mask_round = 2224,
CODE_FOR_ufloatv8div8df2 = 2225,
CODE_FOR_ufloatv8div8df2_round = 2226,
CODE_FOR_ufloatv8div8df2_mask = 2227,
CODE_FOR_ufloatv8div8df2_mask_round = 2228,
CODE_FOR_floatv4div4df2 = 2229,
CODE_FOR_floatv4div4df2_round = 2230,
CODE_FOR_floatv4div4df2_mask = 2231,
CODE_FOR_floatv4div4df2_mask_round = 2232,
CODE_FOR_ufloatv4div4df2 = 2233,
CODE_FOR_ufloatv4div4df2_round = 2234,
CODE_FOR_ufloatv4div4df2_mask = 2235,
CODE_FOR_ufloatv4div4df2_mask_round = 2236,
CODE_FOR_floatv2div2df2 = 2237,
CODE_FOR_floatv2div2df2_round = 2238,
CODE_FOR_floatv2div2df2_mask = 2239,
CODE_FOR_floatv2div2df2_mask_round = 2240,
CODE_FOR_ufloatv2div2df2 = 2241,
CODE_FOR_ufloatv2div2df2_round = 2242,
CODE_FOR_ufloatv2div2df2_mask = 2243,
CODE_FOR_ufloatv2div2df2_mask_round = 2244,
CODE_FOR_floatv8div8sf2 = 2245,
CODE_FOR_floatv8div8sf2_round = 2246,
CODE_FOR_floatv8div8sf2_mask = 2247,
CODE_FOR_floatv8div8sf2_mask_round = 2248,
CODE_FOR_ufloatv8div8sf2 = 2249,
CODE_FOR_ufloatv8div8sf2_round = 2250,
CODE_FOR_ufloatv8div8sf2_mask = 2251,
CODE_FOR_ufloatv8div8sf2_mask_round = 2252,
CODE_FOR_floatv4div4sf2 = 2253,
CODE_FOR_floatv4div4sf2_round = CODE_FOR_nothing,
CODE_FOR_floatv4div4sf2_mask = 2254,
CODE_FOR_floatv4div4sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufloatv4div4sf2 = 2255,
CODE_FOR_ufloatv4div4sf2_round = CODE_FOR_nothing,
CODE_FOR_ufloatv4div4sf2_mask = 2256,
CODE_FOR_ufloatv4div4sf2_mask_round = CODE_FOR_nothing,
CODE_FOR_floatv2div2sf2_mask = 2259,
CODE_FOR_ufloatv2div2sf2_mask = 2260,
CODE_FOR_ufloatv8siv8df2 = 2263,
CODE_FOR_ufloatv8siv8df2_mask = 2264,
CODE_FOR_ufloatv4siv4df2 = 2265,
CODE_FOR_ufloatv4siv4df2_mask = 2266,
CODE_FOR_ufloatv2siv2df2 = 2267,
CODE_FOR_ufloatv2siv2df2_mask = 2268,
CODE_FOR_avx512f_cvtdq2pd512_2 = 2269,
CODE_FOR_avx_cvtdq2pd256_2 = 2270,
CODE_FOR_sse2_cvtdq2pd = 2271,
CODE_FOR_sse2_cvtdq2pd_mask = 2272,
CODE_FOR_avx512f_cvtpd2dq512 = 2273,
CODE_FOR_avx512f_cvtpd2dq512_round = 2274,
CODE_FOR_avx512f_cvtpd2dq512_mask = 2275,
CODE_FOR_avx512f_cvtpd2dq512_mask_round = 2276,
CODE_FOR_avx_cvtpd2dq256 = 2277,
CODE_FOR_avx_cvtpd2dq256_mask = 2278,
CODE_FOR_sse2_cvtpd2dq = 2280,
CODE_FOR_sse2_cvtpd2dq_mask = 2281,
CODE_FOR_ufix_notruncv8dfv8si2 = 2282,
CODE_FOR_ufix_notruncv8dfv8si2_round = 2283,
CODE_FOR_ufix_notruncv8dfv8si2_mask = 2284,
CODE_FOR_ufix_notruncv8dfv8si2_mask_round = 2285,
CODE_FOR_ufix_notruncv4dfv4si2 = 2286,
CODE_FOR_ufix_notruncv4dfv4si2_round = 2287,
CODE_FOR_ufix_notruncv4dfv4si2_mask = 2288,
CODE_FOR_ufix_notruncv4dfv4si2_mask_round = 2289,
CODE_FOR_ufix_notruncv2dfv2si2 = 2290,
CODE_FOR_ufix_notruncv2dfv2si2_mask = 2291,
CODE_FOR_fix_truncv8dfv8si2 = 2292,
CODE_FOR_fix_truncv8dfv8si2_round = 2293,
CODE_FOR_fix_truncv8dfv8si2_mask = 2294,
CODE_FOR_fix_truncv8dfv8si2_mask_round = 2295,
CODE_FOR_ufix_truncv8dfv8si2 = 2296,
CODE_FOR_ufix_truncv8dfv8si2_round = 2297,
CODE_FOR_ufix_truncv8dfv8si2_mask = 2298,
CODE_FOR_ufix_truncv8dfv8si2_mask_round = 2299,
CODE_FOR_ufix_truncv2dfv2si2 = 2300,
CODE_FOR_ufix_truncv2dfv2si2_mask = 2301,
CODE_FOR_fix_truncv4dfv4si2 = 2302,
CODE_FOR_fix_truncv4dfv4si2_mask = 2303,
CODE_FOR_ufix_truncv4dfv4si2 = 2304,
CODE_FOR_ufix_truncv4dfv4si2_mask = 2305,
CODE_FOR_fix_truncv8dfv8di2 = 2306,
CODE_FOR_fix_truncv8dfv8di2_round = 2307,
CODE_FOR_fix_truncv8dfv8di2_mask = 2308,
CODE_FOR_fix_truncv8dfv8di2_mask_round = 2309,
CODE_FOR_ufix_truncv8dfv8di2 = 2310,
CODE_FOR_ufix_truncv8dfv8di2_round = 2311,
CODE_FOR_ufix_truncv8dfv8di2_mask = 2312,
CODE_FOR_ufix_truncv8dfv8di2_mask_round = 2313,
CODE_FOR_fix_truncv4dfv4di2 = 2314,
CODE_FOR_fix_truncv4dfv4di2_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv4dfv4di2_mask = 2315,
CODE_FOR_fix_truncv4dfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufix_truncv4dfv4di2 = 2316,
CODE_FOR_ufix_truncv4dfv4di2_round = CODE_FOR_nothing,
CODE_FOR_ufix_truncv4dfv4di2_mask = 2317,
CODE_FOR_ufix_truncv4dfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv2dfv2di2 = 2318,
CODE_FOR_fix_truncv2dfv2di2_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv2dfv2di2_mask = 2319,
CODE_FOR_fix_truncv2dfv2di2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufix_truncv2dfv2di2 = 2320,
CODE_FOR_ufix_truncv2dfv2di2_round = CODE_FOR_nothing,
CODE_FOR_ufix_truncv2dfv2di2_mask = 2321,
CODE_FOR_ufix_truncv2dfv2di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fix_notruncv8dfv8di2 = 2322,
CODE_FOR_fix_notruncv8dfv8di2_round = 2323,
CODE_FOR_fix_notruncv8dfv8di2_mask = 2324,
CODE_FOR_fix_notruncv8dfv8di2_mask_round = 2325,
CODE_FOR_fix_notruncv4dfv4di2 = 2326,
CODE_FOR_fix_notruncv4dfv4di2_round = CODE_FOR_nothing,
CODE_FOR_fix_notruncv4dfv4di2_mask = 2327,
CODE_FOR_fix_notruncv4dfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fix_notruncv2dfv2di2 = 2328,
CODE_FOR_fix_notruncv2dfv2di2_round = CODE_FOR_nothing,
CODE_FOR_fix_notruncv2dfv2di2_mask = 2329,
CODE_FOR_fix_notruncv2dfv2di2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufix_notruncv8dfv8di2 = 2330,
CODE_FOR_ufix_notruncv8dfv8di2_round = 2331,
CODE_FOR_ufix_notruncv8dfv8di2_mask = 2332,
CODE_FOR_ufix_notruncv8dfv8di2_mask_round = 2333,
CODE_FOR_ufix_notruncv4dfv4di2 = 2334,
CODE_FOR_ufix_notruncv4dfv4di2_round = CODE_FOR_nothing,
CODE_FOR_ufix_notruncv4dfv4di2_mask = 2335,
CODE_FOR_ufix_notruncv4dfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufix_notruncv2dfv2di2 = 2336,
CODE_FOR_ufix_notruncv2dfv2di2_round = CODE_FOR_nothing,
CODE_FOR_ufix_notruncv2dfv2di2_mask = 2337,
CODE_FOR_ufix_notruncv2dfv2di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv8sfv8di2 = 2338,
CODE_FOR_fix_truncv8sfv8di2_round = 2339,
CODE_FOR_fix_truncv8sfv8di2_mask = 2340,
CODE_FOR_fix_truncv8sfv8di2_mask_round = 2341,
CODE_FOR_ufix_truncv8sfv8di2 = 2342,
CODE_FOR_ufix_truncv8sfv8di2_round = 2343,
CODE_FOR_ufix_truncv8sfv8di2_mask = 2344,
CODE_FOR_ufix_truncv8sfv8di2_mask_round = 2345,
CODE_FOR_fix_truncv4sfv4di2 = 2346,
CODE_FOR_fix_truncv4sfv4di2_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv4sfv4di2_mask = 2347,
CODE_FOR_fix_truncv4sfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_ufix_truncv4sfv4di2 = 2348,
CODE_FOR_ufix_truncv4sfv4di2_round = CODE_FOR_nothing,
CODE_FOR_ufix_truncv4sfv4di2_mask = 2349,
CODE_FOR_ufix_truncv4sfv4di2_mask_round = CODE_FOR_nothing,
CODE_FOR_fix_truncv2sfv2di2 = 2350,
CODE_FOR_fix_truncv2sfv2di2_mask = 2351,
CODE_FOR_ufix_truncv2sfv2di2 = 2352,
CODE_FOR_ufix_truncv2sfv2di2_mask = 2353,
CODE_FOR_ufix_truncv8sfv8si2 = 2354,
CODE_FOR_ufix_truncv8sfv8si2_mask = 2355,
CODE_FOR_ufix_truncv4sfv4si2 = 2356,
CODE_FOR_ufix_truncv4sfv4si2_mask = 2357,
CODE_FOR_sse2_cvttpd2dq = 2358,
CODE_FOR_sse2_cvttpd2dq_mask = 2359,
CODE_FOR_sse2_cvtsd2ss = 2360,
CODE_FOR_sse2_cvtsd2ss_round = 2361,
CODE_FOR_sse2_cvtss2sd = 2363,
CODE_FOR_sse2_cvtss2sd_round = 2364,
CODE_FOR_avx512f_cvtpd2ps512_mask = 2368,
CODE_FOR_avx512f_cvtpd2ps512_mask_round = 2369,
CODE_FOR_avx_cvtpd2ps256 = 2370,
CODE_FOR_avx_cvtpd2ps256_mask = 2371,
CODE_FOR_avx512f_cvtps2pd512 = 2374,
CODE_FOR_avx512f_cvtps2pd512_round = 2375,
CODE_FOR_avx512f_cvtps2pd512_mask = 2376,
CODE_FOR_avx512f_cvtps2pd512_mask_round = 2377,
CODE_FOR_avx_cvtps2pd256 = 2378,
CODE_FOR_avx_cvtps2pd256_round = CODE_FOR_nothing,
CODE_FOR_avx_cvtps2pd256_mask = 2379,
CODE_FOR_avx_cvtps2pd256_mask_round = CODE_FOR_nothing,
CODE_FOR_vec_unpacks_lo_v16sf = 2381,
CODE_FOR_avx512bw_cvtb2maskv64qi = 2382,
CODE_FOR_avx512vl_cvtb2maskv16qi = 2383,
CODE_FOR_avx512vl_cvtb2maskv32qi = 2384,
CODE_FOR_avx512bw_cvtw2maskv32hi = 2385,
CODE_FOR_avx512vl_cvtw2maskv16hi = 2386,
CODE_FOR_avx512vl_cvtw2maskv8hi = 2387,
CODE_FOR_avx512f_cvtd2maskv16si = 2388,
CODE_FOR_avx512vl_cvtd2maskv8si = 2389,
CODE_FOR_avx512vl_cvtd2maskv4si = 2390,
CODE_FOR_avx512f_cvtq2maskv8di = 2391,
CODE_FOR_avx512vl_cvtq2maskv4di = 2392,
CODE_FOR_avx512vl_cvtq2maskv2di = 2393,
CODE_FOR_sse2_cvtps2pd = 2406,
CODE_FOR_sse2_cvtps2pd_mask = 2407,
CODE_FOR_sse_movhlps = 2408,
CODE_FOR_sse_movlhps = 2409,
CODE_FOR_avx512f_unpckhps512_mask = 2411,
CODE_FOR_avx_unpckhps256 = 2412,
CODE_FOR_avx_unpckhps256_mask = 2413,
CODE_FOR_vec_interleave_highv4sf = 2414,
CODE_FOR_vec_interleave_highv4sf_mask = 2415,
CODE_FOR_avx512f_unpcklps512_mask = 2417,
CODE_FOR_avx_unpcklps256 = 2418,
CODE_FOR_avx_unpcklps256_mask = 2419,
CODE_FOR_unpcklps128_mask = 2420,
CODE_FOR_vec_interleave_lowv4sf = 2421,
CODE_FOR_avx_movshdup256 = 2422,
CODE_FOR_avx_movshdup256_mask = 2423,
CODE_FOR_sse3_movshdup = 2424,
CODE_FOR_sse3_movshdup_mask = 2425,
CODE_FOR_avx512f_movshdup512_mask = 2427,
CODE_FOR_avx_movsldup256 = 2428,
CODE_FOR_avx_movsldup256_mask = 2429,
CODE_FOR_sse3_movsldup = 2430,
CODE_FOR_sse3_movsldup_mask = 2431,
CODE_FOR_avx512f_movsldup512_mask = 2433,
CODE_FOR_avx_shufps256_1 = 2434,
CODE_FOR_avx_shufps256_1_mask = 2435,
CODE_FOR_sse_shufps_v4sf_mask = 2436,
CODE_FOR_sse_shufps_v4si = 2437,
CODE_FOR_sse_shufps_v4sf = 2438,
CODE_FOR_sse_storehps = 2439,
CODE_FOR_sse_loadhps = 2440,
CODE_FOR_sse_storelps = 2441,
CODE_FOR_sse_loadlps = 2442,
CODE_FOR_sse_movss = 2443,
CODE_FOR_avx2_vec_dupv8sf = 2444,
CODE_FOR_avx2_vec_dupv4sf = 2445,
CODE_FOR_avx2_vec_dupv8sf_1 = 2446,
CODE_FOR_avx512f_vec_dupv16sf_1 = 2447,
CODE_FOR_avx512f_vec_dupv8df_1 = 2448,
CODE_FOR_vec_setv4si_0 = 2452,
CODE_FOR_vec_setv4sf_0 = 2453,
CODE_FOR_sse4_1_insertps = 2455,
CODE_FOR_avx512dq_vextractf64x2_1_maskm = 2459,
CODE_FOR_avx512dq_vextracti64x2_1_maskm = 2460,
CODE_FOR_avx512f_vextractf32x4_1_maskm = 2461,
CODE_FOR_avx512f_vextracti32x4_1_maskm = 2462,
CODE_FOR_avx512dq_vextractf64x2_1_mask = 2464,
CODE_FOR_avx512dq_vextracti64x2_1_mask = 2466,
CODE_FOR_avx512f_vextractf32x4_1_mask = 2468,
CODE_FOR_avx512f_vextracti32x4_1_mask = 2470,
CODE_FOR_vec_extract_lo_v8df_maskm = 2471,
CODE_FOR_vec_extract_lo_v8di_maskm = 2472,
CODE_FOR_vec_extract_lo_v8df = 2473,
CODE_FOR_vec_extract_lo_v8df_mask = 2474,
CODE_FOR_vec_extract_lo_v8di = 2475,
CODE_FOR_vec_extract_lo_v8di_mask = 2476,
CODE_FOR_vec_extract_hi_v8df_maskm = 2477,
CODE_FOR_vec_extract_hi_v8di_maskm = 2478,
CODE_FOR_vec_extract_hi_v8df = 2479,
CODE_FOR_vec_extract_hi_v8df_mask = 2480,
CODE_FOR_vec_extract_hi_v8di = 2481,
CODE_FOR_vec_extract_hi_v8di_mask = 2482,
CODE_FOR_vec_extract_hi_v16sf_maskm = 2483,
CODE_FOR_vec_extract_hi_v16si_maskm = 2484,
CODE_FOR_vec_extract_hi_v16sf = 2485,
CODE_FOR_vec_extract_hi_v16sf_mask = 2486,
CODE_FOR_vec_extract_hi_v16si = 2487,
CODE_FOR_vec_extract_hi_v16si_mask = 2488,
CODE_FOR_vec_extract_lo_v16sf = 2489,
CODE_FOR_vec_extract_lo_v16sf_mask = 2490,
CODE_FOR_vec_extract_lo_v16si = 2491,
CODE_FOR_vec_extract_lo_v16si_mask = 2492,
CODE_FOR_vec_extract_lo_v4di = 2493,
CODE_FOR_vec_extract_lo_v4di_mask = 2494,
CODE_FOR_vec_extract_lo_v4df = 2495,
CODE_FOR_vec_extract_lo_v4df_mask = 2496,
CODE_FOR_vec_extract_hi_v4di = 2497,
CODE_FOR_vec_extract_hi_v4di_mask = 2498,
CODE_FOR_vec_extract_hi_v4df = 2499,
CODE_FOR_vec_extract_hi_v4df_mask = 2500,
CODE_FOR_vec_extract_lo_v8si = 2501,
CODE_FOR_vec_extract_lo_v8si_mask = 2502,
CODE_FOR_vec_extract_lo_v8sf = 2503,
CODE_FOR_vec_extract_lo_v8sf_mask = 2504,
CODE_FOR_vec_extract_lo_v8si_maskm = 2505,
CODE_FOR_vec_extract_lo_v8sf_maskm = 2506,
CODE_FOR_vec_extract_hi_v8si_maskm = 2507,
CODE_FOR_vec_extract_hi_v8sf_maskm = 2508,
CODE_FOR_vec_extract_hi_v8si_mask = 2509,
CODE_FOR_vec_extract_hi_v8sf_mask = 2510,
CODE_FOR_vec_extract_hi_v8si = 2511,
CODE_FOR_vec_extract_hi_v8sf = 2512,
CODE_FOR_vec_extract_lo_v32hi = 2513,
CODE_FOR_vec_extract_hi_v32hi = 2514,
CODE_FOR_vec_extract_lo_v16hi = 2515,
CODE_FOR_vec_extract_hi_v16hi = 2516,
CODE_FOR_vec_extract_lo_v64qi = 2517,
CODE_FOR_vec_extract_hi_v64qi = 2518,
CODE_FOR_vec_extract_lo_v32qi = 2519,
CODE_FOR_vec_extract_hi_v32qi = 2520,
CODE_FOR_avx512f_unpckhpd512_mask = 2522,
CODE_FOR_avx_unpckhpd256 = 2523,
CODE_FOR_avx_unpckhpd256_mask = 2524,
CODE_FOR_avx512vl_unpckhpd128_mask = 2525,
CODE_FOR_avx512vl_unpcklpd128_mask = 2531,
CODE_FOR_avx512f_vmscalefv4sf = 2533,
CODE_FOR_avx512f_vmscalefv4sf_round = 2534,
CODE_FOR_avx512f_vmscalefv2df = 2535,
CODE_FOR_avx512f_vmscalefv2df_round = 2536,
CODE_FOR_avx512f_scalefv16sf = 2537,
CODE_FOR_avx512f_scalefv16sf_round = 2538,
CODE_FOR_avx512f_scalefv16sf_mask = 2539,
CODE_FOR_avx512f_scalefv16sf_mask_round = 2540,
CODE_FOR_avx512vl_scalefv8sf = 2541,
CODE_FOR_avx512vl_scalefv8sf_round = 2542,
CODE_FOR_avx512vl_scalefv8sf_mask = 2543,
CODE_FOR_avx512vl_scalefv8sf_mask_round = 2544,
CODE_FOR_avx512vl_scalefv4sf = 2545,
CODE_FOR_avx512vl_scalefv4sf_round = 2546,
CODE_FOR_avx512vl_scalefv4sf_mask = 2547,
CODE_FOR_avx512vl_scalefv4sf_mask_round = 2548,
CODE_FOR_avx512f_scalefv8df = 2549,
CODE_FOR_avx512f_scalefv8df_round = 2550,
CODE_FOR_avx512f_scalefv8df_mask = 2551,
CODE_FOR_avx512f_scalefv8df_mask_round = 2552,
CODE_FOR_avx512vl_scalefv4df = 2553,
CODE_FOR_avx512vl_scalefv4df_round = 2554,
CODE_FOR_avx512vl_scalefv4df_mask = 2555,
CODE_FOR_avx512vl_scalefv4df_mask_round = 2556,
CODE_FOR_avx512vl_scalefv2df = 2557,
CODE_FOR_avx512vl_scalefv2df_round = 2558,
CODE_FOR_avx512vl_scalefv2df_mask = 2559,
CODE_FOR_avx512vl_scalefv2df_mask_round = 2560,
CODE_FOR_avx512f_vternlogv16si = 2561,
CODE_FOR_avx512f_vternlogv16si_maskz_1 = 2562,
CODE_FOR_avx512vl_vternlogv8si = 2563,
CODE_FOR_avx512vl_vternlogv8si_maskz_1 = 2564,
CODE_FOR_avx512vl_vternlogv4si = 2565,
CODE_FOR_avx512vl_vternlogv4si_maskz_1 = 2566,
CODE_FOR_avx512f_vternlogv8di = 2567,
CODE_FOR_avx512f_vternlogv8di_maskz_1 = 2568,
CODE_FOR_avx512vl_vternlogv4di = 2569,
CODE_FOR_avx512vl_vternlogv4di_maskz_1 = 2570,
CODE_FOR_avx512vl_vternlogv2di = 2571,
CODE_FOR_avx512vl_vternlogv2di_maskz_1 = 2572,
CODE_FOR_avx512f_vternlogv16si_mask = 2573,
CODE_FOR_avx512vl_vternlogv8si_mask = 2574,
CODE_FOR_avx512vl_vternlogv4si_mask = 2575,
CODE_FOR_avx512f_vternlogv8di_mask = 2576,
CODE_FOR_avx512vl_vternlogv4di_mask = 2577,
CODE_FOR_avx512vl_vternlogv2di_mask = 2578,
CODE_FOR_avx512f_getexpv16sf = 2579,
CODE_FOR_avx512f_getexpv16sf_round = 2580,
CODE_FOR_avx512f_getexpv16sf_mask = 2581,
CODE_FOR_avx512f_getexpv16sf_mask_round = 2582,
CODE_FOR_avx512vl_getexpv8sf = 2583,
CODE_FOR_avx512vl_getexpv8sf_round = 2584,
CODE_FOR_avx512vl_getexpv8sf_mask = 2585,
CODE_FOR_avx512vl_getexpv8sf_mask_round = 2586,
CODE_FOR_avx512vl_getexpv4sf = 2587,
CODE_FOR_avx512vl_getexpv4sf_round = 2588,
CODE_FOR_avx512vl_getexpv4sf_mask = 2589,
CODE_FOR_avx512vl_getexpv4sf_mask_round = 2590,
CODE_FOR_avx512f_getexpv8df = 2591,
CODE_FOR_avx512f_getexpv8df_round = 2592,
CODE_FOR_avx512f_getexpv8df_mask = 2593,
CODE_FOR_avx512f_getexpv8df_mask_round = 2594,
CODE_FOR_avx512vl_getexpv4df = 2595,
CODE_FOR_avx512vl_getexpv4df_round = 2596,
CODE_FOR_avx512vl_getexpv4df_mask = 2597,
CODE_FOR_avx512vl_getexpv4df_mask_round = 2598,
CODE_FOR_avx512vl_getexpv2df = 2599,
CODE_FOR_avx512vl_getexpv2df_round = 2600,
CODE_FOR_avx512vl_getexpv2df_mask = 2601,
CODE_FOR_avx512vl_getexpv2df_mask_round = 2602,
CODE_FOR_avx512f_sgetexpv4sf = 2603,
CODE_FOR_avx512f_sgetexpv4sf_round = 2604,
CODE_FOR_avx512f_sgetexpv2df = 2605,
CODE_FOR_avx512f_sgetexpv2df_round = 2606,
CODE_FOR_avx512f_alignv16si_mask = 2608,
CODE_FOR_avx512vl_alignv8si_mask = 2610,
CODE_FOR_avx512vl_alignv4si_mask = 2612,
CODE_FOR_avx512f_alignv8di_mask = 2614,
CODE_FOR_avx512vl_alignv4di_mask = 2616,
CODE_FOR_avx512vl_alignv2di_mask = 2618,
CODE_FOR_avx512f_fixupimmv16sf = 2619,
CODE_FOR_avx512f_fixupimmv16sf_round = 2620,
CODE_FOR_avx512f_fixupimmv16sf_maskz_1 = 2621,
CODE_FOR_avx512f_fixupimmv16sf_maskz_1_round = 2622,
CODE_FOR_avx512vl_fixupimmv8sf = 2623,
CODE_FOR_avx512vl_fixupimmv8sf_round = 2624,
CODE_FOR_avx512vl_fixupimmv8sf_maskz_1 = 2625,
CODE_FOR_avx512vl_fixupimmv8sf_maskz_1_round = 2626,
CODE_FOR_avx512vl_fixupimmv4sf = 2627,
CODE_FOR_avx512vl_fixupimmv4sf_round = 2628,
CODE_FOR_avx512vl_fixupimmv4sf_maskz_1 = 2629,
CODE_FOR_avx512vl_fixupimmv4sf_maskz_1_round = 2630,
CODE_FOR_avx512f_fixupimmv8df = 2631,
CODE_FOR_avx512f_fixupimmv8df_round = 2632,
CODE_FOR_avx512f_fixupimmv8df_maskz_1 = 2633,
CODE_FOR_avx512f_fixupimmv8df_maskz_1_round = 2634,
CODE_FOR_avx512vl_fixupimmv4df = 2635,
CODE_FOR_avx512vl_fixupimmv4df_round = 2636,
CODE_FOR_avx512vl_fixupimmv4df_maskz_1 = 2637,
CODE_FOR_avx512vl_fixupimmv4df_maskz_1_round = 2638,
CODE_FOR_avx512vl_fixupimmv2df = 2639,
CODE_FOR_avx512vl_fixupimmv2df_round = 2640,
CODE_FOR_avx512vl_fixupimmv2df_maskz_1 = 2641,
CODE_FOR_avx512vl_fixupimmv2df_maskz_1_round = 2642,
CODE_FOR_avx512f_fixupimmv16sf_mask = 2643,
CODE_FOR_avx512f_fixupimmv16sf_mask_round = 2644,
CODE_FOR_avx512vl_fixupimmv8sf_mask = 2645,
CODE_FOR_avx512vl_fixupimmv8sf_mask_round = 2646,
CODE_FOR_avx512vl_fixupimmv4sf_mask = 2647,
CODE_FOR_avx512vl_fixupimmv4sf_mask_round = 2648,
CODE_FOR_avx512f_fixupimmv8df_mask = 2649,
CODE_FOR_avx512f_fixupimmv8df_mask_round = 2650,
CODE_FOR_avx512vl_fixupimmv4df_mask = 2651,
CODE_FOR_avx512vl_fixupimmv4df_mask_round = 2652,
CODE_FOR_avx512vl_fixupimmv2df_mask = 2653,
CODE_FOR_avx512vl_fixupimmv2df_mask_round = 2654,
CODE_FOR_avx512f_sfixupimmv4sf = 2655,
CODE_FOR_avx512f_sfixupimmv4sf_round = 2656,
CODE_FOR_avx512f_sfixupimmv4sf_maskz_1 = 2657,
CODE_FOR_avx512f_sfixupimmv4sf_maskz_1_round = 2658,
CODE_FOR_avx512f_sfixupimmv2df = 2659,
CODE_FOR_avx512f_sfixupimmv2df_round = 2660,
CODE_FOR_avx512f_sfixupimmv2df_maskz_1 = 2661,
CODE_FOR_avx512f_sfixupimmv2df_maskz_1_round = 2662,
CODE_FOR_avx512f_sfixupimmv4sf_mask = 2663,
CODE_FOR_avx512f_sfixupimmv4sf_mask_round = 2664,
CODE_FOR_avx512f_sfixupimmv2df_mask = 2665,
CODE_FOR_avx512f_sfixupimmv2df_mask_round = 2666,
CODE_FOR_avx512f_rndscalev16sf = 2667,
CODE_FOR_avx512f_rndscalev16sf_round = 2668,
CODE_FOR_avx512f_rndscalev16sf_mask = 2669,
CODE_FOR_avx512f_rndscalev16sf_mask_round = 2670,
CODE_FOR_avx512vl_rndscalev8sf = 2671,
CODE_FOR_avx512vl_rndscalev8sf_round = 2672,
CODE_FOR_avx512vl_rndscalev8sf_mask = 2673,
CODE_FOR_avx512vl_rndscalev8sf_mask_round = 2674,
CODE_FOR_avx512vl_rndscalev4sf = 2675,
CODE_FOR_avx512vl_rndscalev4sf_round = 2676,
CODE_FOR_avx512vl_rndscalev4sf_mask = 2677,
CODE_FOR_avx512vl_rndscalev4sf_mask_round = 2678,
CODE_FOR_avx512f_rndscalev8df = 2679,
CODE_FOR_avx512f_rndscalev8df_round = 2680,
CODE_FOR_avx512f_rndscalev8df_mask = 2681,
CODE_FOR_avx512f_rndscalev8df_mask_round = 2682,
CODE_FOR_avx512vl_rndscalev4df = 2683,
CODE_FOR_avx512vl_rndscalev4df_round = 2684,
CODE_FOR_avx512vl_rndscalev4df_mask = 2685,
CODE_FOR_avx512vl_rndscalev4df_mask_round = 2686,
CODE_FOR_avx512vl_rndscalev2df = 2687,
CODE_FOR_avx512vl_rndscalev2df_round = 2688,
CODE_FOR_avx512vl_rndscalev2df_mask = 2689,
CODE_FOR_avx512vl_rndscalev2df_mask_round = 2690,
CODE_FOR_avx512f_rndscalev4sf = 2691,
CODE_FOR_avx512f_rndscalev4sf_round = 2692,
CODE_FOR_avx512f_rndscalev2df = 2693,
CODE_FOR_avx512f_rndscalev2df_round = 2694,
CODE_FOR_avx512f_shufps512_1 = 2695,
CODE_FOR_avx512f_shufps512_1_mask = 2696,
CODE_FOR_avx512f_shufpd512_1 = 2697,
CODE_FOR_avx512f_shufpd512_1_mask = 2698,
CODE_FOR_avx_shufpd256_1 = 2699,
CODE_FOR_avx_shufpd256_1_mask = 2700,
CODE_FOR_sse2_shufpd_v2df_mask = 2701,
CODE_FOR_avx2_interleave_highv4di = 2702,
CODE_FOR_avx2_interleave_highv4di_mask = 2703,
CODE_FOR_avx512f_interleave_highv8di_mask = 2705,
CODE_FOR_vec_interleave_highv2di = 2706,
CODE_FOR_vec_interleave_highv2di_mask = 2707,
CODE_FOR_avx2_interleave_lowv4di = 2708,
CODE_FOR_avx2_interleave_lowv4di_mask = 2709,
CODE_FOR_avx512f_interleave_lowv8di_mask = 2711,
CODE_FOR_vec_interleave_lowv2di = 2712,
CODE_FOR_vec_interleave_lowv2di_mask = 2713,
CODE_FOR_sse2_shufpd_v2di = 2714,
CODE_FOR_sse2_shufpd_v2df = 2715,
CODE_FOR_sse2_storehpd = 2716,
CODE_FOR_sse2_storelpd = 2718,
CODE_FOR_sse2_loadhpd = 2720,
CODE_FOR_sse2_loadlpd = 2721,
CODE_FOR_sse2_movsd = 2722,
CODE_FOR_vec_dupv2df = 2723,
CODE_FOR_vec_dupv2df_mask = 2724,
CODE_FOR_vec_concatv2df = 2725,
CODE_FOR_avx512f_ss_truncatev16siv16qi2_mask = 2738,
CODE_FOR_avx512f_truncatev16siv16qi2_mask = 2739,
CODE_FOR_avx512f_us_truncatev16siv16qi2_mask = 2740,
CODE_FOR_avx512f_ss_truncatev16siv16hi2_mask = 2741,
CODE_FOR_avx512f_truncatev16siv16hi2_mask = 2742,
CODE_FOR_avx512f_us_truncatev16siv16hi2_mask = 2743,
CODE_FOR_avx512f_ss_truncatev8div8si2_mask = 2744,
CODE_FOR_avx512f_truncatev8div8si2_mask = 2745,
CODE_FOR_avx512f_us_truncatev8div8si2_mask = 2746,
CODE_FOR_avx512f_ss_truncatev8div8hi2_mask = 2747,
CODE_FOR_avx512f_truncatev8div8hi2_mask = 2748,
CODE_FOR_avx512f_us_truncatev8div8hi2_mask = 2749,
CODE_FOR_avx512bw_ss_truncatev32hiv32qi2 = 2750,
CODE_FOR_avx512bw_truncatev32hiv32qi2 = 2751,
CODE_FOR_avx512bw_us_truncatev32hiv32qi2 = 2752,
CODE_FOR_avx512bw_ss_truncatev32hiv32qi2_mask = 2753,
CODE_FOR_avx512bw_truncatev32hiv32qi2_mask = 2754,
CODE_FOR_avx512bw_us_truncatev32hiv32qi2_mask = 2755,
CODE_FOR_avx512vl_ss_truncatev4div4si2_mask = 2765,
CODE_FOR_avx512vl_truncatev4div4si2_mask = 2766,
CODE_FOR_avx512vl_us_truncatev4div4si2_mask = 2767,
CODE_FOR_avx512vl_ss_truncatev8siv8hi2_mask = 2768,
CODE_FOR_avx512vl_truncatev8siv8hi2_mask = 2769,
CODE_FOR_avx512vl_us_truncatev8siv8hi2_mask = 2770,
CODE_FOR_avx512vl_ss_truncatev16hiv16qi2_mask = 2771,
CODE_FOR_avx512vl_truncatev16hiv16qi2_mask = 2772,
CODE_FOR_avx512vl_us_truncatev16hiv16qi2_mask = 2773,
CODE_FOR_avx512vl_ss_truncatev2div2qi2_mask = 2792,
CODE_FOR_avx512vl_truncatev2div2qi2_mask = 2793,
CODE_FOR_avx512vl_us_truncatev2div2qi2_mask = 2794,
CODE_FOR_avx512vl_ss_truncatev2div2qi2_mask_store = 2798,
CODE_FOR_avx512vl_truncatev2div2qi2_mask_store = 2799,
CODE_FOR_avx512vl_us_truncatev2div2qi2_mask_store = 2800,
CODE_FOR_avx512vl_ss_truncatev4siv4qi2_mask = 2807,
CODE_FOR_avx512vl_truncatev4siv4qi2_mask = 2808,
CODE_FOR_avx512vl_us_truncatev4siv4qi2_mask = 2809,
CODE_FOR_avx512vl_ss_truncatev4div4qi2_mask = 2810,
CODE_FOR_avx512vl_truncatev4div4qi2_mask = 2811,
CODE_FOR_avx512vl_us_truncatev4div4qi2_mask = 2812,
CODE_FOR_avx512vl_ss_truncatev4siv4qi2_mask_store = 2819,
CODE_FOR_avx512vl_truncatev4siv4qi2_mask_store = 2820,
CODE_FOR_avx512vl_us_truncatev4siv4qi2_mask_store = 2821,
CODE_FOR_avx512vl_ss_truncatev4div4qi2_mask_store = 2822,
CODE_FOR_avx512vl_truncatev4div4qi2_mask_store = 2823,
CODE_FOR_avx512vl_us_truncatev4div4qi2_mask_store = 2824,
CODE_FOR_avx512vl_ss_truncatev8hiv8qi2_mask = 2831,
CODE_FOR_avx512vl_truncatev8hiv8qi2_mask = 2832,
CODE_FOR_avx512vl_us_truncatev8hiv8qi2_mask = 2833,
CODE_FOR_avx512vl_ss_truncatev8siv8qi2_mask = 2834,
CODE_FOR_avx512vl_truncatev8siv8qi2_mask = 2835,
CODE_FOR_avx512vl_us_truncatev8siv8qi2_mask = 2836,
CODE_FOR_avx512vl_ss_truncatev8hiv8qi2_mask_store = 2843,
CODE_FOR_avx512vl_truncatev8hiv8qi2_mask_store = 2844,
CODE_FOR_avx512vl_us_truncatev8hiv8qi2_mask_store = 2845,
CODE_FOR_avx512vl_ss_truncatev8siv8qi2_mask_store = 2846,
CODE_FOR_avx512vl_truncatev8siv8qi2_mask_store = 2847,
CODE_FOR_avx512vl_us_truncatev8siv8qi2_mask_store = 2848,
CODE_FOR_avx512vl_ss_truncatev4siv4hi2_mask = 2864,
CODE_FOR_avx512vl_truncatev4siv4hi2_mask = 2865,
CODE_FOR_avx512vl_us_truncatev4siv4hi2_mask = 2866,
CODE_FOR_avx512vl_ss_truncatev4div4hi2_mask = 2867,
CODE_FOR_avx512vl_truncatev4div4hi2_mask = 2868,
CODE_FOR_avx512vl_us_truncatev4div4hi2_mask = 2869,
CODE_FOR_avx512vl_ss_truncatev4siv4hi2_mask_store = 2876,
CODE_FOR_avx512vl_truncatev4siv4hi2_mask_store = 2877,
CODE_FOR_avx512vl_us_truncatev4siv4hi2_mask_store = 2878,
CODE_FOR_avx512vl_ss_truncatev4div4hi2_mask_store = 2879,
CODE_FOR_avx512vl_truncatev4div4hi2_mask_store = 2880,
CODE_FOR_avx512vl_us_truncatev4div4hi2_mask_store = 2881,
CODE_FOR_avx512vl_ss_truncatev2div2hi2_mask = 2885,
CODE_FOR_avx512vl_truncatev2div2hi2_mask = 2886,
CODE_FOR_avx512vl_us_truncatev2div2hi2_mask = 2887,
CODE_FOR_avx512vl_ss_truncatev2div2hi2_mask_store = 2891,
CODE_FOR_avx512vl_truncatev2div2hi2_mask_store = 2892,
CODE_FOR_avx512vl_us_truncatev2div2hi2_mask_store = 2893,
CODE_FOR_avx512vl_ss_truncatev2div2si2_mask = 2900,
CODE_FOR_avx512vl_truncatev2div2si2_mask = 2901,
CODE_FOR_avx512vl_us_truncatev2div2si2_mask = 2902,
CODE_FOR_avx512vl_ss_truncatev2div2si2_mask_store = 2906,
CODE_FOR_avx512vl_truncatev2div2si2_mask_store = 2907,
CODE_FOR_avx512vl_us_truncatev2div2si2_mask_store = 2908,
CODE_FOR_avx512f_ss_truncatev8div16qi2_mask = 2915,
CODE_FOR_avx512f_truncatev8div16qi2_mask = 2916,
CODE_FOR_avx512f_us_truncatev8div16qi2_mask = 2917,
CODE_FOR_avx512f_ss_truncatev8div16qi2_mask_store = 2921,
CODE_FOR_avx512f_truncatev8div16qi2_mask_store = 2922,
CODE_FOR_avx512f_us_truncatev8div16qi2_mask_store = 2923,
CODE_FOR_avx512bw_pmaddwd512v32hi = 3074,
CODE_FOR_avx512bw_pmaddwd512v32hi_mask = 3075,
CODE_FOR_avx512bw_pmaddwd512v16hi = 3076,
CODE_FOR_avx512bw_pmaddwd512v16hi_mask = 3077,
CODE_FOR_avx512bw_pmaddwd512v8hi = 3078,
CODE_FOR_avx512bw_pmaddwd512v8hi_mask = 3079,
CODE_FOR_avx512dq_mulv8di3 = 3082,
CODE_FOR_avx512dq_mulv8di3_mask = 3083,
CODE_FOR_avx512dq_mulv4di3 = 3084,
CODE_FOR_avx512dq_mulv4di3_mask = 3085,
CODE_FOR_avx512dq_mulv2di3 = 3086,
CODE_FOR_avx512dq_mulv2di3_mask = 3087,
CODE_FOR_ashrv16hi3_mask = 3095,
CODE_FOR_ashrv8hi3_mask = 3097,
CODE_FOR_ashrv8si3_mask = 3099,
CODE_FOR_ashrv4si3_mask = 3101,
CODE_FOR_ashrv16hi3 = 3102,
CODE_FOR_ashrv8hi3 = 3103,
CODE_FOR_ashrv8si3 = 3104,
CODE_FOR_ashrv4si3 = 3105,
CODE_FOR_ashrv2di3_mask = 3107,
CODE_FOR_ashrv32hi3 = 3108,
CODE_FOR_ashrv32hi3_mask = 3109,
CODE_FOR_ashrv4di3 = 3110,
CODE_FOR_ashrv4di3_mask = 3111,
CODE_FOR_ashrv16si3 = 3112,
CODE_FOR_ashrv16si3_mask = 3113,
CODE_FOR_ashrv8di3 = 3114,
CODE_FOR_ashrv8di3_mask = 3115,
CODE_FOR_ashlv32hi3 = 3116,
CODE_FOR_ashlv32hi3_mask = 3117,
CODE_FOR_lshrv32hi3 = 3118,
CODE_FOR_lshrv32hi3_mask = 3119,
CODE_FOR_ashlv16hi3 = 3120,
CODE_FOR_ashlv16hi3_mask = 3121,
CODE_FOR_lshrv16hi3 = 3122,
CODE_FOR_lshrv16hi3_mask = 3123,
CODE_FOR_ashlv8hi3 = 3124,
CODE_FOR_ashlv8hi3_mask = 3125,
CODE_FOR_lshrv8hi3 = 3126,
CODE_FOR_lshrv8hi3_mask = 3127,
CODE_FOR_ashlv8si3 = 3128,
CODE_FOR_ashlv8si3_mask = 3129,
CODE_FOR_lshrv8si3 = 3130,
CODE_FOR_lshrv8si3_mask = 3131,
CODE_FOR_ashlv4si3 = 3132,
CODE_FOR_ashlv4si3_mask = 3133,
CODE_FOR_lshrv4si3 = 3134,
CODE_FOR_lshrv4si3_mask = 3135,
CODE_FOR_ashlv4di3 = 3136,
CODE_FOR_ashlv4di3_mask = 3137,
CODE_FOR_lshrv4di3 = 3138,
CODE_FOR_lshrv4di3_mask = 3139,
CODE_FOR_ashlv2di3 = 3140,
CODE_FOR_ashlv2di3_mask = 3141,
CODE_FOR_lshrv2di3 = 3142,
CODE_FOR_lshrv2di3_mask = 3143,
CODE_FOR_ashlv16si3 = 3144,
CODE_FOR_ashlv16si3_mask = 3145,
CODE_FOR_lshrv16si3 = 3146,
CODE_FOR_lshrv16si3_mask = 3147,
CODE_FOR_ashlv8di3 = 3148,
CODE_FOR_ashlv8di3_mask = 3149,
CODE_FOR_lshrv8di3 = 3150,
CODE_FOR_lshrv8di3_mask = 3151,
CODE_FOR_avx512bw_ashlv4ti3 = 3152,
CODE_FOR_avx2_ashlv2ti3 = 3153,
CODE_FOR_sse2_ashlv1ti3 = 3154,
CODE_FOR_avx512bw_lshrv4ti3 = 3155,
CODE_FOR_avx2_lshrv2ti3 = 3156,
CODE_FOR_sse2_lshrv1ti3 = 3157,
CODE_FOR_avx512f_rolvv16si = 3158,
CODE_FOR_avx512f_rolvv16si_mask = 3159,
CODE_FOR_avx512f_rorvv16si = 3160,
CODE_FOR_avx512f_rorvv16si_mask = 3161,
CODE_FOR_avx512vl_rolvv8si = 3162,
CODE_FOR_avx512vl_rolvv8si_mask = 3163,
CODE_FOR_avx512vl_rorvv8si = 3164,
CODE_FOR_avx512vl_rorvv8si_mask = 3165,
CODE_FOR_avx512vl_rolvv4si = 3166,
CODE_FOR_avx512vl_rolvv4si_mask = 3167,
CODE_FOR_avx512vl_rorvv4si = 3168,
CODE_FOR_avx512vl_rorvv4si_mask = 3169,
CODE_FOR_avx512f_rolvv8di = 3170,
CODE_FOR_avx512f_rolvv8di_mask = 3171,
CODE_FOR_avx512f_rorvv8di = 3172,
CODE_FOR_avx512f_rorvv8di_mask = 3173,
CODE_FOR_avx512vl_rolvv4di = 3174,
CODE_FOR_avx512vl_rolvv4di_mask = 3175,
CODE_FOR_avx512vl_rorvv4di = 3176,
CODE_FOR_avx512vl_rorvv4di_mask = 3177,
CODE_FOR_avx512vl_rolvv2di = 3178,
CODE_FOR_avx512vl_rolvv2di_mask = 3179,
CODE_FOR_avx512vl_rorvv2di = 3180,
CODE_FOR_avx512vl_rorvv2di_mask = 3181,
CODE_FOR_avx512f_rolv16si = 3182,
CODE_FOR_avx512f_rolv16si_mask = 3183,
CODE_FOR_avx512f_rorv16si = 3184,
CODE_FOR_avx512f_rorv16si_mask = 3185,
CODE_FOR_avx512vl_rolv8si = 3186,
CODE_FOR_avx512vl_rolv8si_mask = 3187,
CODE_FOR_avx512vl_rorv8si = 3188,
CODE_FOR_avx512vl_rorv8si_mask = 3189,
CODE_FOR_avx512vl_rolv4si = 3190,
CODE_FOR_avx512vl_rolv4si_mask = 3191,
CODE_FOR_avx512vl_rorv4si = 3192,
CODE_FOR_avx512vl_rorv4si_mask = 3193,
CODE_FOR_avx512f_rolv8di = 3194,
CODE_FOR_avx512f_rolv8di_mask = 3195,
CODE_FOR_avx512f_rorv8di = 3196,
CODE_FOR_avx512f_rorv8di_mask = 3197,
CODE_FOR_avx512vl_rolv4di = 3198,
CODE_FOR_avx512vl_rolv4di_mask = 3199,
CODE_FOR_avx512vl_rorv4di = 3200,
CODE_FOR_avx512vl_rorv4di_mask = 3201,
CODE_FOR_avx512vl_rolv2di = 3202,
CODE_FOR_avx512vl_rolv2di_mask = 3203,
CODE_FOR_avx512vl_rorv2di = 3204,
CODE_FOR_avx512vl_rorv2di_mask = 3205,
CODE_FOR_smaxv64qi3_mask = 3267,
CODE_FOR_sminv64qi3_mask = 3269,
CODE_FOR_umaxv64qi3_mask = 3271,
CODE_FOR_uminv64qi3_mask = 3273,
CODE_FOR_smaxv16qi3_mask = 3275,
CODE_FOR_sminv16qi3_mask = 3277,
CODE_FOR_umaxv16qi3_mask = 3279,
CODE_FOR_uminv16qi3_mask = 3281,
CODE_FOR_smaxv32qi3_mask = 3283,
CODE_FOR_sminv32qi3_mask = 3285,
CODE_FOR_umaxv32qi3_mask = 3287,
CODE_FOR_uminv32qi3_mask = 3289,
CODE_FOR_smaxv32hi3_mask = 3291,
CODE_FOR_sminv32hi3_mask = 3293,
CODE_FOR_umaxv32hi3_mask = 3295,
CODE_FOR_uminv32hi3_mask = 3297,
CODE_FOR_smaxv16hi3_mask = 3299,
CODE_FOR_sminv16hi3_mask = 3301,
CODE_FOR_umaxv16hi3_mask = 3303,
CODE_FOR_uminv16hi3_mask = 3305,
CODE_FOR_smaxv8hi3_mask = 3307,
CODE_FOR_sminv8hi3_mask = 3309,
CODE_FOR_umaxv8hi3_mask = 3311,
CODE_FOR_uminv8hi3_mask = 3313,
CODE_FOR_avx512bw_eqv64qi3_1 = 3338,
CODE_FOR_avx512bw_eqv64qi3_mask_1 = 3339,
CODE_FOR_avx512vl_eqv16qi3_1 = 3340,
CODE_FOR_avx512vl_eqv16qi3_mask_1 = 3341,
CODE_FOR_avx512vl_eqv32qi3_1 = 3342,
CODE_FOR_avx512vl_eqv32qi3_mask_1 = 3343,
CODE_FOR_avx512bw_eqv32hi3_1 = 3344,
CODE_FOR_avx512bw_eqv32hi3_mask_1 = 3345,
CODE_FOR_avx512vl_eqv16hi3_1 = 3346,
CODE_FOR_avx512vl_eqv16hi3_mask_1 = 3347,
CODE_FOR_avx512vl_eqv8hi3_1 = 3348,
CODE_FOR_avx512vl_eqv8hi3_mask_1 = 3349,
CODE_FOR_avx512f_eqv16si3_1 = 3350,
CODE_FOR_avx512f_eqv16si3_mask_1 = 3351,
CODE_FOR_avx512vl_eqv8si3_1 = 3352,
CODE_FOR_avx512vl_eqv8si3_mask_1 = 3353,
CODE_FOR_avx512vl_eqv4si3_1 = 3354,
CODE_FOR_avx512vl_eqv4si3_mask_1 = 3355,
CODE_FOR_avx512f_eqv8di3_1 = 3356,
CODE_FOR_avx512f_eqv8di3_mask_1 = 3357,
CODE_FOR_avx512vl_eqv4di3_1 = 3358,
CODE_FOR_avx512vl_eqv4di3_mask_1 = 3359,
CODE_FOR_avx512vl_eqv2di3_1 = 3360,
CODE_FOR_avx512vl_eqv2di3_mask_1 = 3361,
CODE_FOR_sse4_2_gtv2di3 = 3366,
CODE_FOR_avx2_gtv32qi3 = 3367,
CODE_FOR_avx2_gtv16hi3 = 3368,
CODE_FOR_avx2_gtv8si3 = 3369,
CODE_FOR_avx2_gtv4di3 = 3370,
CODE_FOR_avx512f_gtv16si3 = 3371,
CODE_FOR_avx512f_gtv16si3_mask = 3372,
CODE_FOR_avx512vl_gtv8si3 = 3373,
CODE_FOR_avx512vl_gtv8si3_mask = 3374,
CODE_FOR_avx512vl_gtv4si3 = 3375,
CODE_FOR_avx512vl_gtv4si3_mask = 3376,
CODE_FOR_avx512f_gtv8di3 = 3377,
CODE_FOR_avx512f_gtv8di3_mask = 3378,
CODE_FOR_avx512vl_gtv4di3 = 3379,
CODE_FOR_avx512vl_gtv4di3_mask = 3380,
CODE_FOR_avx512vl_gtv2di3 = 3381,
CODE_FOR_avx512vl_gtv2di3_mask = 3382,
CODE_FOR_avx512bw_gtv64qi3 = 3383,
CODE_FOR_avx512bw_gtv64qi3_mask = 3384,
CODE_FOR_avx512vl_gtv16qi3 = 3385,
CODE_FOR_avx512vl_gtv16qi3_mask = 3386,
CODE_FOR_avx512vl_gtv32qi3 = 3387,
CODE_FOR_avx512vl_gtv32qi3_mask = 3388,
CODE_FOR_avx512bw_gtv32hi3 = 3389,
CODE_FOR_avx512bw_gtv32hi3_mask = 3390,
CODE_FOR_avx512vl_gtv16hi3 = 3391,
CODE_FOR_avx512vl_gtv16hi3_mask = 3392,
CODE_FOR_avx512vl_gtv8hi3 = 3393,
CODE_FOR_avx512vl_gtv8hi3_mask = 3394,
CODE_FOR_sse2_gtv16qi3 = 3395,
CODE_FOR_sse2_gtv8hi3 = 3396,
CODE_FOR_sse2_gtv4si3 = 3397,
CODE_FOR_andv16si3_mask = 3417,
CODE_FOR_iorv16si3_mask = 3419,
CODE_FOR_xorv16si3_mask = 3421,
CODE_FOR_andv8si3_mask = 3423,
CODE_FOR_iorv8si3_mask = 3425,
CODE_FOR_xorv8si3_mask = 3427,
CODE_FOR_andv4si3_mask = 3429,
CODE_FOR_iorv4si3_mask = 3431,
CODE_FOR_xorv4si3_mask = 3433,
CODE_FOR_andv8di3_mask = 3435,
CODE_FOR_iorv8di3_mask = 3437,
CODE_FOR_xorv8di3_mask = 3439,
CODE_FOR_andv4di3_mask = 3441,
CODE_FOR_iorv4di3_mask = 3443,
CODE_FOR_xorv4di3_mask = 3445,
CODE_FOR_andv2di3_mask = 3447,
CODE_FOR_iorv2di3_mask = 3449,
CODE_FOR_xorv2di3_mask = 3451,
CODE_FOR_avx512bw_testmv64qi3 = 3488,
CODE_FOR_avx512bw_testmv64qi3_mask = 3489,
CODE_FOR_avx512vl_testmv16qi3 = 3490,
CODE_FOR_avx512vl_testmv16qi3_mask = 3491,
CODE_FOR_avx512vl_testmv32qi3 = 3492,
CODE_FOR_avx512vl_testmv32qi3_mask = 3493,
CODE_FOR_avx512bw_testmv32hi3 = 3494,
CODE_FOR_avx512bw_testmv32hi3_mask = 3495,
CODE_FOR_avx512vl_testmv16hi3 = 3496,
CODE_FOR_avx512vl_testmv16hi3_mask = 3497,
CODE_FOR_avx512vl_testmv8hi3 = 3498,
CODE_FOR_avx512vl_testmv8hi3_mask = 3499,
CODE_FOR_avx512f_testmv16si3 = 3500,
CODE_FOR_avx512f_testmv16si3_mask = 3501,
CODE_FOR_avx512vl_testmv8si3 = 3502,
CODE_FOR_avx512vl_testmv8si3_mask = 3503,
CODE_FOR_avx512vl_testmv4si3 = 3504,
CODE_FOR_avx512vl_testmv4si3_mask = 3505,
CODE_FOR_avx512f_testmv8di3 = 3506,
CODE_FOR_avx512f_testmv8di3_mask = 3507,
CODE_FOR_avx512vl_testmv4di3 = 3508,
CODE_FOR_avx512vl_testmv4di3_mask = 3509,
CODE_FOR_avx512vl_testmv2di3 = 3510,
CODE_FOR_avx512vl_testmv2di3_mask = 3511,
CODE_FOR_avx512bw_testnmv64qi3 = 3512,
CODE_FOR_avx512bw_testnmv64qi3_mask = 3513,
CODE_FOR_avx512vl_testnmv16qi3 = 3514,
CODE_FOR_avx512vl_testnmv16qi3_mask = 3515,
CODE_FOR_avx512vl_testnmv32qi3 = 3516,
CODE_FOR_avx512vl_testnmv32qi3_mask = 3517,
CODE_FOR_avx512bw_testnmv32hi3 = 3518,
CODE_FOR_avx512bw_testnmv32hi3_mask = 3519,
CODE_FOR_avx512vl_testnmv16hi3 = 3520,
CODE_FOR_avx512vl_testnmv16hi3_mask = 3521,
CODE_FOR_avx512vl_testnmv8hi3 = 3522,
CODE_FOR_avx512vl_testnmv8hi3_mask = 3523,
CODE_FOR_avx512f_testnmv16si3 = 3524,
CODE_FOR_avx512f_testnmv16si3_mask = 3525,
CODE_FOR_avx512vl_testnmv8si3 = 3526,
CODE_FOR_avx512vl_testnmv8si3_mask = 3527,
CODE_FOR_avx512vl_testnmv4si3 = 3528,
CODE_FOR_avx512vl_testnmv4si3_mask = 3529,
CODE_FOR_avx512f_testnmv8di3 = 3530,
CODE_FOR_avx512f_testnmv8di3_mask = 3531,
CODE_FOR_avx512vl_testnmv4di3 = 3532,
CODE_FOR_avx512vl_testnmv4di3_mask = 3533,
CODE_FOR_avx512vl_testnmv2di3 = 3534,
CODE_FOR_avx512vl_testnmv2di3_mask = 3535,
CODE_FOR_avx512bw_packsswb = 3536,
CODE_FOR_avx512bw_packsswb_mask = 3537,
CODE_FOR_avx2_packsswb = 3538,
CODE_FOR_avx2_packsswb_mask = 3539,
CODE_FOR_sse2_packsswb = 3540,
CODE_FOR_sse2_packsswb_mask = 3541,
CODE_FOR_avx512bw_packssdw = 3542,
CODE_FOR_avx512bw_packssdw_mask = 3543,
CODE_FOR_avx2_packssdw = 3544,
CODE_FOR_avx2_packssdw_mask = 3545,
CODE_FOR_sse2_packssdw = 3546,
CODE_FOR_sse2_packssdw_mask = 3547,
CODE_FOR_avx512bw_packuswb = 3548,
CODE_FOR_avx512bw_packuswb_mask = 3549,
CODE_FOR_avx2_packuswb = 3550,
CODE_FOR_avx2_packuswb_mask = 3551,
CODE_FOR_sse2_packuswb = 3552,
CODE_FOR_sse2_packuswb_mask = 3553,
CODE_FOR_avx512bw_interleave_highv64qi = 3554,
CODE_FOR_avx512bw_interleave_highv64qi_mask = 3555,
CODE_FOR_avx2_interleave_highv32qi = 3556,
CODE_FOR_avx2_interleave_highv32qi_mask = 3557,
CODE_FOR_vec_interleave_highv16qi = 3558,
CODE_FOR_vec_interleave_highv16qi_mask = 3559,
CODE_FOR_avx512bw_interleave_lowv64qi = 3560,
CODE_FOR_avx512bw_interleave_lowv64qi_mask = 3561,
CODE_FOR_avx2_interleave_lowv32qi = 3562,
CODE_FOR_avx2_interleave_lowv32qi_mask = 3563,
CODE_FOR_vec_interleave_lowv16qi = 3564,
CODE_FOR_vec_interleave_lowv16qi_mask = 3565,
CODE_FOR_avx512bw_interleave_highv32hi = 3566,
CODE_FOR_avx512bw_interleave_highv32hi_mask = 3567,
CODE_FOR_avx2_interleave_highv16hi = 3568,
CODE_FOR_avx2_interleave_highv16hi_mask = 3569,
CODE_FOR_vec_interleave_highv8hi = 3570,
CODE_FOR_vec_interleave_highv8hi_mask = 3571,
CODE_FOR_avx512bw_interleave_lowv32hi_mask = 3573,
CODE_FOR_avx2_interleave_lowv16hi = 3574,
CODE_FOR_avx2_interleave_lowv16hi_mask = 3575,
CODE_FOR_vec_interleave_lowv8hi = 3576,
CODE_FOR_vec_interleave_lowv8hi_mask = 3577,
CODE_FOR_avx2_interleave_highv8si = 3578,
CODE_FOR_avx2_interleave_highv8si_mask = 3579,
CODE_FOR_avx512f_interleave_highv16si_mask = 3581,
CODE_FOR_vec_interleave_highv4si = 3582,
CODE_FOR_vec_interleave_highv4si_mask = 3583,
CODE_FOR_avx2_interleave_lowv8si = 3584,
CODE_FOR_avx2_interleave_lowv8si_mask = 3585,
CODE_FOR_avx512f_interleave_lowv16si_mask = 3587,
CODE_FOR_vec_interleave_lowv4si = 3588,
CODE_FOR_vec_interleave_lowv4si_mask = 3589,
CODE_FOR_sse4_1_pinsrb = 3590,
CODE_FOR_sse2_pinsrw = 3591,
CODE_FOR_sse4_1_pinsrd = 3592,
CODE_FOR_sse4_1_pinsrq = 3593,
CODE_FOR_avx512dq_vinsertf64x2_1_mask = 3595,
CODE_FOR_avx512dq_vinserti64x2_1_mask = 3597,
CODE_FOR_avx512f_vinsertf32x4_1_mask = 3599,
CODE_FOR_avx512f_vinserti32x4_1_mask = 3601,
CODE_FOR_vec_set_lo_v16sf = 3602,
CODE_FOR_vec_set_lo_v16sf_mask = 3603,
CODE_FOR_vec_set_lo_v16si = 3604,
CODE_FOR_vec_set_lo_v16si_mask = 3605,
CODE_FOR_vec_set_hi_v16sf = 3606,
CODE_FOR_vec_set_hi_v16sf_mask = 3607,
CODE_FOR_vec_set_hi_v16si = 3608,
CODE_FOR_vec_set_hi_v16si_mask = 3609,
CODE_FOR_vec_set_lo_v8df = 3610,
CODE_FOR_vec_set_lo_v8df_mask = 3611,
CODE_FOR_vec_set_lo_v8di = 3612,
CODE_FOR_vec_set_lo_v8di_mask = 3613,
CODE_FOR_vec_set_hi_v8df = 3614,
CODE_FOR_vec_set_hi_v8df_mask = 3615,
CODE_FOR_vec_set_hi_v8di = 3616,
CODE_FOR_vec_set_hi_v8di_mask = 3617,
CODE_FOR_avx512dq_shuf_i64x2_1_mask = 3619,
CODE_FOR_avx512dq_shuf_f64x2_1_mask = 3621,
CODE_FOR_avx512f_shuf_f64x2_1 = 3622,
CODE_FOR_avx512f_shuf_f64x2_1_mask = 3623,
CODE_FOR_avx512f_shuf_i64x2_1 = 3624,
CODE_FOR_avx512f_shuf_i64x2_1_mask = 3625,
CODE_FOR_avx512vl_shuf_i32x4_1 = 3626,
CODE_FOR_avx512vl_shuf_i32x4_1_mask = 3627,
CODE_FOR_avx512vl_shuf_f32x4_1 = 3628,
CODE_FOR_avx512vl_shuf_f32x4_1_mask = 3629,
CODE_FOR_avx512f_shuf_f32x4_1 = 3630,
CODE_FOR_avx512f_shuf_f32x4_1_mask = 3631,
CODE_FOR_avx512f_shuf_i32x4_1 = 3632,
CODE_FOR_avx512f_shuf_i32x4_1_mask = 3633,
CODE_FOR_avx512f_pshufd_1 = 3634,
CODE_FOR_avx512f_pshufd_1_mask = 3635,
CODE_FOR_avx2_pshufd_1 = 3636,
CODE_FOR_avx2_pshufd_1_mask = 3637,
CODE_FOR_sse2_pshufd_1 = 3638,
CODE_FOR_sse2_pshufd_1_mask = 3639,
CODE_FOR_avx512bw_pshuflwv32hi_mask = 3641,
CODE_FOR_avx2_pshuflw_1 = 3642,
CODE_FOR_avx2_pshuflw_1_mask = 3643,
CODE_FOR_sse2_pshuflw_1 = 3644,
CODE_FOR_sse2_pshuflw_1_mask = 3645,
CODE_FOR_avx512bw_pshufhwv32hi_mask = 3647,
CODE_FOR_avx2_pshufhw_1 = 3648,
CODE_FOR_avx2_pshufhw_1_mask = 3649,
CODE_FOR_sse2_pshufhw_1 = 3650,
CODE_FOR_sse2_pshufhw_1_mask = 3651,
CODE_FOR_sse2_loadld = 3652,
CODE_FOR_vec_concatv2di = 3674,
CODE_FOR_avx512f_psadbw = 3687,
CODE_FOR_avx2_psadbw = 3688,
CODE_FOR_sse2_psadbw = 3689,
CODE_FOR_avx_movmskps256 = 3690,
CODE_FOR_sse_movmskps = 3691,
CODE_FOR_avx_movmskpd256 = 3692,
CODE_FOR_sse2_movmskpd = 3693,
CODE_FOR_avx2_pmovmskb = 3698,
CODE_FOR_sse2_pmovmskb = 3699,
CODE_FOR_sse_ldmxcsr = 3704,
CODE_FOR_sse_stmxcsr = 3705,
CODE_FOR_sse2_clflush = 3706,
CODE_FOR_sse3_mwait = 3707,
CODE_FOR_sse3_monitor_si = 3708,
CODE_FOR_sse3_monitor_di = 3709,
CODE_FOR_avx2_phaddwv16hi3 = 3710,
CODE_FOR_avx2_phaddswv16hi3 = 3711,
CODE_FOR_avx2_phsubwv16hi3 = 3712,
CODE_FOR_avx2_phsubswv16hi3 = 3713,
CODE_FOR_ssse3_phaddwv8hi3 = 3714,
CODE_FOR_ssse3_phaddswv8hi3 = 3715,
CODE_FOR_ssse3_phsubwv8hi3 = 3716,
CODE_FOR_ssse3_phsubswv8hi3 = 3717,
CODE_FOR_ssse3_phaddwv4hi3 = 3718,
CODE_FOR_ssse3_phaddswv4hi3 = 3719,
CODE_FOR_ssse3_phsubwv4hi3 = 3720,
CODE_FOR_ssse3_phsubswv4hi3 = 3721,
CODE_FOR_avx2_phadddv8si3 = 3722,
CODE_FOR_avx2_phsubdv8si3 = 3723,
CODE_FOR_ssse3_phadddv4si3 = 3724,
CODE_FOR_ssse3_phsubdv4si3 = 3725,
CODE_FOR_ssse3_phadddv2si3 = 3726,
CODE_FOR_ssse3_phsubdv2si3 = 3727,
CODE_FOR_avx2_pmaddubsw256 = 3728,
CODE_FOR_avx512bw_pmaddubsw512v8hi = 3729,
CODE_FOR_avx512bw_pmaddubsw512v8hi_mask = 3730,
CODE_FOR_avx512bw_pmaddubsw512v16hi = 3731,
CODE_FOR_avx512bw_pmaddubsw512v16hi_mask = 3732,
CODE_FOR_avx512bw_pmaddubsw512v32hi = 3733,
CODE_FOR_avx512bw_pmaddubsw512v32hi_mask = 3734,
CODE_FOR_avx512bw_umulhrswv32hi3 = 3735,
CODE_FOR_avx512bw_umulhrswv32hi3_mask = 3736,
CODE_FOR_ssse3_pmaddubsw128 = 3737,
CODE_FOR_ssse3_pmaddubsw = 3738,
CODE_FOR_avx512bw_pshufbv64qi3 = 3746,
CODE_FOR_avx512bw_pshufbv64qi3_mask = 3747,
CODE_FOR_avx2_pshufbv32qi3 = 3748,
CODE_FOR_avx2_pshufbv32qi3_mask = 3749,
CODE_FOR_ssse3_pshufbv16qi3 = 3750,
CODE_FOR_ssse3_pshufbv16qi3_mask = 3751,
CODE_FOR_ssse3_pshufbv8qi3 = 3752,
CODE_FOR_avx2_psignv32qi3 = 3753,
CODE_FOR_ssse3_psignv16qi3 = 3754,
CODE_FOR_avx2_psignv16hi3 = 3755,
CODE_FOR_ssse3_psignv8hi3 = 3756,
CODE_FOR_avx2_psignv8si3 = 3757,
CODE_FOR_ssse3_psignv4si3 = 3758,
CODE_FOR_ssse3_psignv8qi3 = 3759,
CODE_FOR_ssse3_psignv4hi3 = 3760,
CODE_FOR_ssse3_psignv2si3 = 3761,
CODE_FOR_avx512bw_palignrv64qi_mask = 3762,
CODE_FOR_avx2_palignrv32qi_mask = 3763,
CODE_FOR_ssse3_palignrv16qi_mask = 3764,
CODE_FOR_avx512bw_palignrv4ti = 3765,
CODE_FOR_avx2_palignrv2ti = 3766,
CODE_FOR_ssse3_palignrti = 3767,
CODE_FOR_ssse3_palignrdi = 3768,
CODE_FOR_absv16si2_mask = 3781,
CODE_FOR_absv8si2_mask = 3782,
CODE_FOR_absv4si2_mask = 3783,
CODE_FOR_absv8di2_mask = 3784,
CODE_FOR_absv4di2_mask = 3785,
CODE_FOR_absv2di2_mask = 3786,
CODE_FOR_absv64qi2_mask = 3787,
CODE_FOR_absv16qi2_mask = 3788,
CODE_FOR_absv32qi2_mask = 3789,
CODE_FOR_absv32hi2_mask = 3790,
CODE_FOR_absv16hi2_mask = 3791,
CODE_FOR_absv8hi2_mask = 3792,
CODE_FOR_absv8qi2 = 3793,
CODE_FOR_absv4hi2 = 3794,
CODE_FOR_absv2si2 = 3795,
CODE_FOR_sse4a_movntsf = 3796,
CODE_FOR_sse4a_movntdf = 3797,
CODE_FOR_sse4a_vmmovntv4sf = 3798,
CODE_FOR_sse4a_vmmovntv2df = 3799,
CODE_FOR_sse4a_extrqi = 3800,
CODE_FOR_sse4a_extrq = 3801,
CODE_FOR_sse4a_insertqi = 3802,
CODE_FOR_sse4a_insertq = 3803,
CODE_FOR_avx_blendps256 = 3804,
CODE_FOR_sse4_1_blendps = 3805,
CODE_FOR_avx_blendpd256 = 3806,
CODE_FOR_sse4_1_blendpd = 3807,
CODE_FOR_avx_blendvps256 = 3808,
CODE_FOR_sse4_1_blendvps = 3809,
CODE_FOR_avx_blendvpd256 = 3810,
CODE_FOR_sse4_1_blendvpd = 3811,
CODE_FOR_avx_dpps256 = 3812,
CODE_FOR_sse4_1_dpps = 3813,
CODE_FOR_avx_dppd256 = 3814,
CODE_FOR_sse4_1_dppd = 3815,
CODE_FOR_avx512f_movntdqa = 3816,
CODE_FOR_avx2_movntdqa = 3817,
CODE_FOR_sse4_1_movntdqa = 3818,
CODE_FOR_avx2_mpsadbw = 3819,
CODE_FOR_sse4_1_mpsadbw = 3820,
CODE_FOR_avx512bw_packusdw = 3821,
CODE_FOR_avx512bw_packusdw_mask = 3822,
CODE_FOR_avx2_packusdw = 3823,
CODE_FOR_avx2_packusdw_mask = 3824,
CODE_FOR_sse4_1_packusdw = 3825,
CODE_FOR_sse4_1_packusdw_mask = 3826,
CODE_FOR_avx2_pblendvb = 3827,
CODE_FOR_sse4_1_pblendvb = 3828,
CODE_FOR_sse4_1_pblendw = 3829,
CODE_FOR_avx2_pblenddv8si = 3831,
CODE_FOR_avx2_pblenddv4si = 3832,
CODE_FOR_sse4_1_phminposuw = 3833,
CODE_FOR_avx2_sign_extendv16qiv16hi2 = 3834,
CODE_FOR_avx2_sign_extendv16qiv16hi2_mask = 3835,
CODE_FOR_avx2_zero_extendv16qiv16hi2 = 3836,
CODE_FOR_avx2_zero_extendv16qiv16hi2_mask = 3837,
CODE_FOR_avx512bw_sign_extendv32qiv32hi2 = 3838,
CODE_FOR_avx512bw_sign_extendv32qiv32hi2_mask = 3839,
CODE_FOR_avx512bw_zero_extendv32qiv32hi2 = 3840,
CODE_FOR_avx512bw_zero_extendv32qiv32hi2_mask = 3841,
CODE_FOR_sse4_1_sign_extendv8qiv8hi2 = 3842,
CODE_FOR_sse4_1_sign_extendv8qiv8hi2_mask = 3843,
CODE_FOR_sse4_1_zero_extendv8qiv8hi2 = 3844,
CODE_FOR_sse4_1_zero_extendv8qiv8hi2_mask = 3845,
CODE_FOR_avx512f_sign_extendv16qiv16si2_mask = 3847,
CODE_FOR_avx512f_zero_extendv16qiv16si2_mask = 3849,
CODE_FOR_avx2_sign_extendv8qiv8si2 = 3850,
CODE_FOR_avx2_sign_extendv8qiv8si2_mask = 3851,
CODE_FOR_avx2_zero_extendv8qiv8si2 = 3852,
CODE_FOR_avx2_zero_extendv8qiv8si2_mask = 3853,
CODE_FOR_sse4_1_sign_extendv4qiv4si2 = 3854,
CODE_FOR_sse4_1_sign_extendv4qiv4si2_mask = 3855,
CODE_FOR_sse4_1_zero_extendv4qiv4si2 = 3856,
CODE_FOR_sse4_1_zero_extendv4qiv4si2_mask = 3857,
CODE_FOR_avx512f_sign_extendv16hiv16si2 = 3858,
CODE_FOR_avx512f_sign_extendv16hiv16si2_mask = 3859,
CODE_FOR_avx512f_zero_extendv16hiv16si2 = 3860,
CODE_FOR_avx512f_zero_extendv16hiv16si2_mask = 3861,
CODE_FOR_avx2_sign_extendv8hiv8si2 = 3862,
CODE_FOR_avx2_sign_extendv8hiv8si2_mask = 3863,
CODE_FOR_avx2_zero_extendv8hiv8si2 = 3864,
CODE_FOR_avx2_zero_extendv8hiv8si2_mask = 3865,
CODE_FOR_sse4_1_sign_extendv4hiv4si2 = 3866,
CODE_FOR_sse4_1_sign_extendv4hiv4si2_mask = 3867,
CODE_FOR_sse4_1_zero_extendv4hiv4si2 = 3868,
CODE_FOR_sse4_1_zero_extendv4hiv4si2_mask = 3869,
CODE_FOR_avx512f_sign_extendv8qiv8di2 = 3870,
CODE_FOR_avx512f_sign_extendv8qiv8di2_mask = 3871,
CODE_FOR_avx512f_zero_extendv8qiv8di2 = 3872,
CODE_FOR_avx512f_zero_extendv8qiv8di2_mask = 3873,
CODE_FOR_avx2_sign_extendv4qiv4di2 = 3874,
CODE_FOR_avx2_sign_extendv4qiv4di2_mask = 3875,
CODE_FOR_avx2_zero_extendv4qiv4di2 = 3876,
CODE_FOR_avx2_zero_extendv4qiv4di2_mask = 3877,
CODE_FOR_sse4_1_sign_extendv2qiv2di2 = 3878,
CODE_FOR_sse4_1_sign_extendv2qiv2di2_mask = 3879,
CODE_FOR_sse4_1_zero_extendv2qiv2di2 = 3880,
CODE_FOR_sse4_1_zero_extendv2qiv2di2_mask = 3881,
CODE_FOR_avx512f_sign_extendv8hiv8di2 = 3882,
CODE_FOR_avx512f_sign_extendv8hiv8di2_mask = 3883,
CODE_FOR_avx512f_zero_extendv8hiv8di2 = 3884,
CODE_FOR_avx512f_zero_extendv8hiv8di2_mask = 3885,
CODE_FOR_avx2_sign_extendv4hiv4di2 = 3886,
CODE_FOR_avx2_sign_extendv4hiv4di2_mask = 3887,
CODE_FOR_avx2_zero_extendv4hiv4di2 = 3888,
CODE_FOR_avx2_zero_extendv4hiv4di2_mask = 3889,
CODE_FOR_sse4_1_sign_extendv2hiv2di2 = 3890,
CODE_FOR_sse4_1_sign_extendv2hiv2di2_mask = 3891,
CODE_FOR_sse4_1_zero_extendv2hiv2di2 = 3892,
CODE_FOR_sse4_1_zero_extendv2hiv2di2_mask = 3893,
CODE_FOR_avx512f_sign_extendv8siv8di2 = 3894,
CODE_FOR_avx512f_sign_extendv8siv8di2_mask = 3895,
CODE_FOR_avx512f_zero_extendv8siv8di2 = 3896,
CODE_FOR_avx512f_zero_extendv8siv8di2_mask = 3897,
CODE_FOR_avx2_sign_extendv4siv4di2 = 3898,
CODE_FOR_avx2_sign_extendv4siv4di2_mask = 3899,
CODE_FOR_avx2_zero_extendv4siv4di2 = 3900,
CODE_FOR_avx2_zero_extendv4siv4di2_mask = 3901,
CODE_FOR_sse4_1_sign_extendv2siv2di2 = 3902,
CODE_FOR_sse4_1_sign_extendv2siv2di2_mask = 3903,
CODE_FOR_sse4_1_zero_extendv2siv2di2 = 3904,
CODE_FOR_sse4_1_zero_extendv2siv2di2_mask = 3905,
CODE_FOR_avx_vtestps256 = 3906,
CODE_FOR_avx_vtestps = 3907,
CODE_FOR_avx_vtestpd256 = 3908,
CODE_FOR_avx_vtestpd = 3909,
CODE_FOR_sse4_1_ptestv16qi = 3910,
CODE_FOR_sse4_1_ptestv8hi = 3911,
CODE_FOR_sse4_1_ptestv4si = 3912,
CODE_FOR_sse4_1_ptestv2di = 3913,
CODE_FOR_sse4_1_ptestv4sf = 3914,
CODE_FOR_sse4_1_ptestv2df = 3915,
CODE_FOR_avx_ptestv32qi = 3916,
CODE_FOR_avx_ptestv16hi = 3917,
CODE_FOR_avx_ptestv8si = 3918,
CODE_FOR_avx_ptestv4di = 3919,
CODE_FOR_avx_ptestv8sf = 3920,
CODE_FOR_avx_ptestv4df = 3921,
CODE_FOR_ptesttf2 = 3922,
CODE_FOR_avx_roundps256 = 3923,
CODE_FOR_sse4_1_roundps = 3924,
CODE_FOR_avx_roundpd256 = 3925,
CODE_FOR_sse4_1_roundpd = 3926,
CODE_FOR_sse4_1_roundss = 3927,
CODE_FOR_sse4_1_roundsd = 3928,
CODE_FOR_sse4_2_pcmpestr = 3929,
CODE_FOR_sse4_2_pcmpestri = 3930,
CODE_FOR_sse4_2_pcmpestrm = 3931,
CODE_FOR_sse4_2_pcmpestr_cconly = 3932,
CODE_FOR_sse4_2_pcmpistr = 3933,
CODE_FOR_sse4_2_pcmpistri = 3934,
CODE_FOR_sse4_2_pcmpistrm = 3935,
CODE_FOR_sse4_2_pcmpistr_cconly = 3936,
CODE_FOR_avx512er_exp2v16sf = 3953,
CODE_FOR_avx512er_exp2v16sf_round = 3954,
CODE_FOR_avx512er_exp2v16sf_mask = 3955,
CODE_FOR_avx512er_exp2v16sf_mask_round = 3956,
CODE_FOR_avx512er_exp2v8df = 3957,
CODE_FOR_avx512er_exp2v8df_round = 3958,
CODE_FOR_avx512er_exp2v8df_mask = 3959,
CODE_FOR_avx512er_exp2v8df_mask_round = 3960,
CODE_FOR_avx512er_rcp28v16sf_mask = 3963,
CODE_FOR_avx512er_rcp28v16sf_mask_round = 3964,
CODE_FOR_avx512er_rcp28v8df_mask = 3967,
CODE_FOR_avx512er_rcp28v8df_mask_round = 3968,
CODE_FOR_avx512er_vmrcp28v4sf = 3969,
CODE_FOR_avx512er_vmrcp28v4sf_round = 3970,
CODE_FOR_avx512er_vmrcp28v2df = 3971,
CODE_FOR_avx512er_vmrcp28v2df_round = 3972,
CODE_FOR_avx512er_rsqrt28v16sf_mask = 3975,
CODE_FOR_avx512er_rsqrt28v16sf_mask_round = 3976,
CODE_FOR_avx512er_rsqrt28v8df_mask = 3979,
CODE_FOR_avx512er_rsqrt28v8df_mask_round = 3980,
CODE_FOR_avx512er_vmrsqrt28v4sf = 3981,
CODE_FOR_avx512er_vmrsqrt28v4sf_round = 3982,
CODE_FOR_avx512er_vmrsqrt28v2df = 3983,
CODE_FOR_avx512er_vmrsqrt28v2df_round = 3984,
CODE_FOR_xop_pmacsww = 3985,
CODE_FOR_xop_pmacssww = 3986,
CODE_FOR_xop_pmacsdd = 3987,
CODE_FOR_xop_pmacssdd = 3988,
CODE_FOR_xop_pmacsdql = 3989,
CODE_FOR_xop_pmacssdql = 3990,
CODE_FOR_xop_pmacsdqh = 3991,
CODE_FOR_xop_pmacssdqh = 3992,
CODE_FOR_xop_pmacswd = 3993,
CODE_FOR_xop_pmacsswd = 3994,
CODE_FOR_xop_pmadcswd = 3995,
CODE_FOR_xop_pmadcsswd = 3996,
CODE_FOR_xop_pcmov_v32qi256 = 3997,
CODE_FOR_xop_pcmov_v16qi = 3998,
CODE_FOR_xop_pcmov_v16hi256 = 3999,
CODE_FOR_xop_pcmov_v8hi = 4000,
CODE_FOR_xop_pcmov_v16si512 = 4001,
CODE_FOR_xop_pcmov_v8si256 = 4002,
CODE_FOR_xop_pcmov_v4si = 4003,
CODE_FOR_xop_pcmov_v8di512 = 4004,
CODE_FOR_xop_pcmov_v4di256 = 4005,
CODE_FOR_xop_pcmov_v2di = 4006,
CODE_FOR_xop_pcmov_v16sf512 = 4007,
CODE_FOR_xop_pcmov_v8sf256 = 4008,
CODE_FOR_xop_pcmov_v4sf = 4009,
CODE_FOR_xop_pcmov_v8df512 = 4010,
CODE_FOR_xop_pcmov_v4df256 = 4011,
CODE_FOR_xop_pcmov_v2df = 4012,
CODE_FOR_xop_phaddbw = 4013,
CODE_FOR_xop_phaddubw = 4014,
CODE_FOR_xop_phaddbd = 4015,
CODE_FOR_xop_phaddubd = 4016,
CODE_FOR_xop_phaddbq = 4017,
CODE_FOR_xop_phaddubq = 4018,
CODE_FOR_xop_phaddwd = 4019,
CODE_FOR_xop_phadduwd = 4020,
CODE_FOR_xop_phaddwq = 4021,
CODE_FOR_xop_phadduwq = 4022,
CODE_FOR_xop_phadddq = 4023,
CODE_FOR_xop_phaddudq = 4024,
CODE_FOR_xop_phsubbw = 4025,
CODE_FOR_xop_phsubwd = 4026,
CODE_FOR_xop_phsubdq = 4027,
CODE_FOR_xop_pperm = 4028,
CODE_FOR_xop_pperm_pack_v2di_v4si = 4029,
CODE_FOR_xop_pperm_pack_v4si_v8hi = 4030,
CODE_FOR_xop_pperm_pack_v8hi_v16qi = 4031,
CODE_FOR_xop_rotlv16qi3 = 4032,
CODE_FOR_xop_rotlv8hi3 = 4033,
CODE_FOR_xop_rotlv4si3 = 4034,
CODE_FOR_xop_rotlv2di3 = 4035,
CODE_FOR_xop_rotrv16qi3 = 4036,
CODE_FOR_xop_rotrv8hi3 = 4037,
CODE_FOR_xop_rotrv4si3 = 4038,
CODE_FOR_xop_rotrv2di3 = 4039,
CODE_FOR_xop_vrotlv16qi3 = 4040,
CODE_FOR_xop_vrotlv8hi3 = 4041,
CODE_FOR_xop_vrotlv4si3 = 4042,
CODE_FOR_xop_vrotlv2di3 = 4043,
CODE_FOR_xop_shav16qi3 = 4044,
CODE_FOR_xop_shav8hi3 = 4045,
CODE_FOR_xop_shav4si3 = 4046,
CODE_FOR_xop_shav2di3 = 4047,
CODE_FOR_xop_shlv16qi3 = 4048,
CODE_FOR_xop_shlv8hi3 = 4049,
CODE_FOR_xop_shlv4si3 = 4050,
CODE_FOR_xop_shlv2di3 = 4051,
CODE_FOR_xop_frczsf2 = 4052,
CODE_FOR_xop_frczdf2 = 4053,
CODE_FOR_xop_frczv4sf2 = 4054,
CODE_FOR_xop_frczv2df2 = 4055,
CODE_FOR_xop_frczv8sf2 = 4056,
CODE_FOR_xop_frczv4df2 = 4057,
CODE_FOR_xop_maskcmpv16qi3 = 4060,
CODE_FOR_xop_maskcmpv8hi3 = 4061,
CODE_FOR_xop_maskcmpv4si3 = 4062,
CODE_FOR_xop_maskcmpv2di3 = 4063,
CODE_FOR_xop_maskcmp_unsv16qi3 = 4064,
CODE_FOR_xop_maskcmp_unsv8hi3 = 4065,
CODE_FOR_xop_maskcmp_unsv4si3 = 4066,
CODE_FOR_xop_maskcmp_unsv2di3 = 4067,
CODE_FOR_xop_maskcmp_uns2v16qi3 = 4068,
CODE_FOR_xop_maskcmp_uns2v8hi3 = 4069,
CODE_FOR_xop_maskcmp_uns2v4si3 = 4070,
CODE_FOR_xop_maskcmp_uns2v2di3 = 4071,
CODE_FOR_xop_pcom_tfv16qi3 = 4072,
CODE_FOR_xop_pcom_tfv8hi3 = 4073,
CODE_FOR_xop_pcom_tfv4si3 = 4074,
CODE_FOR_xop_pcom_tfv2di3 = 4075,
CODE_FOR_xop_vpermil2v8sf3 = 4076,
CODE_FOR_xop_vpermil2v4sf3 = 4077,
CODE_FOR_xop_vpermil2v4df3 = 4078,
CODE_FOR_xop_vpermil2v2df3 = 4079,
CODE_FOR_aesenc = 4080,
CODE_FOR_aesenclast = 4081,
CODE_FOR_aesdec = 4082,
CODE_FOR_aesdeclast = 4083,
CODE_FOR_aesimc = 4084,
CODE_FOR_aeskeygenassist = 4085,
CODE_FOR_pclmulqdq = 4086,
CODE_FOR_avx_vzeroupper = 4088,
CODE_FOR_avx2_pbroadcastv16si = 4089,
CODE_FOR_avx2_pbroadcastv8di = 4090,
CODE_FOR_avx2_pbroadcastv64qi = 4091,
CODE_FOR_avx2_pbroadcastv32qi = 4092,
CODE_FOR_avx2_pbroadcastv16qi = 4093,
CODE_FOR_avx2_pbroadcastv32hi = 4094,
CODE_FOR_avx2_pbroadcastv16hi = 4095,
CODE_FOR_avx2_pbroadcastv8hi = 4096,
CODE_FOR_avx2_pbroadcastv8si = 4097,
CODE_FOR_avx2_pbroadcastv4si = 4098,
CODE_FOR_avx2_pbroadcastv4di = 4099,
CODE_FOR_avx2_pbroadcastv2di = 4100,
CODE_FOR_avx2_pbroadcastv32qi_1 = 4101,
CODE_FOR_avx2_pbroadcastv16hi_1 = 4102,
CODE_FOR_avx2_pbroadcastv8si_1 = 4103,
CODE_FOR_avx2_pbroadcastv4di_1 = 4104,
CODE_FOR_avx2_permvarv8si = 4105,
CODE_FOR_avx2_permvarv8si_mask = 4106,
CODE_FOR_avx2_permvarv8sf = 4107,
CODE_FOR_avx2_permvarv8sf_mask = 4108,
CODE_FOR_avx512f_permvarv16si = 4109,
CODE_FOR_avx512f_permvarv16si_mask = 4110,
CODE_FOR_avx512f_permvarv16sf = 4111,
CODE_FOR_avx512f_permvarv16sf_mask = 4112,
CODE_FOR_avx512f_permvarv8di = 4113,
CODE_FOR_avx512f_permvarv8di_mask = 4114,
CODE_FOR_avx512f_permvarv8df = 4115,
CODE_FOR_avx512f_permvarv8df_mask = 4116,
CODE_FOR_avx2_permvarv4di = 4117,
CODE_FOR_avx2_permvarv4di_mask = 4118,
CODE_FOR_avx2_permvarv4df = 4119,
CODE_FOR_avx2_permvarv4df_mask = 4120,
CODE_FOR_avx512bw_permvarv64qi = 4121,
CODE_FOR_avx512bw_permvarv64qi_mask = 4122,
CODE_FOR_avx512vl_permvarv16qi = 4123,
CODE_FOR_avx512vl_permvarv16qi_mask = 4124,
CODE_FOR_avx512vl_permvarv32qi = 4125,
CODE_FOR_avx512vl_permvarv32qi_mask = 4126,
CODE_FOR_avx512vl_permvarv8hi = 4127,
CODE_FOR_avx512vl_permvarv8hi_mask = 4128,
CODE_FOR_avx512vl_permvarv16hi = 4129,
CODE_FOR_avx512vl_permvarv16hi_mask = 4130,
CODE_FOR_avx512bw_permvarv32hi = 4131,
CODE_FOR_avx512bw_permvarv32hi_mask = 4132,
CODE_FOR_avx2_permv4di_1 = 4133,
CODE_FOR_avx2_permv4di_1_mask = 4134,
CODE_FOR_avx2_permv4df_1 = 4135,
CODE_FOR_avx2_permv4df_1_mask = 4136,
CODE_FOR_avx512f_permv8df_1 = 4137,
CODE_FOR_avx512f_permv8df_1_mask = 4138,
CODE_FOR_avx512f_permv8di_1 = 4139,
CODE_FOR_avx512f_permv8di_1_mask = 4140,
CODE_FOR_avx2_permv2ti = 4141,
CODE_FOR_avx2_vec_dupv4df = 4142,
CODE_FOR_avx512f_vec_dupv16si_1 = 4143,
CODE_FOR_avx512f_vec_dupv8di_1 = 4144,
CODE_FOR_avx512bw_vec_dupv32hi_1 = 4145,
CODE_FOR_avx512bw_vec_dupv64qi_1 = 4146,
CODE_FOR_avx512f_vec_dupv16si = 4147,
CODE_FOR_avx512f_vec_dupv16si_mask = 4148,
CODE_FOR_avx512vl_vec_dupv8si = 4149,
CODE_FOR_avx512vl_vec_dupv8si_mask = 4150,
CODE_FOR_avx512vl_vec_dupv4si = 4151,
CODE_FOR_avx512vl_vec_dupv4si_mask = 4152,
CODE_FOR_avx512f_vec_dupv8di = 4153,
CODE_FOR_avx512f_vec_dupv8di_mask = 4154,
CODE_FOR_avx512vl_vec_dupv4di = 4155,
CODE_FOR_avx512vl_vec_dupv4di_mask = 4156,
CODE_FOR_avx512vl_vec_dupv2di = 4157,
CODE_FOR_avx512vl_vec_dupv2di_mask = 4158,
CODE_FOR_avx512f_vec_dupv16sf = 4159,
CODE_FOR_avx512f_vec_dupv16sf_mask = 4160,
CODE_FOR_avx512vl_vec_dupv8sf = 4161,
CODE_FOR_avx512vl_vec_dupv8sf_mask = 4162,
CODE_FOR_avx512vl_vec_dupv4sf = 4163,
CODE_FOR_avx512vl_vec_dupv4sf_mask = 4164,
CODE_FOR_avx512f_vec_dupv8df = 4165,
CODE_FOR_avx512f_vec_dupv8df_mask = 4166,
CODE_FOR_avx512vl_vec_dupv4df = 4167,
CODE_FOR_avx512vl_vec_dupv4df_mask = 4168,
CODE_FOR_avx512vl_vec_dupv2df = 4169,
CODE_FOR_avx512vl_vec_dupv2df_mask = 4170,
CODE_FOR_avx512bw_vec_dupv64qi = 4171,
CODE_FOR_avx512bw_vec_dupv64qi_mask = 4172,
CODE_FOR_avx512vl_vec_dupv16qi = 4173,
CODE_FOR_avx512vl_vec_dupv16qi_mask = 4174,
CODE_FOR_avx512vl_vec_dupv32qi = 4175,
CODE_FOR_avx512vl_vec_dupv32qi_mask = 4176,
CODE_FOR_avx512bw_vec_dupv32hi = 4177,
CODE_FOR_avx512bw_vec_dupv32hi_mask = 4178,
CODE_FOR_avx512vl_vec_dupv16hi = 4179,
CODE_FOR_avx512vl_vec_dupv16hi_mask = 4180,
CODE_FOR_avx512vl_vec_dupv8hi = 4181,
CODE_FOR_avx512vl_vec_dupv8hi_mask = 4182,
CODE_FOR_avx512f_broadcastv16sf_mask = 4184,
CODE_FOR_avx512f_broadcastv16si_mask = 4186,
CODE_FOR_avx512f_broadcastv8df_mask = 4188,
CODE_FOR_avx512f_broadcastv8di_mask = 4190,
CODE_FOR_avx512bw_vec_dup_gprv64qi_mask = 4192,
CODE_FOR_avx512vl_vec_dup_gprv16qi_mask = 4194,
CODE_FOR_avx512vl_vec_dup_gprv32qi_mask = 4196,
CODE_FOR_avx512bw_vec_dup_gprv32hi_mask = 4198,
CODE_FOR_avx512vl_vec_dup_gprv16hi_mask = 4200,
CODE_FOR_avx512vl_vec_dup_gprv8hi_mask = 4202,
CODE_FOR_avx512f_vec_dup_gprv16si_mask = 4204,
CODE_FOR_avx512vl_vec_dup_gprv8si_mask = 4206,
CODE_FOR_avx512vl_vec_dup_gprv4si_mask = 4208,
CODE_FOR_avx512f_vec_dup_gprv8di_mask = 4210,
CODE_FOR_avx512vl_vec_dup_gprv4di_mask = 4212,
CODE_FOR_avx512vl_vec_dup_gprv2di_mask = 4214,
CODE_FOR_avx512f_vec_dup_gprv16sf_mask = 4216,
CODE_FOR_avx512vl_vec_dup_gprv8sf_mask = 4218,
CODE_FOR_avx512vl_vec_dup_gprv4sf_mask = 4220,
CODE_FOR_avx512f_vec_dup_gprv8df_mask = 4222,
CODE_FOR_avx512vl_vec_dup_gprv4df_mask = 4224,
CODE_FOR_avx512vl_vec_dup_gprv2df_mask = 4226,
CODE_FOR_vec_dupv4sf = 4227,
CODE_FOR_avx2_vbroadcasti128_v32qi = 4230,
CODE_FOR_avx2_vbroadcasti128_v16hi = 4231,
CODE_FOR_avx2_vbroadcasti128_v8si = 4232,
CODE_FOR_avx2_vbroadcasti128_v4di = 4233,
CODE_FOR_vec_dupv8si = 4240,
CODE_FOR_vec_dupv8sf = 4241,
CODE_FOR_vec_dupv4di = 4242,
CODE_FOR_vec_dupv4df = 4243,
CODE_FOR_avx_vbroadcastf128_v32qi = 4244,
CODE_FOR_avx_vbroadcastf128_v16hi = 4245,
CODE_FOR_avx_vbroadcastf128_v8si = 4246,
CODE_FOR_avx_vbroadcastf128_v4di = 4247,
CODE_FOR_avx_vbroadcastf128_v8sf = 4248,
CODE_FOR_avx_vbroadcastf128_v4df = 4249,
CODE_FOR_avx512dq_broadcastv16si_mask = 4251,
CODE_FOR_avx512dq_broadcastv8si_mask = 4253,
CODE_FOR_avx512dq_broadcastv4si_mask = 4255,
CODE_FOR_avx512dq_broadcastv16sf_mask = 4257,
CODE_FOR_avx512dq_broadcastv8sf_mask = 4259,
CODE_FOR_avx512vl_broadcastv8si_mask_1 = 4261,
CODE_FOR_avx512vl_broadcastv8sf_mask_1 = 4263,
CODE_FOR_avx512dq_broadcastv16sf_mask_1 = 4265,
CODE_FOR_avx512dq_broadcastv16si_mask_1 = 4267,
CODE_FOR_avx512dq_broadcastv8di_mask_1 = 4269,
CODE_FOR_avx512dq_broadcastv8df_mask_1 = 4271,
CODE_FOR_avx512dq_broadcastv4di_mask_1 = 4273,
CODE_FOR_avx512dq_broadcastv4df_mask_1 = 4275,
CODE_FOR_avx512cd_maskb_vec_dupv8di = 4276,
CODE_FOR_avx512cd_maskb_vec_dupv4di = 4277,
CODE_FOR_avx512cd_maskb_vec_dupv2di = 4278,
CODE_FOR_avx512cd_maskw_vec_dupv16si = 4279,
CODE_FOR_avx512cd_maskw_vec_dupv8si = 4280,
CODE_FOR_avx512cd_maskw_vec_dupv4si = 4281,
CODE_FOR_avx512f_vpermilvarv16sf3 = 4297,
CODE_FOR_avx512f_vpermilvarv16sf3_mask = 4298,
CODE_FOR_avx_vpermilvarv8sf3 = 4299,
CODE_FOR_avx_vpermilvarv8sf3_mask = 4300,
CODE_FOR_avx_vpermilvarv4sf3 = 4301,
CODE_FOR_avx_vpermilvarv4sf3_mask = 4302,
CODE_FOR_avx512f_vpermilvarv8df3 = 4303,
CODE_FOR_avx512f_vpermilvarv8df3_mask = 4304,
CODE_FOR_avx_vpermilvarv4df3 = 4305,
CODE_FOR_avx_vpermilvarv4df3_mask = 4306,
CODE_FOR_avx_vpermilvarv2df3 = 4307,
CODE_FOR_avx_vpermilvarv2df3_mask = 4308,
CODE_FOR_avx512f_vpermi2varv16si3 = 4309,
CODE_FOR_avx512f_vpermi2varv16si3_maskz_1 = 4310,
CODE_FOR_avx512f_vpermi2varv16sf3 = 4311,
CODE_FOR_avx512f_vpermi2varv16sf3_maskz_1 = 4312,
CODE_FOR_avx512f_vpermi2varv8di3 = 4313,
CODE_FOR_avx512f_vpermi2varv8di3_maskz_1 = 4314,
CODE_FOR_avx512f_vpermi2varv8df3 = 4315,
CODE_FOR_avx512f_vpermi2varv8df3_maskz_1 = 4316,
CODE_FOR_avx512vl_vpermi2varv8si3 = 4317,
CODE_FOR_avx512vl_vpermi2varv8si3_maskz_1 = 4318,
CODE_FOR_avx512vl_vpermi2varv8sf3 = 4319,
CODE_FOR_avx512vl_vpermi2varv8sf3_maskz_1 = 4320,
CODE_FOR_avx512vl_vpermi2varv4di3 = 4321,
CODE_FOR_avx512vl_vpermi2varv4di3_maskz_1 = 4322,
CODE_FOR_avx512vl_vpermi2varv4df3 = 4323,
CODE_FOR_avx512vl_vpermi2varv4df3_maskz_1 = 4324,
CODE_FOR_avx512vl_vpermi2varv4si3 = 4325,
CODE_FOR_avx512vl_vpermi2varv4si3_maskz_1 = 4326,
CODE_FOR_avx512vl_vpermi2varv4sf3 = 4327,
CODE_FOR_avx512vl_vpermi2varv4sf3_maskz_1 = 4328,
CODE_FOR_avx512vl_vpermi2varv2di3 = 4329,
CODE_FOR_avx512vl_vpermi2varv2di3_maskz_1 = 4330,
CODE_FOR_avx512vl_vpermi2varv2df3 = 4331,
CODE_FOR_avx512vl_vpermi2varv2df3_maskz_1 = 4332,
CODE_FOR_avx512bw_vpermi2varv64qi3 = 4333,
CODE_FOR_avx512bw_vpermi2varv64qi3_maskz_1 = 4334,
CODE_FOR_avx512vl_vpermi2varv16qi3 = 4335,
CODE_FOR_avx512vl_vpermi2varv16qi3_maskz_1 = 4336,
CODE_FOR_avx512vl_vpermi2varv32qi3 = 4337,
CODE_FOR_avx512vl_vpermi2varv32qi3_maskz_1 = 4338,
CODE_FOR_avx512vl_vpermi2varv8hi3 = 4339,
CODE_FOR_avx512vl_vpermi2varv8hi3_maskz_1 = 4340,
CODE_FOR_avx512vl_vpermi2varv16hi3 = 4341,
CODE_FOR_avx512vl_vpermi2varv16hi3_maskz_1 = 4342,
CODE_FOR_avx512bw_vpermi2varv32hi3 = 4343,
CODE_FOR_avx512bw_vpermi2varv32hi3_maskz_1 = 4344,
CODE_FOR_avx512f_vpermi2varv16si3_mask = 4345,
CODE_FOR_avx512f_vpermi2varv16sf3_mask = 4346,
CODE_FOR_avx512f_vpermi2varv8di3_mask = 4347,
CODE_FOR_avx512f_vpermi2varv8df3_mask = 4348,
CODE_FOR_avx512vl_vpermi2varv8si3_mask = 4349,
CODE_FOR_avx512vl_vpermi2varv8sf3_mask = 4350,
CODE_FOR_avx512vl_vpermi2varv4di3_mask = 4351,
CODE_FOR_avx512vl_vpermi2varv4df3_mask = 4352,
CODE_FOR_avx512vl_vpermi2varv4si3_mask = 4353,
CODE_FOR_avx512vl_vpermi2varv4sf3_mask = 4354,
CODE_FOR_avx512vl_vpermi2varv2di3_mask = 4355,
CODE_FOR_avx512vl_vpermi2varv2df3_mask = 4356,
CODE_FOR_avx512bw_vpermi2varv64qi3_mask = 4357,
CODE_FOR_avx512vl_vpermi2varv16qi3_mask = 4358,
CODE_FOR_avx512vl_vpermi2varv32qi3_mask = 4359,
CODE_FOR_avx512vl_vpermi2varv8hi3_mask = 4360,
CODE_FOR_avx512vl_vpermi2varv16hi3_mask = 4361,
CODE_FOR_avx512bw_vpermi2varv32hi3_mask = 4362,
CODE_FOR_avx512f_vpermt2varv16si3 = 4363,
CODE_FOR_avx512f_vpermt2varv16si3_maskz_1 = 4364,
CODE_FOR_avx512f_vpermt2varv16sf3 = 4365,
CODE_FOR_avx512f_vpermt2varv16sf3_maskz_1 = 4366,
CODE_FOR_avx512f_vpermt2varv8di3 = 4367,
CODE_FOR_avx512f_vpermt2varv8di3_maskz_1 = 4368,
CODE_FOR_avx512f_vpermt2varv8df3 = 4369,
CODE_FOR_avx512f_vpermt2varv8df3_maskz_1 = 4370,
CODE_FOR_avx512vl_vpermt2varv8si3 = 4371,
CODE_FOR_avx512vl_vpermt2varv8si3_maskz_1 = 4372,
CODE_FOR_avx512vl_vpermt2varv8sf3 = 4373,
CODE_FOR_avx512vl_vpermt2varv8sf3_maskz_1 = 4374,
CODE_FOR_avx512vl_vpermt2varv4di3 = 4375,
CODE_FOR_avx512vl_vpermt2varv4di3_maskz_1 = 4376,
CODE_FOR_avx512vl_vpermt2varv4df3 = 4377,
CODE_FOR_avx512vl_vpermt2varv4df3_maskz_1 = 4378,
CODE_FOR_avx512vl_vpermt2varv4si3 = 4379,
CODE_FOR_avx512vl_vpermt2varv4si3_maskz_1 = 4380,
CODE_FOR_avx512vl_vpermt2varv4sf3 = 4381,
CODE_FOR_avx512vl_vpermt2varv4sf3_maskz_1 = 4382,
CODE_FOR_avx512vl_vpermt2varv2di3 = 4383,
CODE_FOR_avx512vl_vpermt2varv2di3_maskz_1 = 4384,
CODE_FOR_avx512vl_vpermt2varv2df3 = 4385,
CODE_FOR_avx512vl_vpermt2varv2df3_maskz_1 = 4386,
CODE_FOR_avx512bw_vpermt2varv64qi3 = 4387,
CODE_FOR_avx512bw_vpermt2varv64qi3_maskz_1 = 4388,
CODE_FOR_avx512vl_vpermt2varv16qi3 = 4389,
CODE_FOR_avx512vl_vpermt2varv16qi3_maskz_1 = 4390,
CODE_FOR_avx512vl_vpermt2varv32qi3 = 4391,
CODE_FOR_avx512vl_vpermt2varv32qi3_maskz_1 = 4392,
CODE_FOR_avx512vl_vpermt2varv8hi3 = 4393,
CODE_FOR_avx512vl_vpermt2varv8hi3_maskz_1 = 4394,
CODE_FOR_avx512vl_vpermt2varv16hi3 = 4395,
CODE_FOR_avx512vl_vpermt2varv16hi3_maskz_1 = 4396,
CODE_FOR_avx512bw_vpermt2varv32hi3 = 4397,
CODE_FOR_avx512bw_vpermt2varv32hi3_maskz_1 = 4398,
CODE_FOR_avx512f_vpermt2varv16si3_mask = 4399,
CODE_FOR_avx512f_vpermt2varv16sf3_mask = 4400,
CODE_FOR_avx512f_vpermt2varv8di3_mask = 4401,
CODE_FOR_avx512f_vpermt2varv8df3_mask = 4402,
CODE_FOR_avx512vl_vpermt2varv8si3_mask = 4403,
CODE_FOR_avx512vl_vpermt2varv8sf3_mask = 4404,
CODE_FOR_avx512vl_vpermt2varv4di3_mask = 4405,
CODE_FOR_avx512vl_vpermt2varv4df3_mask = 4406,
CODE_FOR_avx512vl_vpermt2varv4si3_mask = 4407,
CODE_FOR_avx512vl_vpermt2varv4sf3_mask = 4408,
CODE_FOR_avx512vl_vpermt2varv2di3_mask = 4409,
CODE_FOR_avx512vl_vpermt2varv2df3_mask = 4410,
CODE_FOR_avx512bw_vpermt2varv64qi3_mask = 4411,
CODE_FOR_avx512vl_vpermt2varv16qi3_mask = 4412,
CODE_FOR_avx512vl_vpermt2varv32qi3_mask = 4413,
CODE_FOR_avx512vl_vpermt2varv8hi3_mask = 4414,
CODE_FOR_avx512vl_vpermt2varv16hi3_mask = 4415,
CODE_FOR_avx512bw_vpermt2varv32hi3_mask = 4416,
CODE_FOR_vec_set_lo_v4di = 4429,
CODE_FOR_vec_set_lo_v4di_mask = 4430,
CODE_FOR_vec_set_lo_v4df = 4431,
CODE_FOR_vec_set_lo_v4df_mask = 4432,
CODE_FOR_vec_set_hi_v4di = 4433,
CODE_FOR_vec_set_hi_v4di_mask = 4434,
CODE_FOR_vec_set_hi_v4df = 4435,
CODE_FOR_vec_set_hi_v4df_mask = 4436,
CODE_FOR_vec_set_lo_v8si = 4437,
CODE_FOR_vec_set_lo_v8si_mask = 4438,
CODE_FOR_vec_set_lo_v8sf = 4439,
CODE_FOR_vec_set_lo_v8sf_mask = 4440,
CODE_FOR_vec_set_hi_v8si = 4441,
CODE_FOR_vec_set_hi_v8si_mask = 4442,
CODE_FOR_vec_set_hi_v8sf = 4443,
CODE_FOR_vec_set_hi_v8sf_mask = 4444,
CODE_FOR_vec_set_lo_v16hi = 4445,
CODE_FOR_vec_set_hi_v16hi = 4446,
CODE_FOR_vec_set_lo_v32qi = 4447,
CODE_FOR_vec_set_hi_v32qi = 4448,
CODE_FOR_avx_maskloadps = 4449,
CODE_FOR_avx_maskloadpd = 4450,
CODE_FOR_avx_maskloadps256 = 4451,
CODE_FOR_avx_maskloadpd256 = 4452,
CODE_FOR_avx2_maskloadd = 4453,
CODE_FOR_avx2_maskloadq = 4454,
CODE_FOR_avx2_maskloadd256 = 4455,
CODE_FOR_avx2_maskloadq256 = 4456,
CODE_FOR_avx_maskstoreps = 4457,
CODE_FOR_avx_maskstorepd = 4458,
CODE_FOR_avx_maskstoreps256 = 4459,
CODE_FOR_avx_maskstorepd256 = 4460,
CODE_FOR_avx2_maskstored = 4461,
CODE_FOR_avx2_maskstoreq = 4462,
CODE_FOR_avx2_maskstored256 = 4463,
CODE_FOR_avx2_maskstoreq256 = 4464,
CODE_FOR_avx_si256_si = 4465,
CODE_FOR_avx_ps256_ps = 4466,
CODE_FOR_avx_pd256_pd = 4467,
CODE_FOR_avx2_ashrvv4si = 4468,
CODE_FOR_avx2_ashrvv4si_mask = 4469,
CODE_FOR_avx2_ashrvv8si = 4470,
CODE_FOR_avx2_ashrvv8si_mask = 4471,
CODE_FOR_avx512f_ashrvv16si = 4472,
CODE_FOR_avx512f_ashrvv16si_mask = 4473,
CODE_FOR_avx2_ashrvv2di = 4474,
CODE_FOR_avx2_ashrvv2di_mask = 4475,
CODE_FOR_avx2_ashrvv4di = 4476,
CODE_FOR_avx2_ashrvv4di_mask = 4477,
CODE_FOR_avx512f_ashrvv8di = 4478,
CODE_FOR_avx512f_ashrvv8di_mask = 4479,
CODE_FOR_avx512vl_ashrvv8hi = 4480,
CODE_FOR_avx512vl_ashrvv8hi_mask = 4481,
CODE_FOR_avx512vl_ashrvv16hi = 4482,
CODE_FOR_avx512vl_ashrvv16hi_mask = 4483,
CODE_FOR_avx512bw_ashrvv32hi = 4484,
CODE_FOR_avx512bw_ashrvv32hi_mask = 4485,
CODE_FOR_avx512f_ashlvv16si = 4486,
CODE_FOR_avx512f_ashlvv16si_mask = 4487,
CODE_FOR_avx512f_lshrvv16si = 4488,
CODE_FOR_avx512f_lshrvv16si_mask = 4489,
CODE_FOR_avx2_ashlvv8si = 4490,
CODE_FOR_avx2_ashlvv8si_mask = 4491,
CODE_FOR_avx2_lshrvv8si = 4492,
CODE_FOR_avx2_lshrvv8si_mask = 4493,
CODE_FOR_avx2_ashlvv4si = 4494,
CODE_FOR_avx2_ashlvv4si_mask = 4495,
CODE_FOR_avx2_lshrvv4si = 4496,
CODE_FOR_avx2_lshrvv4si_mask = 4497,
CODE_FOR_avx512f_ashlvv8di = 4498,
CODE_FOR_avx512f_ashlvv8di_mask = 4499,
CODE_FOR_avx512f_lshrvv8di = 4500,
CODE_FOR_avx512f_lshrvv8di_mask = 4501,
CODE_FOR_avx2_ashlvv4di = 4502,
CODE_FOR_avx2_ashlvv4di_mask = 4503,
CODE_FOR_avx2_lshrvv4di = 4504,
CODE_FOR_avx2_lshrvv4di_mask = 4505,
CODE_FOR_avx2_ashlvv2di = 4506,
CODE_FOR_avx2_ashlvv2di_mask = 4507,
CODE_FOR_avx2_lshrvv2di = 4508,
CODE_FOR_avx2_lshrvv2di_mask = 4509,
CODE_FOR_avx512vl_ashlvv8hi = 4510,
CODE_FOR_avx512vl_ashlvv8hi_mask = 4511,
CODE_FOR_avx512vl_lshrvv8hi = 4512,
CODE_FOR_avx512vl_lshrvv8hi_mask = 4513,
CODE_FOR_avx512vl_ashlvv16hi = 4514,
CODE_FOR_avx512vl_ashlvv16hi_mask = 4515,
CODE_FOR_avx512vl_lshrvv16hi = 4516,
CODE_FOR_avx512vl_lshrvv16hi_mask = 4517,
CODE_FOR_avx512bw_ashlvv32hi = 4518,
CODE_FOR_avx512bw_ashlvv32hi_mask = 4519,
CODE_FOR_avx512bw_lshrvv32hi = 4520,
CODE_FOR_avx512bw_lshrvv32hi_mask = 4521,
CODE_FOR_avx_vec_concatv32qi = 4522,
CODE_FOR_avx_vec_concatv16hi = 4523,
CODE_FOR_avx_vec_concatv8si = 4524,
CODE_FOR_avx_vec_concatv4di = 4525,
CODE_FOR_avx_vec_concatv8sf = 4526,
CODE_FOR_avx_vec_concatv4df = 4527,
CODE_FOR_avx_vec_concatv64qi = 4528,
CODE_FOR_avx_vec_concatv32hi = 4529,
CODE_FOR_avx_vec_concatv16si = 4530,
CODE_FOR_avx_vec_concatv8di = 4531,
CODE_FOR_avx_vec_concatv16sf = 4532,
CODE_FOR_avx_vec_concatv8df = 4533,
CODE_FOR_vcvtph2ps = 4534,
CODE_FOR_vcvtph2ps_mask = 4535,
CODE_FOR_vcvtph2ps256 = 4538,
CODE_FOR_vcvtph2ps256_mask = 4539,
CODE_FOR_avx512f_vcvtph2ps512_mask = 4542,
CODE_FOR_avx512f_vcvtph2ps512_mask_round = 4543,
CODE_FOR_vcvtps2ph256 = 4547,
CODE_FOR_vcvtps2ph256_mask = 4548,
CODE_FOR_avx512f_vcvtps2ph512_mask = 4550,
CODE_FOR_avx512f_compressv16si_mask = 4767,
CODE_FOR_avx512f_compressv16sf_mask = 4768,
CODE_FOR_avx512f_compressv8di_mask = 4769,
CODE_FOR_avx512f_compressv8df_mask = 4770,
CODE_FOR_avx512vl_compressv8si_mask = 4771,
CODE_FOR_avx512vl_compressv8sf_mask = 4772,
CODE_FOR_avx512vl_compressv4di_mask = 4773,
CODE_FOR_avx512vl_compressv4df_mask = 4774,
CODE_FOR_avx512vl_compressv4si_mask = 4775,
CODE_FOR_avx512vl_compressv4sf_mask = 4776,
CODE_FOR_avx512vl_compressv2di_mask = 4777,
CODE_FOR_avx512vl_compressv2df_mask = 4778,
CODE_FOR_avx512f_compressstorev16si_mask = 4779,
CODE_FOR_avx512f_compressstorev16sf_mask = 4780,
CODE_FOR_avx512f_compressstorev8di_mask = 4781,
CODE_FOR_avx512f_compressstorev8df_mask = 4782,
CODE_FOR_avx512vl_compressstorev8si_mask = 4783,
CODE_FOR_avx512vl_compressstorev8sf_mask = 4784,
CODE_FOR_avx512vl_compressstorev4di_mask = 4785,
CODE_FOR_avx512vl_compressstorev4df_mask = 4786,
CODE_FOR_avx512vl_compressstorev4si_mask = 4787,
CODE_FOR_avx512vl_compressstorev4sf_mask = 4788,
CODE_FOR_avx512vl_compressstorev2di_mask = 4789,
CODE_FOR_avx512vl_compressstorev2df_mask = 4790,
CODE_FOR_avx512f_expandv16si_mask = 4791,
CODE_FOR_avx512f_expandv16sf_mask = 4792,
CODE_FOR_avx512f_expandv8di_mask = 4793,
CODE_FOR_avx512f_expandv8df_mask = 4794,
CODE_FOR_avx512vl_expandv8si_mask = 4795,
CODE_FOR_avx512vl_expandv8sf_mask = 4796,
CODE_FOR_avx512vl_expandv4di_mask = 4797,
CODE_FOR_avx512vl_expandv4df_mask = 4798,
CODE_FOR_avx512vl_expandv4si_mask = 4799,
CODE_FOR_avx512vl_expandv4sf_mask = 4800,
CODE_FOR_avx512vl_expandv2di_mask = 4801,
CODE_FOR_avx512vl_expandv2df_mask = 4802,
CODE_FOR_avx512dq_rangepv16sf = 4803,
CODE_FOR_avx512dq_rangepv16sf_round = 4804,
CODE_FOR_avx512dq_rangepv16sf_mask = 4805,
CODE_FOR_avx512dq_rangepv16sf_mask_round = 4806,
CODE_FOR_avx512dq_rangepv8sf = 4807,
CODE_FOR_avx512dq_rangepv8sf_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv8sf_mask = 4808,
CODE_FOR_avx512dq_rangepv8sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv4sf = 4809,
CODE_FOR_avx512dq_rangepv4sf_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv4sf_mask = 4810,
CODE_FOR_avx512dq_rangepv4sf_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv8df = 4811,
CODE_FOR_avx512dq_rangepv8df_round = 4812,
CODE_FOR_avx512dq_rangepv8df_mask = 4813,
CODE_FOR_avx512dq_rangepv8df_mask_round = 4814,
CODE_FOR_avx512dq_rangepv4df = 4815,
CODE_FOR_avx512dq_rangepv4df_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv4df_mask = 4816,
CODE_FOR_avx512dq_rangepv4df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv2df = 4817,
CODE_FOR_avx512dq_rangepv2df_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangepv2df_mask = 4818,
CODE_FOR_avx512dq_rangepv2df_mask_round = CODE_FOR_nothing,
CODE_FOR_avx512dq_rangesv4sf = 4819,
CODE_FOR_avx512dq_rangesv4sf_round = 4820,
CODE_FOR_avx512dq_rangesv2df = 4821,
CODE_FOR_avx512dq_rangesv2df_round = 4822,
CODE_FOR_avx512dq_fpclassv16sf = 4823,
CODE_FOR_avx512dq_fpclassv16sf_mask = 4824,
CODE_FOR_avx512dq_fpclassv8sf = 4825,
CODE_FOR_avx512dq_fpclassv8sf_mask = 4826,
CODE_FOR_avx512dq_fpclassv4sf = 4827,
CODE_FOR_avx512dq_fpclassv4sf_mask = 4828,
CODE_FOR_avx512dq_fpclassv8df = 4829,
CODE_FOR_avx512dq_fpclassv8df_mask = 4830,
CODE_FOR_avx512dq_fpclassv4df = 4831,
CODE_FOR_avx512dq_fpclassv4df_mask = 4832,
CODE_FOR_avx512dq_fpclassv2df = 4833,
CODE_FOR_avx512dq_fpclassv2df_mask = 4834,
CODE_FOR_avx512dq_vmfpclassv4sf = 4835,
CODE_FOR_avx512dq_vmfpclassv2df = 4836,
CODE_FOR_avx512f_getmantv16sf = 4837,
CODE_FOR_avx512f_getmantv16sf_round = 4838,
CODE_FOR_avx512f_getmantv16sf_mask = 4839,
CODE_FOR_avx512f_getmantv16sf_mask_round = 4840,
CODE_FOR_avx512vl_getmantv8sf = 4841,
CODE_FOR_avx512vl_getmantv8sf_round = 4842,
CODE_FOR_avx512vl_getmantv8sf_mask = 4843,
CODE_FOR_avx512vl_getmantv8sf_mask_round = 4844,
CODE_FOR_avx512vl_getmantv4sf = 4845,
CODE_FOR_avx512vl_getmantv4sf_round = 4846,
CODE_FOR_avx512vl_getmantv4sf_mask = 4847,
CODE_FOR_avx512vl_getmantv4sf_mask_round = 4848,
CODE_FOR_avx512f_getmantv8df = 4849,
CODE_FOR_avx512f_getmantv8df_round = 4850,
CODE_FOR_avx512f_getmantv8df_mask = 4851,
CODE_FOR_avx512f_getmantv8df_mask_round = 4852,
CODE_FOR_avx512vl_getmantv4df = 4853,
CODE_FOR_avx512vl_getmantv4df_round = 4854,
CODE_FOR_avx512vl_getmantv4df_mask = 4855,
CODE_FOR_avx512vl_getmantv4df_mask_round = 4856,
CODE_FOR_avx512vl_getmantv2df = 4857,
CODE_FOR_avx512vl_getmantv2df_round = 4858,
CODE_FOR_avx512vl_getmantv2df_mask = 4859,
CODE_FOR_avx512vl_getmantv2df_mask_round = 4860,
CODE_FOR_avx512f_vgetmantv4sf = 4861,
CODE_FOR_avx512f_vgetmantv4sf_round = 4862,
CODE_FOR_avx512f_vgetmantv2df = 4863,
CODE_FOR_avx512f_vgetmantv2df_round = 4864,
CODE_FOR_avx512bw_dbpsadbwv8hi_mask = 4866,
CODE_FOR_avx512bw_dbpsadbwv16hi_mask = 4868,
CODE_FOR_avx512bw_dbpsadbwv32hi_mask = 4870,
CODE_FOR_clzv16si2 = 4871,
CODE_FOR_clzv16si2_mask = 4872,
CODE_FOR_clzv8si2 = 4873,
CODE_FOR_clzv8si2_mask = 4874,
CODE_FOR_clzv4si2 = 4875,
CODE_FOR_clzv4si2_mask = 4876,
CODE_FOR_clzv8di2 = 4877,
CODE_FOR_clzv8di2_mask = 4878,
CODE_FOR_clzv4di2 = 4879,
CODE_FOR_clzv4di2_mask = 4880,
CODE_FOR_clzv2di2 = 4881,
CODE_FOR_clzv2di2_mask = 4882,
CODE_FOR_conflictv16si_mask = 4884,
CODE_FOR_conflictv8si_mask = 4886,
CODE_FOR_conflictv4si_mask = 4888,
CODE_FOR_conflictv8di_mask = 4890,
CODE_FOR_conflictv4di_mask = 4892,
CODE_FOR_conflictv2di_mask = 4894,
CODE_FOR_sha1msg1 = 4895,
CODE_FOR_sha1msg2 = 4896,
CODE_FOR_sha1nexte = 4897,
CODE_FOR_sha1rnds4 = 4898,
CODE_FOR_sha256msg1 = 4899,
CODE_FOR_sha256msg2 = 4900,
CODE_FOR_sha256rnds2 = 4901,
CODE_FOR_avx512f_si512_si = 4902,
CODE_FOR_avx512f_ps512_ps = 4903,
CODE_FOR_avx512f_pd512_pd = 4904,
CODE_FOR_avx512f_si512_256si = 4905,
CODE_FOR_avx512f_ps512_256ps = 4906,
CODE_FOR_avx512f_pd512_256pd = 4907,
CODE_FOR_vpamdd52luqv8di = 4908,
CODE_FOR_vpamdd52luqv8di_maskz_1 = 4909,
CODE_FOR_vpamdd52huqv8di = 4910,
CODE_FOR_vpamdd52huqv8di_maskz_1 = 4911,
CODE_FOR_vpamdd52luqv4di = 4912,
CODE_FOR_vpamdd52luqv4di_maskz_1 = 4913,
CODE_FOR_vpamdd52huqv4di = 4914,
CODE_FOR_vpamdd52huqv4di_maskz_1 = 4915,
CODE_FOR_vpamdd52luqv2di = 4916,
CODE_FOR_vpamdd52luqv2di_maskz_1 = 4917,
CODE_FOR_vpamdd52huqv2di = 4918,
CODE_FOR_vpamdd52huqv2di_maskz_1 = 4919,
CODE_FOR_vpamdd52luqv8di_mask = 4920,
CODE_FOR_vpamdd52huqv8di_mask = 4921,
CODE_FOR_vpamdd52luqv4di_mask = 4922,
CODE_FOR_vpamdd52huqv4di_mask = 4923,
CODE_FOR_vpamdd52luqv2di_mask = 4924,
CODE_FOR_vpamdd52huqv2di_mask = 4925,
CODE_FOR_vpmultishiftqbv64qi = 4926,
CODE_FOR_vpmultishiftqbv64qi_mask = 4927,
CODE_FOR_vpmultishiftqbv16qi = 4928,
CODE_FOR_vpmultishiftqbv16qi_mask = 4929,
CODE_FOR_vpmultishiftqbv32qi = 4930,
CODE_FOR_vpmultishiftqbv32qi_mask = 4931,
CODE_FOR_avx5124fmaddps_4fmaddps = 4934,
CODE_FOR_avx5124fmaddps_4fmaddps_mask = 4935,
CODE_FOR_avx5124fmaddps_4fmaddps_maskz = 4936,
CODE_FOR_avx5124fmaddps_4fmaddss = 4937,
CODE_FOR_avx5124fmaddps_4fmaddss_mask = 4938,
CODE_FOR_avx5124fmaddps_4fmaddss_maskz = 4939,
CODE_FOR_avx5124fmaddps_4fnmaddps = 4940,
CODE_FOR_avx5124fmaddps_4fnmaddps_mask = 4941,
CODE_FOR_avx5124fmaddps_4fnmaddps_maskz = 4942,
CODE_FOR_avx5124fmaddps_4fnmaddss = 4943,
CODE_FOR_avx5124fmaddps_4fnmaddss_mask = 4944,
CODE_FOR_avx5124fmaddps_4fnmaddss_maskz = 4945,
CODE_FOR_avx5124vnniw_vp4dpwssd = 4946,
CODE_FOR_avx5124vnniw_vp4dpwssd_mask = 4947,
CODE_FOR_avx5124vnniw_vp4dpwssd_maskz = 4948,
CODE_FOR_avx5124vnniw_vp4dpwssds = 4949,
CODE_FOR_avx5124vnniw_vp4dpwssds_mask = 4950,
CODE_FOR_avx5124vnniw_vp4dpwssds_maskz = 4951,
CODE_FOR_vpopcountv16si = 4952,
CODE_FOR_vpopcountv16si_mask = 4953,
CODE_FOR_vpopcountv8di = 4954,
CODE_FOR_vpopcountv8di_mask = 4955,
CODE_FOR_mfence_sse2 = 4958,
CODE_FOR_mfence_nosse = 4959,
CODE_FOR_atomic_loaddi_fpu = 4960,
CODE_FOR_atomic_storeqi_1 = 4961,
CODE_FOR_atomic_storehi_1 = 4962,
CODE_FOR_atomic_storesi_1 = 4963,
CODE_FOR_atomic_storedi_1 = 4964,
CODE_FOR_atomic_storedi_fpu = 4965,
CODE_FOR_loaddi_via_fpu = 4966,
CODE_FOR_storedi_via_fpu = 4967,
CODE_FOR_loaddi_via_sse = 4968,
CODE_FOR_storedi_via_sse = 4969,
CODE_FOR_atomic_compare_and_swapdi_doubleword = 4970,
CODE_FOR_atomic_compare_and_swapti_doubleword = 4971,
CODE_FOR_atomic_compare_and_swapqi_1 = 4972,
CODE_FOR_atomic_compare_and_swaphi_1 = 4973,
CODE_FOR_atomic_compare_and_swapsi_1 = 4974,
CODE_FOR_atomic_compare_and_swapdi_1 = 4975,
CODE_FOR_atomic_fetch_addqi = 4976,
CODE_FOR_atomic_fetch_addhi = 4977,
CODE_FOR_atomic_fetch_addsi = 4978,
CODE_FOR_atomic_fetch_adddi = 4979,
CODE_FOR_atomic_exchangeqi = 4984,
CODE_FOR_atomic_exchangehi = 4985,
CODE_FOR_atomic_exchangesi = 4986,
CODE_FOR_atomic_exchangedi = 4987,
CODE_FOR_atomic_addqi = 4988,
CODE_FOR_atomic_addhi = 4989,
CODE_FOR_atomic_addsi = 4990,
CODE_FOR_atomic_adddi = 4991,
CODE_FOR_atomic_subqi = 4992,
CODE_FOR_atomic_subhi = 4993,
CODE_FOR_atomic_subsi = 4994,
CODE_FOR_atomic_subdi = 4995,
CODE_FOR_atomic_andqi = 4996,
CODE_FOR_atomic_orqi = 4997,
CODE_FOR_atomic_xorqi = 4998,
CODE_FOR_atomic_andhi = 4999,
CODE_FOR_atomic_orhi = 5000,
CODE_FOR_atomic_xorhi = 5001,
CODE_FOR_atomic_andsi = 5002,
CODE_FOR_atomic_orsi = 5003,
CODE_FOR_atomic_xorsi = 5004,
CODE_FOR_atomic_anddi = 5005,
CODE_FOR_atomic_ordi = 5006,
CODE_FOR_atomic_xordi = 5007,
CODE_FOR_atomic_bit_test_and_sethi_1 = 5008,
CODE_FOR_atomic_bit_test_and_setsi_1 = 5009,
CODE_FOR_atomic_bit_test_and_setdi_1 = 5010,
CODE_FOR_atomic_bit_test_and_complementhi_1 = 5011,
CODE_FOR_atomic_bit_test_and_complementsi_1 = 5012,
CODE_FOR_atomic_bit_test_and_complementdi_1 = 5013,
CODE_FOR_atomic_bit_test_and_resethi_1 = 5014,
CODE_FOR_atomic_bit_test_and_resetsi_1 = 5015,
CODE_FOR_atomic_bit_test_and_resetdi_1 = 5016,
CODE_FOR_cbranchqi4 = 5017,
CODE_FOR_cbranchhi4 = 5018,
CODE_FOR_cbranchsi4 = 5019,
CODE_FOR_cbranchdi4 = 5020,
CODE_FOR_cbranchti4 = 5021,
CODE_FOR_cstoreqi4 = 5022,
CODE_FOR_cstorehi4 = 5023,
CODE_FOR_cstoresi4 = 5024,
CODE_FOR_cstoredi4 = 5025,
CODE_FOR_cmpsi_1 = 5026,
CODE_FOR_cmpdi_1 = 5027,
CODE_FOR_cmpqi_ext_3 = 5028,
CODE_FOR_cbranchxf4 = 5029,
CODE_FOR_cstorexf4 = 5030,
CODE_FOR_cbranchsf4 = 5031,
CODE_FOR_cbranchdf4 = 5032,
CODE_FOR_cstoresf4 = 5033,
CODE_FOR_cstoredf4 = 5034,
CODE_FOR_cbranchcc4 = 5035,
CODE_FOR_cstorecc4 = 5036,
CODE_FOR_reload_noff_store = 5037,
CODE_FOR_reload_noff_load = 5038,
CODE_FOR_movxi = 5039,
CODE_FOR_movoi = 5040,
CODE_FOR_movti = 5041,
CODE_FOR_movcdi = 5042,
CODE_FOR_movqi = 5043,
CODE_FOR_movhi = 5044,
CODE_FOR_movsi = 5045,
CODE_FOR_movdi = 5046,
CODE_FOR_movstrictqi = 5047,
CODE_FOR_movstricthi = 5048,
CODE_FOR_extvhi = 5049,
CODE_FOR_extvsi = 5050,
CODE_FOR_extzvhi = 5051,
CODE_FOR_extzvsi = 5052,
CODE_FOR_extzvdi = 5053,
CODE_FOR_insvhi = 5054,
CODE_FOR_insvsi = 5055,
CODE_FOR_insvdi = 5056,
CODE_FOR_movtf = 5057,
CODE_FOR_movsf = 5058,
CODE_FOR_movdf = 5059,
CODE_FOR_movxf = 5060,
CODE_FOR_zero_extendsidi2 = 5061,
CODE_FOR_zero_extendqisi2 = 5062,
CODE_FOR_zero_extendhisi2 = 5063,
CODE_FOR_zero_extendqihi2 = 5064,
CODE_FOR_extendsidi2 = 5065,
CODE_FOR_extendsfdf2 = 5066,
CODE_FOR_extendsfxf2 = 5067,
CODE_FOR_extenddfxf2 = 5068,
CODE_FOR_truncdfsf2 = 5069,
CODE_FOR_truncdfsf2_with_temp = 5070,
CODE_FOR_truncxfsf2 = 5071,
CODE_FOR_truncxfdf2 = 5072,
CODE_FOR_fix_truncxfdi2 = 5073,
CODE_FOR_fix_truncsfdi2 = 5074,
CODE_FOR_fix_truncdfdi2 = 5075,
CODE_FOR_fix_truncxfsi2 = 5076,
CODE_FOR_fix_truncsfsi2 = 5077,
CODE_FOR_fix_truncdfsi2 = 5078,
CODE_FOR_fix_truncsfhi2 = 5079,
CODE_FOR_fix_truncdfhi2 = 5080,
CODE_FOR_fix_truncxfhi2 = 5081,
CODE_FOR_fixuns_truncsfsi2 = 5082,
CODE_FOR_fixuns_truncdfsi2 = 5083,
CODE_FOR_fixuns_truncsfhi2 = 5084,
CODE_FOR_fixuns_truncdfhi2 = 5085,
CODE_FOR_floatsisf2 = 5086,
CODE_FOR_floatdisf2 = 5087,
CODE_FOR_floatsidf2 = 5088,
CODE_FOR_floatdidf2 = 5089,
CODE_FOR_floatunsqisf2 = 5090,
CODE_FOR_floatunshisf2 = 5091,
CODE_FOR_floatunsqidf2 = 5092,
CODE_FOR_floatunshidf2 = 5093,
CODE_FOR_floatunssisf2 = 5094,
CODE_FOR_floatunssidf2 = 5095,
CODE_FOR_floatunssixf2 = 5096,
CODE_FOR_floatunsdisf2 = 5097,
CODE_FOR_floatunsdidf2 = 5098,
CODE_FOR_addqi3 = 5099,
CODE_FOR_addhi3 = 5100,
CODE_FOR_addsi3 = 5101,
CODE_FOR_adddi3 = 5102,
CODE_FOR_addti3 = 5103,
CODE_FOR_addvqi4 = 5104,
CODE_FOR_addvhi4 = 5105,
CODE_FOR_addvsi4 = 5106,
CODE_FOR_addvdi4 = 5107,
CODE_FOR_uaddvqi4 = 5108,
CODE_FOR_uaddvhi4 = 5109,
CODE_FOR_uaddvsi4 = 5110,
CODE_FOR_uaddvdi4 = 5111,
CODE_FOR_subqi3 = 5112,
CODE_FOR_subhi3 = 5113,
CODE_FOR_subsi3 = 5114,
CODE_FOR_subdi3 = 5115,
CODE_FOR_subti3 = 5116,
CODE_FOR_subvqi4 = 5117,
CODE_FOR_subvhi4 = 5118,
CODE_FOR_subvsi4 = 5119,
CODE_FOR_subvdi4 = 5120,
CODE_FOR_usubvqi4 = 5121,
CODE_FOR_usubvhi4 = 5122,
CODE_FOR_usubvsi4 = 5123,
CODE_FOR_usubvdi4 = 5124,
CODE_FOR_addqi3_cconly_overflow = 5125,
CODE_FOR_addxf3 = 5126,
CODE_FOR_subxf3 = 5127,
CODE_FOR_addsf3 = 5128,
CODE_FOR_subsf3 = 5129,
CODE_FOR_adddf3 = 5130,
CODE_FOR_subdf3 = 5131,
CODE_FOR_mulhi3 = 5132,
CODE_FOR_mulsi3 = 5133,
CODE_FOR_muldi3 = 5134,
CODE_FOR_mulqi3 = 5135,
CODE_FOR_mulvhi4 = 5136,
CODE_FOR_mulvsi4 = 5137,
CODE_FOR_mulvdi4 = 5138,
CODE_FOR_umulvhi4 = 5139,
CODE_FOR_umulvsi4 = 5140,
CODE_FOR_umulvdi4 = 5141,
CODE_FOR_mulvqi4 = 5142,
CODE_FOR_umulvqi4 = 5143,
CODE_FOR_mulsidi3 = 5144,
CODE_FOR_umulsidi3 = 5145,
CODE_FOR_mulditi3 = 5146,
CODE_FOR_umulditi3 = 5147,
CODE_FOR_mulqihi3 = 5148,
CODE_FOR_umulqihi3 = 5149,
CODE_FOR_smulsi3_highpart = 5150,
CODE_FOR_umulsi3_highpart = 5151,
CODE_FOR_smuldi3_highpart = 5152,
CODE_FOR_umuldi3_highpart = 5153,
CODE_FOR_mulxf3 = 5154,
CODE_FOR_mulsf3 = 5155,
CODE_FOR_muldf3 = 5156,
CODE_FOR_divxf3 = 5157,
CODE_FOR_divsf3 = 5158,
CODE_FOR_divdf3 = 5159,
CODE_FOR_divmodhi4 = 5160,
CODE_FOR_divmodsi4 = 5161,
CODE_FOR_divmoddi4 = 5162,
CODE_FOR_divmodqi4 = 5163,
CODE_FOR_udivmodhi4 = 5164,
CODE_FOR_udivmodsi4 = 5165,
CODE_FOR_udivmoddi4 = 5166,
CODE_FOR_udivmodqi4 = 5167,
CODE_FOR_testsi_ccno_1 = 5168,
CODE_FOR_testqi_ccz_1 = 5169,
CODE_FOR_testdi_ccno_1 = 5170,
CODE_FOR_testqi_ext_1_ccno = 5171,
CODE_FOR_andqi3 = 5172,
CODE_FOR_andhi3 = 5173,
CODE_FOR_andsi3 = 5174,
CODE_FOR_anddi3 = 5175,
CODE_FOR_iorqi3 = 5176,
CODE_FOR_xorqi3 = 5177,
CODE_FOR_iorhi3 = 5178,
CODE_FOR_xorhi3 = 5179,
CODE_FOR_iorsi3 = 5180,
CODE_FOR_xorsi3 = 5181,
CODE_FOR_iordi3 = 5182,
CODE_FOR_xordi3 = 5183,
CODE_FOR_xorqi_ext_1_cc = 5184,
CODE_FOR_negqi2 = 5185,
CODE_FOR_neghi2 = 5186,
CODE_FOR_negsi2 = 5187,
CODE_FOR_negdi2 = 5188,
CODE_FOR_negti2 = 5189,
CODE_FOR_negvqi3 = 5190,
CODE_FOR_negvhi3 = 5191,
CODE_FOR_negvsi3 = 5192,
CODE_FOR_negvdi3 = 5193,
CODE_FOR_abssf2 = 5194,
CODE_FOR_negsf2 = 5195,
CODE_FOR_absdf2 = 5196,
CODE_FOR_negdf2 = 5197,
CODE_FOR_absxf2 = 5198,
CODE_FOR_negxf2 = 5199,
CODE_FOR_abstf2 = 5200,
CODE_FOR_negtf2 = 5201,
CODE_FOR_copysignsf3 = 5202,
CODE_FOR_copysigndf3 = 5203,
CODE_FOR_copysigntf3 = 5204,
CODE_FOR_one_cmplqi2 = 5205,
CODE_FOR_one_cmplhi2 = 5206,
CODE_FOR_one_cmplsi2 = 5207,
CODE_FOR_one_cmpldi2 = 5208,
CODE_FOR_ashlqi3 = 5209,
CODE_FOR_ashlhi3 = 5210,
CODE_FOR_ashlsi3 = 5211,
CODE_FOR_ashldi3 = 5212,
CODE_FOR_ashlti3 = 5213,
CODE_FOR_x86_shiftsi_adj_1 = 5214,
CODE_FOR_x86_shiftdi_adj_1 = 5215,
CODE_FOR_x86_shiftsi_adj_2 = 5216,
CODE_FOR_x86_shiftdi_adj_2 = 5217,
CODE_FOR_lshrqi3 = 5218,
CODE_FOR_ashrqi3 = 5219,
CODE_FOR_lshrhi3 = 5220,
CODE_FOR_ashrhi3 = 5221,
CODE_FOR_lshrsi3 = 5222,
CODE_FOR_ashrsi3 = 5223,
CODE_FOR_lshrdi3 = 5224,
CODE_FOR_ashrdi3 = 5225,
CODE_FOR_lshrti3 = 5226,
CODE_FOR_ashrti3 = 5227,
CODE_FOR_x86_shiftsi_adj_3 = 5228,
CODE_FOR_x86_shiftdi_adj_3 = 5229,
CODE_FOR_rotlti3 = 5230,
CODE_FOR_rotrti3 = 5231,
CODE_FOR_rotldi3 = 5232,
CODE_FOR_rotrdi3 = 5233,
CODE_FOR_rotlqi3 = 5234,
CODE_FOR_rotrqi3 = 5235,
CODE_FOR_rotlhi3 = 5236,
CODE_FOR_rotrhi3 = 5237,
CODE_FOR_rotlsi3 = 5238,
CODE_FOR_rotrsi3 = 5239,
CODE_FOR_indirect_jump = 5240,
CODE_FOR_tablejump = 5241,
CODE_FOR_call = 5242,
CODE_FOR_sibcall = 5243,
CODE_FOR_call_pop = 5244,
CODE_FOR_call_value = 5245,
CODE_FOR_sibcall_value = 5246,
CODE_FOR_call_value_pop = 5247,
CODE_FOR_untyped_call = 5248,
CODE_FOR_memory_blockage = 5249,
CODE_FOR_return = 5250,
CODE_FOR_simple_return = 5251,
CODE_FOR_prologue = 5252,
CODE_FOR_set_got = 5253,
CODE_FOR_set_got_labelled = 5254,
CODE_FOR_epilogue = 5255,
CODE_FOR_sibcall_epilogue = 5256,
CODE_FOR_eh_return = 5257,
CODE_FOR_split_stack_prologue = 5258,
CODE_FOR_split_stack_space_check = 5259,
CODE_FOR_ffssi2 = 5260,
CODE_FOR_ffsdi2 = 5261,
CODE_FOR_clzsi2 = 5262,
CODE_FOR_clzdi2 = 5263,
CODE_FOR_bmi2_bzhi_si3 = 5264,
CODE_FOR_bmi2_bzhi_di3 = 5265,
CODE_FOR_bswapdi2 = 5266,
CODE_FOR_bswapsi2 = 5267,
CODE_FOR_paritydi2 = 5268,
CODE_FOR_paritysi2 = 5269,
CODE_FOR_tls_global_dynamic_32 = 5270,
CODE_FOR_tls_global_dynamic_64_si = 5271,
CODE_FOR_tls_global_dynamic_64_di = 5272,
CODE_FOR_tls_local_dynamic_base_32 = 5273,
CODE_FOR_tls_local_dynamic_base_64_si = 5274,
CODE_FOR_tls_local_dynamic_base_64_di = 5275,
CODE_FOR_tls_dynamic_gnu2_32 = 5276,
CODE_FOR_tls_dynamic_gnu2_64 = 5277,
CODE_FOR_rsqrtsf2 = 5278,
CODE_FOR_sqrtsf2 = 5279,
CODE_FOR_sqrtdf2 = 5280,
CODE_FOR_fmodxf3 = 5281,
CODE_FOR_fmodsf3 = 5282,
CODE_FOR_fmoddf3 = 5283,
CODE_FOR_remainderxf3 = 5284,
CODE_FOR_remaindersf3 = 5285,
CODE_FOR_remainderdf3 = 5286,
CODE_FOR_sincossf3 = 5287,
CODE_FOR_sincosdf3 = 5288,
CODE_FOR_tanxf2 = 5289,
CODE_FOR_tansf2 = 5290,
CODE_FOR_tandf2 = 5291,
CODE_FOR_atan2xf3 = 5292,
CODE_FOR_atan2sf3 = 5293,
CODE_FOR_atan2df3 = 5294,
CODE_FOR_atanxf2 = 5295,
CODE_FOR_atansf2 = 5296,
CODE_FOR_atandf2 = 5297,
CODE_FOR_asinxf2 = 5298,
CODE_FOR_asinsf2 = 5299,
CODE_FOR_asindf2 = 5300,
CODE_FOR_acosxf2 = 5301,
CODE_FOR_acossf2 = 5302,
CODE_FOR_acosdf2 = 5303,
CODE_FOR_logxf2 = 5304,
CODE_FOR_logsf2 = 5305,
CODE_FOR_logdf2 = 5306,
CODE_FOR_log10xf2 = 5307,
CODE_FOR_log10sf2 = 5308,
CODE_FOR_log10df2 = 5309,
CODE_FOR_log2xf2 = 5310,
CODE_FOR_log2sf2 = 5311,
CODE_FOR_log2df2 = 5312,
CODE_FOR_log1pxf2 = 5313,
CODE_FOR_log1psf2 = 5314,
CODE_FOR_log1pdf2 = 5315,
CODE_FOR_logbxf2 = 5316,
CODE_FOR_logbsf2 = 5317,
CODE_FOR_logbdf2 = 5318,
CODE_FOR_ilogbxf2 = 5319,
CODE_FOR_ilogbsf2 = 5320,
CODE_FOR_ilogbdf2 = 5321,
CODE_FOR_expNcorexf3 = 5322,
CODE_FOR_expxf2 = 5323,
CODE_FOR_expsf2 = 5324,
CODE_FOR_expdf2 = 5325,
CODE_FOR_exp10xf2 = 5326,
CODE_FOR_exp10sf2 = 5327,
CODE_FOR_exp10df2 = 5328,
CODE_FOR_exp2xf2 = 5329,
CODE_FOR_exp2sf2 = 5330,
CODE_FOR_exp2df2 = 5331,
CODE_FOR_expm1xf2 = 5332,
CODE_FOR_expm1sf2 = 5333,
CODE_FOR_expm1df2 = 5334,
CODE_FOR_ldexpxf3 = 5335,
CODE_FOR_ldexpsf3 = 5336,
CODE_FOR_ldexpdf3 = 5337,
CODE_FOR_scalbxf3 = 5338,
CODE_FOR_scalbsf3 = 5339,
CODE_FOR_scalbdf3 = 5340,
CODE_FOR_significandxf2 = 5341,
CODE_FOR_significandsf2 = 5342,
CODE_FOR_significanddf2 = 5343,
CODE_FOR_rintsf2 = 5344,
CODE_FOR_rintdf2 = 5345,
CODE_FOR_roundsf2 = 5346,
CODE_FOR_rounddf2 = 5347,
CODE_FOR_roundxf2 = 5348,
CODE_FOR_lrintxfhi2 = 5349,
CODE_FOR_lrintxfsi2 = 5350,
CODE_FOR_lrintxfdi2 = 5351,
CODE_FOR_lrintsfsi2 = 5352,
CODE_FOR_lrintsfdi2 = 5353,
CODE_FOR_lrintdfsi2 = 5354,
CODE_FOR_lrintdfdi2 = 5355,
CODE_FOR_lroundsfhi2 = 5356,
CODE_FOR_lrounddfhi2 = 5357,
CODE_FOR_lroundxfhi2 = 5358,
CODE_FOR_lroundsfsi2 = 5359,
CODE_FOR_lrounddfsi2 = 5360,
CODE_FOR_lroundxfsi2 = 5361,
CODE_FOR_lroundsfdi2 = 5362,
CODE_FOR_lrounddfdi2 = 5363,
CODE_FOR_lroundxfdi2 = 5364,
CODE_FOR_floorxf2 = 5365,
CODE_FOR_ceilxf2 = 5366,
CODE_FOR_btruncxf2 = 5367,
CODE_FOR_floorsf2 = 5368,
CODE_FOR_ceilsf2 = 5369,
CODE_FOR_btruncsf2 = 5370,
CODE_FOR_floordf2 = 5371,
CODE_FOR_ceildf2 = 5372,
CODE_FOR_btruncdf2 = 5373,
CODE_FOR_nearbyintxf2 = 5374,
CODE_FOR_nearbyintsf2 = 5375,
CODE_FOR_nearbyintdf2 = 5376,
CODE_FOR_lfloorxfhi2 = 5377,
CODE_FOR_lceilxfhi2 = 5378,
CODE_FOR_lfloorxfsi2 = 5379,
CODE_FOR_lceilxfsi2 = 5380,
CODE_FOR_lfloorxfdi2 = 5381,
CODE_FOR_lceilxfdi2 = 5382,
CODE_FOR_lfloorsfsi2 = 5383,
CODE_FOR_lceilsfsi2 = 5384,
CODE_FOR_lfloorsfdi2 = 5385,
CODE_FOR_lceilsfdi2 = 5386,
CODE_FOR_lfloordfsi2 = 5387,
CODE_FOR_lceildfsi2 = 5388,
CODE_FOR_lfloordfdi2 = 5389,
CODE_FOR_lceildfdi2 = 5390,
CODE_FOR_isinfxf2 = 5391,
CODE_FOR_isinfsf2 = 5392,
CODE_FOR_isinfdf2 = 5393,
CODE_FOR_signbittf2 = 5394,
CODE_FOR_signbitxf2 = 5395,
CODE_FOR_signbitdf2 = 5396,
CODE_FOR_signbitsf2 = 5397,
CODE_FOR_movmemsi = 5398,
CODE_FOR_movmemdi = 5399,
CODE_FOR_strmov = 5400,
CODE_FOR_strmov_singleop = 5401,
CODE_FOR_rep_mov = 5402,
CODE_FOR_setmemsi = 5403,
CODE_FOR_setmemdi = 5404,
CODE_FOR_strset = 5405,
CODE_FOR_strset_singleop = 5406,
CODE_FOR_rep_stos = 5407,
CODE_FOR_cmpstrnsi = 5408,
CODE_FOR_cmpintqi = 5409,
CODE_FOR_cmpstrnqi_nz_1 = 5410,
CODE_FOR_cmpstrnqi_1 = 5411,
CODE_FOR_strlensi = 5412,
CODE_FOR_strlendi = 5413,
CODE_FOR_strlenqi_1 = 5414,
CODE_FOR_movqicc = 5415,
CODE_FOR_movhicc = 5416,
CODE_FOR_movsicc = 5417,
CODE_FOR_movdicc = 5418,
CODE_FOR_x86_movsicc_0_m1 = 5419,
CODE_FOR_x86_movdicc_0_m1 = 5420,
CODE_FOR_movsfcc = 5421,
CODE_FOR_movdfcc = 5422,
CODE_FOR_movxfcc = 5423,
CODE_FOR_addqicc = 5424,
CODE_FOR_addhicc = 5425,
CODE_FOR_addsicc = 5426,
CODE_FOR_adddicc = 5427,
CODE_FOR_allocate_stack = 5428,
CODE_FOR_probe_stack = 5429,
CODE_FOR_builtin_setjmp_receiver = 5430,
CODE_FOR_prefetch = 5431,
CODE_FOR_stack_protect_set = 5432,
CODE_FOR_stack_protect_test = 5433,
CODE_FOR_lwp_llwpcb = 5434,
CODE_FOR_lwp_slwpcb = 5435,
CODE_FOR_lwp_lwpvalsi3 = 5436,
CODE_FOR_lwp_lwpvaldi3 = 5437,
CODE_FOR_lwp_lwpinssi3 = 5438,
CODE_FOR_lwp_lwpinsdi3 = 5439,
CODE_FOR_pause = 5440,
CODE_FOR_xbegin = 5441,
CODE_FOR_xtest = 5442,
CODE_FOR_bnd32_mk = 5443,
CODE_FOR_bnd64_mk = 5444,
CODE_FOR_movbnd32 = 5445,
CODE_FOR_movbnd64 = 5446,
CODE_FOR_bnd32_cl = 5447,
CODE_FOR_bnd32_cu = 5448,
CODE_FOR_bnd32_cn = 5449,
CODE_FOR_bnd64_cl = 5450,
CODE_FOR_bnd64_cu = 5451,
CODE_FOR_bnd64_cn = 5452,
CODE_FOR_bnd32_ldx = 5453,
CODE_FOR_bnd64_ldx = 5454,
CODE_FOR_bnd32_stx = 5455,
CODE_FOR_bnd64_stx = 5456,
CODE_FOR_rdpkru = 5457,
CODE_FOR_wrpkru = 5458,
CODE_FOR_movv8qi = 5459,
CODE_FOR_movv4hi = 5460,
CODE_FOR_movv2si = 5461,
CODE_FOR_movv1di = 5462,
CODE_FOR_movv2sf = 5463,
CODE_FOR_movmisalignv8qi = 5464,
CODE_FOR_movmisalignv4hi = 5465,
CODE_FOR_movmisalignv2si = 5466,
CODE_FOR_movmisalignv1di = 5467,
CODE_FOR_movmisalignv2sf = 5468,
CODE_FOR_mmx_addv2sf3 = 5469,
CODE_FOR_mmx_subv2sf3 = 5470,
CODE_FOR_mmx_subrv2sf3 = 5471,
CODE_FOR_mmx_mulv2sf3 = 5472,
CODE_FOR_mmx_smaxv2sf3 = 5473,
CODE_FOR_mmx_sminv2sf3 = 5474,
CODE_FOR_mmx_eqv2sf3 = 5475,
CODE_FOR_vec_setv2sf = 5476,
CODE_FOR_vec_extractv2sf = 5477,
CODE_FOR_vec_initv2sf = 5478,
CODE_FOR_mmx_addv8qi3 = 5479,
CODE_FOR_mmx_subv8qi3 = 5480,
CODE_FOR_mmx_addv4hi3 = 5481,
CODE_FOR_mmx_subv4hi3 = 5482,
CODE_FOR_mmx_addv2si3 = 5483,
CODE_FOR_mmx_subv2si3 = 5484,
CODE_FOR_mmx_addv1di3 = 5485,
CODE_FOR_mmx_subv1di3 = 5486,
CODE_FOR_mmx_ssaddv8qi3 = 5487,
CODE_FOR_mmx_usaddv8qi3 = 5488,
CODE_FOR_mmx_sssubv8qi3 = 5489,
CODE_FOR_mmx_ussubv8qi3 = 5490,
CODE_FOR_mmx_ssaddv4hi3 = 5491,
CODE_FOR_mmx_usaddv4hi3 = 5492,
CODE_FOR_mmx_sssubv4hi3 = 5493,
CODE_FOR_mmx_ussubv4hi3 = 5494,
CODE_FOR_mmx_mulv4hi3 = 5495,
CODE_FOR_mmx_smulv4hi3_highpart = 5496,
CODE_FOR_mmx_umulv4hi3_highpart = 5497,
CODE_FOR_mmx_pmaddwd = 5498,
CODE_FOR_mmx_pmulhrwv4hi3 = 5499,
CODE_FOR_sse2_umulv1siv1di3 = 5500,
CODE_FOR_mmx_smaxv4hi3 = 5501,
CODE_FOR_mmx_sminv4hi3 = 5502,
CODE_FOR_mmx_umaxv8qi3 = 5503,
CODE_FOR_mmx_uminv8qi3 = 5504,
CODE_FOR_mmx_eqv8qi3 = 5505,
CODE_FOR_mmx_eqv4hi3 = 5506,
CODE_FOR_mmx_eqv2si3 = 5507,
CODE_FOR_mmx_andv8qi3 = 5508,
CODE_FOR_mmx_iorv8qi3 = 5509,
CODE_FOR_mmx_xorv8qi3 = 5510,
CODE_FOR_mmx_andv4hi3 = 5511,
CODE_FOR_mmx_iorv4hi3 = 5512,
CODE_FOR_mmx_xorv4hi3 = 5513,
CODE_FOR_mmx_andv2si3 = 5514,
CODE_FOR_mmx_iorv2si3 = 5515,
CODE_FOR_mmx_xorv2si3 = 5516,
CODE_FOR_mmx_pinsrw = 5517,
CODE_FOR_mmx_pshufw = 5518,
CODE_FOR_vec_setv2si = 5519,
CODE_FOR_vec_extractv2si = 5520,
CODE_FOR_vec_initv2si = 5521,
CODE_FOR_vec_setv4hi = 5522,
CODE_FOR_vec_extractv4hi = 5523,
CODE_FOR_vec_initv4hi = 5524,
CODE_FOR_vec_setv8qi = 5525,
CODE_FOR_vec_extractv8qi = 5526,
CODE_FOR_vec_initv8qi = 5527,
CODE_FOR_mmx_uavgv8qi3 = 5528,
CODE_FOR_mmx_uavgv4hi3 = 5529,
CODE_FOR_mmx_maskmovq = 5530,
CODE_FOR_mmx_emms = 5531,
CODE_FOR_mmx_femms = 5532,
CODE_FOR_movv64qi = 5533,
CODE_FOR_movv32qi = 5534,
CODE_FOR_movv16qi = 5535,
CODE_FOR_movv32hi = 5536,
CODE_FOR_movv16hi = 5537,
CODE_FOR_movv8hi = 5538,
CODE_FOR_movv16si = 5539,
CODE_FOR_movv8si = 5540,
CODE_FOR_movv4si = 5541,
CODE_FOR_movv8di = 5542,
CODE_FOR_movv4di = 5543,
CODE_FOR_movv2di = 5544,
CODE_FOR_movv4ti = 5545,
CODE_FOR_movv2ti = 5546,
CODE_FOR_movv1ti = 5547,
CODE_FOR_movv16sf = 5548,
CODE_FOR_movv8sf = 5549,
CODE_FOR_movv4sf = 5550,
CODE_FOR_movv8df = 5551,
CODE_FOR_movv4df = 5552,
CODE_FOR_movv2df = 5553,
CODE_FOR_movmisalignv64qi = 5554,
CODE_FOR_movmisalignv32qi = 5555,
CODE_FOR_movmisalignv16qi = 5556,
CODE_FOR_movmisalignv32hi = 5557,
CODE_FOR_movmisalignv16hi = 5558,
CODE_FOR_movmisalignv8hi = 5559,
CODE_FOR_movmisalignv16si = 5560,
CODE_FOR_movmisalignv8si = 5561,
CODE_FOR_movmisalignv4si = 5562,
CODE_FOR_movmisalignv8di = 5563,
CODE_FOR_movmisalignv4di = 5564,
CODE_FOR_movmisalignv2di = 5565,
CODE_FOR_movmisalignv4ti = 5566,
CODE_FOR_movmisalignv2ti = 5567,
CODE_FOR_movmisalignv1ti = 5568,
CODE_FOR_movmisalignv16sf = 5569,
CODE_FOR_movmisalignv8sf = 5570,
CODE_FOR_movmisalignv4sf = 5571,
CODE_FOR_movmisalignv8df = 5572,
CODE_FOR_movmisalignv4df = 5573,
CODE_FOR_movmisalignv2df = 5574,
CODE_FOR_storentdi = 5575,
CODE_FOR_storentsi = 5576,
CODE_FOR_storentsf = 5577,
CODE_FOR_storentdf = 5578,
CODE_FOR_storentv8di = 5579,
CODE_FOR_storentv4di = 5580,
CODE_FOR_storentv2di = 5581,
CODE_FOR_storentv16sf = 5582,
CODE_FOR_storentv8sf = 5583,
CODE_FOR_storentv4sf = 5584,
CODE_FOR_storentv8df = 5585,
CODE_FOR_storentv4df = 5586,
CODE_FOR_storentv2df = 5587,
CODE_FOR_kmovb = 5588,
CODE_FOR_kmovw = 5589,
CODE_FOR_kmovd = 5590,
CODE_FOR_kmovq = 5591,
CODE_FOR_absv16sf2 = 5592,
CODE_FOR_negv16sf2 = 5593,
CODE_FOR_absv8sf2 = 5594,
CODE_FOR_negv8sf2 = 5595,
CODE_FOR_absv4sf2 = 5596,
CODE_FOR_negv4sf2 = 5597,
CODE_FOR_absv8df2 = 5598,
CODE_FOR_negv8df2 = 5599,
CODE_FOR_absv4df2 = 5600,
CODE_FOR_negv4df2 = 5601,
CODE_FOR_absv2df2 = 5602,
CODE_FOR_negv2df2 = 5603,
CODE_FOR_addv16sf3 = 5604,
CODE_FOR_addv16sf3_round = 5605,
CODE_FOR_addv16sf3_mask = 5606,
CODE_FOR_addv16sf3_mask_round = 5607,
CODE_FOR_subv16sf3 = 5608,
CODE_FOR_subv16sf3_round = 5609,
CODE_FOR_subv16sf3_mask = 5610,
CODE_FOR_subv16sf3_mask_round = 5611,
CODE_FOR_addv8sf3 = 5612,
CODE_FOR_addv8sf3_round = CODE_FOR_nothing,
CODE_FOR_addv8sf3_mask = 5613,
CODE_FOR_addv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_subv8sf3 = 5614,
CODE_FOR_subv8sf3_round = CODE_FOR_nothing,
CODE_FOR_subv8sf3_mask = 5615,
CODE_FOR_subv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_addv4sf3 = 5616,
CODE_FOR_addv4sf3_round = CODE_FOR_nothing,
CODE_FOR_addv4sf3_mask = 5617,
CODE_FOR_addv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_subv4sf3 = 5618,
CODE_FOR_subv4sf3_round = CODE_FOR_nothing,
CODE_FOR_subv4sf3_mask = 5619,
CODE_FOR_subv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_addv8df3 = 5620,
CODE_FOR_addv8df3_round = 5621,
CODE_FOR_addv8df3_mask = 5622,
CODE_FOR_addv8df3_mask_round = 5623,
CODE_FOR_subv8df3 = 5624,
CODE_FOR_subv8df3_round = 5625,
CODE_FOR_subv8df3_mask = 5626,
CODE_FOR_subv8df3_mask_round = 5627,
CODE_FOR_addv4df3 = 5628,
CODE_FOR_addv4df3_round = CODE_FOR_nothing,
CODE_FOR_addv4df3_mask = 5629,
CODE_FOR_addv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_subv4df3 = 5630,
CODE_FOR_subv4df3_round = CODE_FOR_nothing,
CODE_FOR_subv4df3_mask = 5631,
CODE_FOR_subv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_addv2df3 = 5632,
CODE_FOR_addv2df3_round = CODE_FOR_nothing,
CODE_FOR_addv2df3_mask = 5633,
CODE_FOR_addv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_subv2df3 = 5634,
CODE_FOR_subv2df3_round = CODE_FOR_nothing,
CODE_FOR_subv2df3_mask = 5635,
CODE_FOR_subv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_mulv16sf3 = 5636,
CODE_FOR_mulv16sf3_round = 5637,
CODE_FOR_mulv16sf3_mask = 5638,
CODE_FOR_mulv16sf3_mask_round = 5639,
CODE_FOR_mulv8sf3 = 5640,
CODE_FOR_mulv8sf3_round = CODE_FOR_nothing,
CODE_FOR_mulv8sf3_mask = 5641,
CODE_FOR_mulv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_mulv4sf3 = 5642,
CODE_FOR_mulv4sf3_round = CODE_FOR_nothing,
CODE_FOR_mulv4sf3_mask = 5643,
CODE_FOR_mulv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_mulv8df3 = 5644,
CODE_FOR_mulv8df3_round = 5645,
CODE_FOR_mulv8df3_mask = 5646,
CODE_FOR_mulv8df3_mask_round = 5647,
CODE_FOR_mulv4df3 = 5648,
CODE_FOR_mulv4df3_round = CODE_FOR_nothing,
CODE_FOR_mulv4df3_mask = 5649,
CODE_FOR_mulv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_mulv2df3 = 5650,
CODE_FOR_mulv2df3_round = CODE_FOR_nothing,
CODE_FOR_mulv2df3_mask = 5651,
CODE_FOR_mulv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_divv8df3 = 5652,
CODE_FOR_divv4df3 = 5653,
CODE_FOR_divv2df3 = 5654,
CODE_FOR_divv16sf3 = 5655,
CODE_FOR_divv8sf3 = 5656,
CODE_FOR_divv4sf3 = 5657,
CODE_FOR_sqrtv8df2 = 5658,
CODE_FOR_sqrtv4df2 = 5659,
CODE_FOR_sqrtv2df2 = 5660,
CODE_FOR_sqrtv16sf2 = 5661,
CODE_FOR_sqrtv8sf2 = 5662,
CODE_FOR_sqrtv4sf2 = 5663,
CODE_FOR_rsqrtv8sf2 = 5664,
CODE_FOR_rsqrtv4sf2 = 5665,
CODE_FOR_rsqrtv16sf2 = 5666,
CODE_FOR_smaxv16sf3 = 5667,
CODE_FOR_smaxv16sf3_round = 5668,
CODE_FOR_smaxv16sf3_mask = 5669,
CODE_FOR_smaxv16sf3_mask_round = 5670,
CODE_FOR_sminv16sf3 = 5671,
CODE_FOR_sminv16sf3_round = 5672,
CODE_FOR_sminv16sf3_mask = 5673,
CODE_FOR_sminv16sf3_mask_round = 5674,
CODE_FOR_smaxv8sf3 = 5675,
CODE_FOR_smaxv8sf3_round = CODE_FOR_nothing,
CODE_FOR_smaxv8sf3_mask = 5676,
CODE_FOR_smaxv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_sminv8sf3 = 5677,
CODE_FOR_sminv8sf3_round = CODE_FOR_nothing,
CODE_FOR_sminv8sf3_mask = 5678,
CODE_FOR_sminv8sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_smaxv4sf3 = 5679,
CODE_FOR_smaxv4sf3_round = CODE_FOR_nothing,
CODE_FOR_smaxv4sf3_mask = 5680,
CODE_FOR_smaxv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_sminv4sf3 = 5681,
CODE_FOR_sminv4sf3_round = CODE_FOR_nothing,
CODE_FOR_sminv4sf3_mask = 5682,
CODE_FOR_sminv4sf3_mask_round = CODE_FOR_nothing,
CODE_FOR_smaxv8df3 = 5683,
CODE_FOR_smaxv8df3_round = 5684,
CODE_FOR_smaxv8df3_mask = 5685,
CODE_FOR_smaxv8df3_mask_round = 5686,
CODE_FOR_sminv8df3 = 5687,
CODE_FOR_sminv8df3_round = 5688,
CODE_FOR_sminv8df3_mask = 5689,
CODE_FOR_sminv8df3_mask_round = 5690,
CODE_FOR_smaxv4df3 = 5691,
CODE_FOR_smaxv4df3_round = CODE_FOR_nothing,
CODE_FOR_smaxv4df3_mask = 5692,
CODE_FOR_smaxv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sminv4df3 = 5693,
CODE_FOR_sminv4df3_round = CODE_FOR_nothing,
CODE_FOR_sminv4df3_mask = 5694,
CODE_FOR_sminv4df3_mask_round = CODE_FOR_nothing,
CODE_FOR_smaxv2df3 = 5695,
CODE_FOR_smaxv2df3_round = CODE_FOR_nothing,
CODE_FOR_smaxv2df3_mask = 5696,
CODE_FOR_smaxv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sminv2df3 = 5697,
CODE_FOR_sminv2df3_round = CODE_FOR_nothing,
CODE_FOR_sminv2df3_mask = 5698,
CODE_FOR_sminv2df3_mask_round = CODE_FOR_nothing,
CODE_FOR_sse3_haddv2df3 = 5699,
CODE_FOR_reduc_plus_scal_v8df = 5700,
CODE_FOR_reduc_plus_scal_v4df = 5701,
CODE_FOR_reduc_plus_scal_v2df = 5702,
CODE_FOR_reduc_plus_scal_v16sf = 5703,
CODE_FOR_reduc_plus_scal_v8sf = 5704,
CODE_FOR_reduc_plus_scal_v4sf = 5705,
CODE_FOR_reduc_smax_scal_v32qi = 5706,
CODE_FOR_reduc_smin_scal_v32qi = 5707,
CODE_FOR_reduc_smax_scal_v16hi = 5708,
CODE_FOR_reduc_smin_scal_v16hi = 5709,
CODE_FOR_reduc_smax_scal_v8si = 5710,
CODE_FOR_reduc_smin_scal_v8si = 5711,
CODE_FOR_reduc_smax_scal_v4di = 5712,
CODE_FOR_reduc_smin_scal_v4di = 5713,
CODE_FOR_reduc_smax_scal_v8sf = 5714,
CODE_FOR_reduc_smin_scal_v8sf = 5715,
CODE_FOR_reduc_smax_scal_v4df = 5716,
CODE_FOR_reduc_smin_scal_v4df = 5717,
CODE_FOR_reduc_smax_scal_v4sf = 5718,
CODE_FOR_reduc_smin_scal_v4sf = 5719,
CODE_FOR_reduc_smax_scal_v64qi = 5720,
CODE_FOR_reduc_smin_scal_v64qi = 5721,
CODE_FOR_reduc_smax_scal_v32hi = 5722,
CODE_FOR_reduc_smin_scal_v32hi = 5723,
CODE_FOR_reduc_smax_scal_v16si = 5724,
CODE_FOR_reduc_smin_scal_v16si = 5725,
CODE_FOR_reduc_smax_scal_v8di = 5726,
CODE_FOR_reduc_smin_scal_v8di = 5727,
CODE_FOR_reduc_smax_scal_v16sf = 5728,
CODE_FOR_reduc_smin_scal_v16sf = 5729,
CODE_FOR_reduc_smax_scal_v8df = 5730,
CODE_FOR_reduc_smin_scal_v8df = 5731,
CODE_FOR_reduc_umax_scal_v16si = 5732,
CODE_FOR_reduc_umin_scal_v16si = 5733,
CODE_FOR_reduc_umax_scal_v8di = 5734,
CODE_FOR_reduc_umin_scal_v8di = 5735,
CODE_FOR_reduc_umax_scal_v32hi = 5736,
CODE_FOR_reduc_umin_scal_v32hi = 5737,
CODE_FOR_reduc_umax_scal_v64qi = 5738,
CODE_FOR_reduc_umin_scal_v64qi = 5739,
CODE_FOR_reduc_umax_scal_v32qi = 5740,
CODE_FOR_reduc_umin_scal_v32qi = 5741,
CODE_FOR_reduc_umax_scal_v16hi = 5742,
CODE_FOR_reduc_umin_scal_v16hi = 5743,
CODE_FOR_reduc_umax_scal_v8si = 5744,
CODE_FOR_reduc_umin_scal_v8si = 5745,
CODE_FOR_reduc_umax_scal_v4di = 5746,
CODE_FOR_reduc_umin_scal_v4di = 5747,
CODE_FOR_reduc_umin_scal_v8hi = 5748,
CODE_FOR_vec_cmpv16sihi = 5749,
CODE_FOR_vec_cmpv8siqi = 5750,
CODE_FOR_vec_cmpv4siqi = 5751,
CODE_FOR_vec_cmpv8diqi = 5752,
CODE_FOR_vec_cmpv4diqi = 5753,
CODE_FOR_vec_cmpv2diqi = 5754,
CODE_FOR_vec_cmpv16sfhi = 5755,
CODE_FOR_vec_cmpv8sfqi = 5756,
CODE_FOR_vec_cmpv4sfqi = 5757,
CODE_FOR_vec_cmpv8dfqi = 5758,
CODE_FOR_vec_cmpv4dfqi = 5759,
CODE_FOR_vec_cmpv2dfqi = 5760,
CODE_FOR_vec_cmpv64qidi = 5761,
CODE_FOR_vec_cmpv16qihi = 5762,
CODE_FOR_vec_cmpv32qisi = 5763,
CODE_FOR_vec_cmpv32hisi = 5764,
CODE_FOR_vec_cmpv16hihi = 5765,
CODE_FOR_vec_cmpv8hiqi = 5766,
CODE_FOR_vec_cmpv32qiv32qi = 5767,
CODE_FOR_vec_cmpv16hiv16hi = 5768,
CODE_FOR_vec_cmpv8siv8si = 5769,
CODE_FOR_vec_cmpv4div4di = 5770,
CODE_FOR_vec_cmpv16qiv16qi = 5771,
CODE_FOR_vec_cmpv8hiv8hi = 5772,
CODE_FOR_vec_cmpv4siv4si = 5773,
CODE_FOR_vec_cmpv2div2di = 5774,
CODE_FOR_vec_cmpv8sfv8si = 5775,
CODE_FOR_vec_cmpv4dfv4di = 5776,
CODE_FOR_vec_cmpv4sfv4si = 5777,
CODE_FOR_vec_cmpv2dfv2di = 5778,
CODE_FOR_vec_cmpuv16sihi = 5779,
CODE_FOR_vec_cmpuv8siqi = 5780,
CODE_FOR_vec_cmpuv4siqi = 5781,
CODE_FOR_vec_cmpuv8diqi = 5782,
CODE_FOR_vec_cmpuv4diqi = 5783,
CODE_FOR_vec_cmpuv2diqi = 5784,
CODE_FOR_vec_cmpuv64qidi = 5785,
CODE_FOR_vec_cmpuv16qihi = 5786,
CODE_FOR_vec_cmpuv32qisi = 5787,
CODE_FOR_vec_cmpuv32hisi = 5788,
CODE_FOR_vec_cmpuv16hihi = 5789,
CODE_FOR_vec_cmpuv8hiqi = 5790,
CODE_FOR_vec_cmpuv32qiv32qi = 5791,
CODE_FOR_vec_cmpuv16hiv16hi = 5792,
CODE_FOR_vec_cmpuv8siv8si = 5793,
CODE_FOR_vec_cmpuv4div4di = 5794,
CODE_FOR_vec_cmpuv16qiv16qi = 5795,
CODE_FOR_vec_cmpuv8hiv8hi = 5796,
CODE_FOR_vec_cmpuv4siv4si = 5797,
CODE_FOR_vec_cmpuv2div2di = 5798,
CODE_FOR_vec_cmpeqv2div2di = 5799,
CODE_FOR_vcondv64qiv16sf = 5800,
CODE_FOR_vcondv32hiv16sf = 5801,
CODE_FOR_vcondv16siv16sf = 5802,
CODE_FOR_vcondv8div16sf = 5803,
CODE_FOR_vcondv16sfv16sf = 5804,
CODE_FOR_vcondv8dfv16sf = 5805,
CODE_FOR_vcondv64qiv8df = 5806,
CODE_FOR_vcondv32hiv8df = 5807,
CODE_FOR_vcondv16siv8df = 5808,
CODE_FOR_vcondv8div8df = 5809,
CODE_FOR_vcondv16sfv8df = 5810,
CODE_FOR_vcondv8dfv8df = 5811,
CODE_FOR_vcondv32qiv8sf = 5812,
CODE_FOR_vcondv32qiv4df = 5813,
CODE_FOR_vcondv16hiv8sf = 5814,
CODE_FOR_vcondv16hiv4df = 5815,
CODE_FOR_vcondv8siv8sf = 5816,
CODE_FOR_vcondv8siv4df = 5817,
CODE_FOR_vcondv4div8sf = 5818,
CODE_FOR_vcondv4div4df = 5819,
CODE_FOR_vcondv8sfv8sf = 5820,
CODE_FOR_vcondv8sfv4df = 5821,
CODE_FOR_vcondv4dfv8sf = 5822,
CODE_FOR_vcondv4dfv4df = 5823,
CODE_FOR_vcondv16qiv4sf = 5824,
CODE_FOR_vcondv16qiv2df = 5825,
CODE_FOR_vcondv8hiv4sf = 5826,
CODE_FOR_vcondv8hiv2df = 5827,
CODE_FOR_vcondv4siv4sf = 5828,
CODE_FOR_vcondv4siv2df = 5829,
CODE_FOR_vcondv2div4sf = 5830,
CODE_FOR_vcondv2div2df = 5831,
CODE_FOR_vcondv4sfv4sf = 5832,
CODE_FOR_vcondv4sfv2df = 5833,
CODE_FOR_vcondv2dfv4sf = 5834,
CODE_FOR_vcondv2dfv2df = 5835,
CODE_FOR_vcond_mask_v16sihi = 5836,
CODE_FOR_vcond_mask_v8siqi = 5837,
CODE_FOR_vcond_mask_v4siqi = 5838,
CODE_FOR_vcond_mask_v8diqi = 5839,
CODE_FOR_vcond_mask_v4diqi = 5840,
CODE_FOR_vcond_mask_v2diqi = 5841,
CODE_FOR_vcond_mask_v16sfhi = 5842,
CODE_FOR_vcond_mask_v8sfqi = 5843,
CODE_FOR_vcond_mask_v4sfqi = 5844,
CODE_FOR_vcond_mask_v8dfqi = 5845,
CODE_FOR_vcond_mask_v4dfqi = 5846,
CODE_FOR_vcond_mask_v2dfqi = 5847,
CODE_FOR_vcond_mask_v64qidi = 5848,
CODE_FOR_vcond_mask_v16qihi = 5849,
CODE_FOR_vcond_mask_v32qisi = 5850,
CODE_FOR_vcond_mask_v32hisi = 5851,
CODE_FOR_vcond_mask_v16hihi = 5852,
CODE_FOR_vcond_mask_v8hiqi = 5853,
CODE_FOR_vcond_mask_v32qiv32qi = 5854,
CODE_FOR_vcond_mask_v16hiv16hi = 5855,
CODE_FOR_vcond_mask_v8siv8si = 5856,
CODE_FOR_vcond_mask_v4div4di = 5857,
CODE_FOR_vcond_mask_v16qiv16qi = 5858,
CODE_FOR_vcond_mask_v8hiv8hi = 5859,
CODE_FOR_vcond_mask_v4siv4si = 5860,
CODE_FOR_vcond_mask_v2div2di = 5861,
CODE_FOR_vcond_mask_v8sfv8si = 5862,
CODE_FOR_vcond_mask_v4dfv4di = 5863,
CODE_FOR_vcond_mask_v4sfv4si = 5864,
CODE_FOR_vcond_mask_v2dfv2di = 5865,
CODE_FOR_andv8sf3 = 5866,
CODE_FOR_andv8sf3_mask = 5867,
CODE_FOR_iorv8sf3 = 5868,
CODE_FOR_iorv8sf3_mask = 5869,
CODE_FOR_xorv8sf3 = 5870,
CODE_FOR_xorv8sf3_mask = 5871,
CODE_FOR_andv4sf3 = 5872,
CODE_FOR_andv4sf3_mask = 5873,
CODE_FOR_iorv4sf3 = 5874,
CODE_FOR_iorv4sf3_mask = 5875,
CODE_FOR_xorv4sf3 = 5876,
CODE_FOR_xorv4sf3_mask = 5877,
CODE_FOR_andv4df3 = 5878,
CODE_FOR_andv4df3_mask = 5879,
CODE_FOR_iorv4df3 = 5880,
CODE_FOR_iorv4df3_mask = 5881,
CODE_FOR_xorv4df3 = 5882,
CODE_FOR_xorv4df3_mask = 5883,
CODE_FOR_andv2df3 = 5884,
CODE_FOR_andv2df3_mask = 5885,
CODE_FOR_iorv2df3 = 5886,
CODE_FOR_iorv2df3_mask = 5887,
CODE_FOR_xorv2df3 = 5888,
CODE_FOR_xorv2df3_mask = 5889,
CODE_FOR_andv16sf3 = 5890,
CODE_FOR_andv16sf3_mask = 5891,
CODE_FOR_iorv16sf3 = 5892,
CODE_FOR_iorv16sf3_mask = 5893,
CODE_FOR_xorv16sf3 = 5894,
CODE_FOR_xorv16sf3_mask = 5895,
CODE_FOR_andv8df3 = 5896,
CODE_FOR_andv8df3_mask = 5897,
CODE_FOR_iorv8df3 = 5898,
CODE_FOR_iorv8df3_mask = 5899,
CODE_FOR_xorv8df3 = 5900,
CODE_FOR_xorv8df3_mask = 5901,
CODE_FOR_copysignv16sf3 = 5902,
CODE_FOR_copysignv8sf3 = 5903,
CODE_FOR_copysignv4sf3 = 5904,
CODE_FOR_copysignv8df3 = 5905,
CODE_FOR_copysignv4df3 = 5906,
CODE_FOR_copysignv2df3 = 5907,
CODE_FOR_andtf3 = 5908,
CODE_FOR_iortf3 = 5909,
CODE_FOR_xortf3 = 5910,
CODE_FOR_fmasf4 = 5911,
CODE_FOR_fmadf4 = 5912,
CODE_FOR_fmav4sf4 = 5913,
CODE_FOR_fmav2df4 = 5914,
CODE_FOR_fmav8sf4 = 5915,
CODE_FOR_fmav4df4 = 5916,
CODE_FOR_fmav16sf4 = 5917,
CODE_FOR_fmav8df4 = 5918,
CODE_FOR_fmssf4 = 5919,
CODE_FOR_fmsdf4 = 5920,
CODE_FOR_fmsv4sf4 = 5921,
CODE_FOR_fmsv2df4 = 5922,
CODE_FOR_fmsv8sf4 = 5923,
CODE_FOR_fmsv4df4 = 5924,
CODE_FOR_fmsv16sf4 = 5925,
CODE_FOR_fmsv8df4 = 5926,
CODE_FOR_fnmasf4 = 5927,
CODE_FOR_fnmadf4 = 5928,
CODE_FOR_fnmav4sf4 = 5929,
CODE_FOR_fnmav2df4 = 5930,
CODE_FOR_fnmav8sf4 = 5931,
CODE_FOR_fnmav4df4 = 5932,
CODE_FOR_fnmav16sf4 = 5933,
CODE_FOR_fnmav8df4 = 5934,
CODE_FOR_fnmssf4 = 5935,
CODE_FOR_fnmsdf4 = 5936,
CODE_FOR_fnmsv4sf4 = 5937,
CODE_FOR_fnmsv2df4 = 5938,
CODE_FOR_fnmsv8sf4 = 5939,
CODE_FOR_fnmsv4df4 = 5940,
CODE_FOR_fnmsv16sf4 = 5941,
CODE_FOR_fnmsv8df4 = 5942,
CODE_FOR_fma4i_fmadd_sf = 5943,
CODE_FOR_fma4i_fmadd_df = 5944,
CODE_FOR_fma4i_fmadd_v4sf = 5945,
CODE_FOR_fma4i_fmadd_v2df = 5946,
CODE_FOR_fma4i_fmadd_v8sf = 5947,
CODE_FOR_fma4i_fmadd_v4df = 5948,
CODE_FOR_fma4i_fmadd_v16sf = 5949,
CODE_FOR_fma4i_fmadd_v8df = 5950,
CODE_FOR_avx512f_fmadd_v16sf_maskz = 5951,
CODE_FOR_avx512f_fmadd_v16sf_maskz_round = 5952,
CODE_FOR_avx512vl_fmadd_v8sf_maskz = 5953,
CODE_FOR_avx512vl_fmadd_v8sf_maskz_round = 5954,
CODE_FOR_avx512vl_fmadd_v4sf_maskz = 5955,
CODE_FOR_avx512vl_fmadd_v4sf_maskz_round = 5956,
CODE_FOR_avx512f_fmadd_v8df_maskz = 5957,
CODE_FOR_avx512f_fmadd_v8df_maskz_round = 5958,
CODE_FOR_avx512vl_fmadd_v4df_maskz = 5959,
CODE_FOR_avx512vl_fmadd_v4df_maskz_round = 5960,
CODE_FOR_avx512vl_fmadd_v2df_maskz = 5961,
CODE_FOR_avx512vl_fmadd_v2df_maskz_round = 5962,
CODE_FOR_fmaddsub_v16sf = 5963,
CODE_FOR_fmaddsub_v8sf = 5964,
CODE_FOR_fmaddsub_v4sf = 5965,
CODE_FOR_fmaddsub_v8df = 5966,
CODE_FOR_fmaddsub_v4df = 5967,
CODE_FOR_fmaddsub_v2df = 5968,
CODE_FOR_avx512f_fmaddsub_v16sf_maskz = 5969,
CODE_FOR_avx512f_fmaddsub_v16sf_maskz_round = 5970,
CODE_FOR_avx512vl_fmaddsub_v8sf_maskz = 5971,
CODE_FOR_avx512vl_fmaddsub_v8sf_maskz_round = 5972,
CODE_FOR_avx512vl_fmaddsub_v4sf_maskz = 5973,
CODE_FOR_avx512vl_fmaddsub_v4sf_maskz_round = 5974,
CODE_FOR_avx512f_fmaddsub_v8df_maskz = 5975,
CODE_FOR_avx512f_fmaddsub_v8df_maskz_round = 5976,
CODE_FOR_avx512vl_fmaddsub_v4df_maskz = 5977,
CODE_FOR_avx512vl_fmaddsub_v4df_maskz_round = 5978,
CODE_FOR_avx512vl_fmaddsub_v2df_maskz = 5979,
CODE_FOR_avx512vl_fmaddsub_v2df_maskz_round = 5980,
CODE_FOR_fmai_vmfmadd_v4sf = 5981,
CODE_FOR_fmai_vmfmadd_v4sf_round = 5982,
CODE_FOR_fmai_vmfmadd_v2df = 5983,
CODE_FOR_fmai_vmfmadd_v2df_round = 5984,
CODE_FOR_fma4i_vmfmadd_v4sf = 5985,
CODE_FOR_fma4i_vmfmadd_v2df = 5986,
CODE_FOR_floatunsv16siv16sf2 = 5987,
CODE_FOR_floatunsv8siv8sf2 = 5988,
CODE_FOR_floatunsv4siv4sf2 = 5989,
CODE_FOR_fixuns_truncv16sfv16si2 = 5990,
CODE_FOR_fixuns_truncv8sfv8si2 = 5991,
CODE_FOR_fixuns_truncv4sfv4si2 = 5992,
CODE_FOR_avx_cvtpd2dq256_2 = 5993,
CODE_FOR_avx_cvttpd2dq256_2 = 5994,
CODE_FOR_sse2_cvtpd2ps = 5995,
CODE_FOR_sse2_cvtpd2ps_mask = 5996,
CODE_FOR_avx512bw_cvtmask2bv64qi = 5997,
CODE_FOR_avx512vl_cvtmask2bv16qi = 5998,
CODE_FOR_avx512vl_cvtmask2bv32qi = 5999,
CODE_FOR_avx512bw_cvtmask2wv32hi = 6000,
CODE_FOR_avx512vl_cvtmask2wv16hi = 6001,
CODE_FOR_avx512vl_cvtmask2wv8hi = 6002,
CODE_FOR_avx512f_cvtmask2dv16si = 6003,
CODE_FOR_avx512vl_cvtmask2dv8si = 6004,
CODE_FOR_avx512vl_cvtmask2dv4si = 6005,
CODE_FOR_avx512f_cvtmask2qv8di = 6006,
CODE_FOR_avx512vl_cvtmask2qv4di = 6007,
CODE_FOR_avx512vl_cvtmask2qv2di = 6008,
CODE_FOR_vec_unpacks_hi_v4sf = 6009,
CODE_FOR_vec_unpacks_hi_v8sf = 6010,
CODE_FOR_vec_unpacks_hi_v16sf = 6011,
CODE_FOR_vec_unpacks_lo_v4sf = 6012,
CODE_FOR_vec_unpacks_lo_v8sf = 6013,
CODE_FOR_vec_unpacks_float_hi_v32hi = 6014,
CODE_FOR_vec_unpacks_float_hi_v16hi = 6015,
CODE_FOR_vec_unpacks_float_hi_v8hi = 6016,
CODE_FOR_vec_unpacks_float_lo_v32hi = 6017,
CODE_FOR_vec_unpacks_float_lo_v16hi = 6018,
CODE_FOR_vec_unpacks_float_lo_v8hi = 6019,
CODE_FOR_vec_unpacku_float_hi_v32hi = 6020,
CODE_FOR_vec_unpacku_float_hi_v16hi = 6021,
CODE_FOR_vec_unpacku_float_hi_v8hi = 6022,
CODE_FOR_vec_unpacku_float_lo_v32hi = 6023,
CODE_FOR_vec_unpacku_float_lo_v16hi = 6024,
CODE_FOR_vec_unpacku_float_lo_v8hi = 6025,
CODE_FOR_vec_unpacks_float_hi_v4si = 6026,
CODE_FOR_vec_unpacks_float_lo_v4si = 6027,
CODE_FOR_vec_unpacks_float_hi_v8si = 6028,
CODE_FOR_vec_unpacks_float_lo_v8si = 6029,
CODE_FOR_vec_unpacks_float_hi_v16si = 6030,
CODE_FOR_vec_unpacks_float_lo_v16si = 6031,
CODE_FOR_vec_unpacku_float_hi_v4si = 6032,
CODE_FOR_vec_unpacku_float_lo_v4si = 6033,
CODE_FOR_vec_unpacku_float_hi_v8si = 6034,
CODE_FOR_vec_unpacku_float_hi_v16si = 6035,
CODE_FOR_vec_unpacku_float_lo_v8si = 6036,
CODE_FOR_vec_unpacku_float_lo_v16si = 6037,
CODE_FOR_vec_pack_trunc_v8df = 6038,
CODE_FOR_vec_pack_trunc_v4df = 6039,
CODE_FOR_vec_pack_trunc_v2df = 6040,
CODE_FOR_vec_pack_sfix_trunc_v8df = 6041,
CODE_FOR_vec_pack_sfix_trunc_v4df = 6042,
CODE_FOR_vec_pack_sfix_trunc_v2df = 6043,
CODE_FOR_vec_pack_ufix_trunc_v8df = 6044,
CODE_FOR_vec_pack_ufix_trunc_v4df = 6045,
CODE_FOR_vec_pack_ufix_trunc_v2df = 6046,
CODE_FOR_avx512f_vec_pack_sfix_v8df = 6047,
CODE_FOR_vec_pack_sfix_v4df = 6048,
CODE_FOR_vec_pack_sfix_v2df = 6049,
CODE_FOR_sse_movhlps_exp = 6050,
CODE_FOR_sse_movlhps_exp = 6051,
CODE_FOR_vec_interleave_highv8sf = 6052,
CODE_FOR_vec_interleave_lowv8sf = 6053,
CODE_FOR_avx_shufps256 = 6054,
CODE_FOR_avx_shufps256_mask = 6055,
CODE_FOR_sse_shufps = 6056,
CODE_FOR_sse_shufps_mask = 6057,
CODE_FOR_sse_loadhps_exp = 6058,
CODE_FOR_sse_loadlps_exp = 6059,
CODE_FOR_vec_initv16qi = 6060,
CODE_FOR_vec_initv8hi = 6061,
CODE_FOR_vec_initv4si = 6062,
CODE_FOR_vec_initv2di = 6063,
CODE_FOR_vec_initv4sf = 6064,
CODE_FOR_vec_initv2df = 6065,
CODE_FOR_vec_setv32qi = 6066,
CODE_FOR_vec_setv16qi = 6067,
CODE_FOR_vec_setv16hi = 6068,
CODE_FOR_vec_setv8hi = 6069,
CODE_FOR_vec_setv16si = 6070,
CODE_FOR_vec_setv8si = 6071,
CODE_FOR_vec_setv4si = 6072,
CODE_FOR_vec_setv8di = 6073,
CODE_FOR_vec_setv4di = 6074,
CODE_FOR_vec_setv2di = 6075,
CODE_FOR_vec_setv16sf = 6076,
CODE_FOR_vec_setv8sf = 6077,
CODE_FOR_vec_setv4sf = 6078,
CODE_FOR_vec_setv8df = 6079,
CODE_FOR_vec_setv4df = 6080,
CODE_FOR_vec_setv2df = 6081,
CODE_FOR_avx512dq_vextractf64x2_mask = 6082,
CODE_FOR_avx512dq_vextracti64x2_mask = 6083,
CODE_FOR_avx512f_vextractf32x4_mask = 6084,
CODE_FOR_avx512f_vextracti32x4_mask = 6085,
CODE_FOR_avx512dq_vextractf32x8_mask = 6086,
CODE_FOR_avx512dq_vextracti32x8_mask = 6087,
CODE_FOR_avx512f_vextractf64x4_mask = 6088,
CODE_FOR_avx512f_vextracti64x4_mask = 6089,
CODE_FOR_avx512vl_vextractf128v8si = 6090,
CODE_FOR_avx512vl_vextractf128v8sf = 6091,
CODE_FOR_avx512vl_vextractf128v4di = 6092,
CODE_FOR_avx512vl_vextractf128v4df = 6093,
CODE_FOR_avx_vextractf128v32qi = 6094,
CODE_FOR_avx_vextractf128v16hi = 6095,
CODE_FOR_avx_vextractf128v8si = 6096,
CODE_FOR_avx_vextractf128v4di = 6097,
CODE_FOR_avx_vextractf128v8sf = 6098,
CODE_FOR_avx_vextractf128v4df = 6099,
CODE_FOR_vec_extractv64qi = 6100,
CODE_FOR_vec_extractv32qi = 6101,
CODE_FOR_vec_extractv16qi = 6102,
CODE_FOR_vec_extractv32hi = 6103,
CODE_FOR_vec_extractv16hi = 6104,
CODE_FOR_vec_extractv8hi = 6105,
CODE_FOR_vec_extractv16si = 6106,
CODE_FOR_vec_extractv8si = 6107,
CODE_FOR_vec_extractv4si = 6108,
CODE_FOR_vec_extractv8di = 6109,
CODE_FOR_vec_extractv4di = 6110,
CODE_FOR_vec_extractv2di = 6111,
CODE_FOR_vec_extractv16sf = 6112,
CODE_FOR_vec_extractv8sf = 6113,
CODE_FOR_vec_extractv4sf = 6114,
CODE_FOR_vec_extractv8df = 6115,
CODE_FOR_vec_extractv4df = 6116,
CODE_FOR_vec_extractv2df = 6117,
CODE_FOR_vec_interleave_highv4df = 6118,
CODE_FOR_vec_interleave_highv2df = 6119,
CODE_FOR_avx512f_movddup512 = 6120,
CODE_FOR_avx512f_movddup512_mask = 6121,
CODE_FOR_avx512f_unpcklpd512 = 6122,
CODE_FOR_avx512f_unpcklpd512_mask = 6123,
CODE_FOR_avx_movddup256 = 6124,
CODE_FOR_avx_movddup256_mask = 6125,
CODE_FOR_avx_unpcklpd256 = 6126,
CODE_FOR_avx_unpcklpd256_mask = 6127,
CODE_FOR_vec_interleave_lowv4df = 6128,
CODE_FOR_vec_interleave_lowv2df = 6129,
CODE_FOR_avx512f_vternlogv16si_maskz = 6130,
CODE_FOR_avx512vl_vternlogv8si_maskz = 6131,
CODE_FOR_avx512vl_vternlogv4si_maskz = 6132,
CODE_FOR_avx512f_vternlogv8di_maskz = 6133,
CODE_FOR_avx512vl_vternlogv4di_maskz = 6134,
CODE_FOR_avx512vl_vternlogv2di_maskz = 6135,
CODE_FOR_avx512f_shufps512_mask = 6136,
CODE_FOR_avx512f_fixupimmv16sf_maskz = 6137,
CODE_FOR_avx512f_fixupimmv16sf_maskz_round = 6138,
CODE_FOR_avx512vl_fixupimmv8sf_maskz = 6139,
CODE_FOR_avx512vl_fixupimmv8sf_maskz_round = 6140,
CODE_FOR_avx512vl_fixupimmv4sf_maskz = 6141,
CODE_FOR_avx512vl_fixupimmv4sf_maskz_round = 6142,
CODE_FOR_avx512f_fixupimmv8df_maskz = 6143,
CODE_FOR_avx512f_fixupimmv8df_maskz_round = 6144,
CODE_FOR_avx512vl_fixupimmv4df_maskz = 6145,
CODE_FOR_avx512vl_fixupimmv4df_maskz_round = 6146,
CODE_FOR_avx512vl_fixupimmv2df_maskz = 6147,
CODE_FOR_avx512vl_fixupimmv2df_maskz_round = 6148,
CODE_FOR_avx512f_sfixupimmv4sf_maskz = 6149,
CODE_FOR_avx512f_sfixupimmv4sf_maskz_round = 6150,
CODE_FOR_avx512f_sfixupimmv2df_maskz = 6151,
CODE_FOR_avx512f_sfixupimmv2df_maskz_round = 6152,
CODE_FOR_avx512f_shufpd512_mask = 6153,
CODE_FOR_avx_shufpd256 = 6154,
CODE_FOR_avx_shufpd256_mask = 6155,
CODE_FOR_sse2_shufpd = 6156,
CODE_FOR_sse2_shufpd_mask = 6157,
CODE_FOR_sse2_loadhpd_exp = 6158,
CODE_FOR_sse2_loadlpd_exp = 6159,
CODE_FOR_avx512f_ss_truncatev16siv16qi2_mask_store = 6160,
CODE_FOR_avx512f_truncatev16siv16qi2_mask_store = 6161,
CODE_FOR_avx512f_us_truncatev16siv16qi2_mask_store = 6162,
CODE_FOR_avx512f_ss_truncatev16siv16hi2_mask_store = 6163,
CODE_FOR_avx512f_truncatev16siv16hi2_mask_store = 6164,
CODE_FOR_avx512f_us_truncatev16siv16hi2_mask_store = 6165,
CODE_FOR_avx512f_ss_truncatev8div8si2_mask_store = 6166,
CODE_FOR_avx512f_truncatev8div8si2_mask_store = 6167,
CODE_FOR_avx512f_us_truncatev8div8si2_mask_store = 6168,
CODE_FOR_avx512f_ss_truncatev8div8hi2_mask_store = 6169,
CODE_FOR_avx512f_truncatev8div8hi2_mask_store = 6170,
CODE_FOR_avx512f_us_truncatev8div8hi2_mask_store = 6171,
CODE_FOR_avx512bw_ss_truncatev32hiv32qi2_mask_store = 6172,
CODE_FOR_avx512bw_truncatev32hiv32qi2_mask_store = 6173,
CODE_FOR_avx512bw_us_truncatev32hiv32qi2_mask_store = 6174,
CODE_FOR_avx512vl_ss_truncatev4div4si2_mask_store = 6175,
CODE_FOR_avx512vl_truncatev4div4si2_mask_store = 6176,
CODE_FOR_avx512vl_us_truncatev4div4si2_mask_store = 6177,
CODE_FOR_avx512vl_ss_truncatev8siv8hi2_mask_store = 6178,
CODE_FOR_avx512vl_truncatev8siv8hi2_mask_store = 6179,
CODE_FOR_avx512vl_us_truncatev8siv8hi2_mask_store = 6180,
CODE_FOR_avx512vl_ss_truncatev16hiv16qi2_mask_store = 6181,
CODE_FOR_avx512vl_truncatev16hiv16qi2_mask_store = 6182,
CODE_FOR_avx512vl_us_truncatev16hiv16qi2_mask_store = 6183,
CODE_FOR_negv64qi2 = 6184,
CODE_FOR_negv32qi2 = 6185,
CODE_FOR_negv16qi2 = 6186,
CODE_FOR_negv32hi2 = 6187,
CODE_FOR_negv16hi2 = 6188,
CODE_FOR_negv8hi2 = 6189,
CODE_FOR_negv16si2 = 6190,
CODE_FOR_negv8si2 = 6191,
CODE_FOR_negv4si2 = 6192,
CODE_FOR_negv8di2 = 6193,
CODE_FOR_negv4di2 = 6194,
CODE_FOR_negv2di2 = 6195,
CODE_FOR_addv64qi3 = 6196,
CODE_FOR_subv64qi3 = 6197,
CODE_FOR_addv32qi3 = 6198,
CODE_FOR_subv32qi3 = 6199,
CODE_FOR_addv16qi3 = 6200,
CODE_FOR_subv16qi3 = 6201,
CODE_FOR_addv32hi3 = 6202,
CODE_FOR_subv32hi3 = 6203,
CODE_FOR_addv16hi3 = 6204,
CODE_FOR_subv16hi3 = 6205,
CODE_FOR_addv8hi3 = 6206,
CODE_FOR_subv8hi3 = 6207,
CODE_FOR_addv16si3 = 6208,
CODE_FOR_subv16si3 = 6209,
CODE_FOR_addv8si3 = 6210,
CODE_FOR_subv8si3 = 6211,
CODE_FOR_addv4si3 = 6212,
CODE_FOR_subv4si3 = 6213,
CODE_FOR_addv8di3 = 6214,
CODE_FOR_subv8di3 = 6215,
CODE_FOR_addv4di3 = 6216,
CODE_FOR_subv4di3 = 6217,
CODE_FOR_addv2di3 = 6218,
CODE_FOR_subv2di3 = 6219,
CODE_FOR_addv16si3_mask = 6220,
CODE_FOR_subv16si3_mask = 6221,
CODE_FOR_addv8si3_mask = 6222,
CODE_FOR_subv8si3_mask = 6223,
CODE_FOR_addv4si3_mask = 6224,
CODE_FOR_subv4si3_mask = 6225,
CODE_FOR_addv8di3_mask = 6226,
CODE_FOR_subv8di3_mask = 6227,
CODE_FOR_addv4di3_mask = 6228,
CODE_FOR_subv4di3_mask = 6229,
CODE_FOR_addv2di3_mask = 6230,
CODE_FOR_subv2di3_mask = 6231,
CODE_FOR_addv64qi3_mask = 6232,
CODE_FOR_subv64qi3_mask = 6233,
CODE_FOR_addv16qi3_mask = 6234,
CODE_FOR_subv16qi3_mask = 6235,
CODE_FOR_addv32qi3_mask = 6236,
CODE_FOR_subv32qi3_mask = 6237,
CODE_FOR_addv32hi3_mask = 6238,
CODE_FOR_subv32hi3_mask = 6239,
CODE_FOR_addv16hi3_mask = 6240,
CODE_FOR_subv16hi3_mask = 6241,
CODE_FOR_addv8hi3_mask = 6242,
CODE_FOR_subv8hi3_mask = 6243,
CODE_FOR_avx512bw_ssaddv64qi3 = 6244,
CODE_FOR_avx512bw_ssaddv64qi3_mask = 6245,
CODE_FOR_avx512bw_usaddv64qi3 = 6246,
CODE_FOR_avx512bw_usaddv64qi3_mask = 6247,
CODE_FOR_avx512bw_sssubv64qi3 = 6248,
CODE_FOR_avx512bw_sssubv64qi3_mask = 6249,
CODE_FOR_avx512bw_ussubv64qi3 = 6250,
CODE_FOR_avx512bw_ussubv64qi3_mask = 6251,
CODE_FOR_avx2_ssaddv32qi3 = 6252,
CODE_FOR_avx2_ssaddv32qi3_mask = 6253,
CODE_FOR_avx2_usaddv32qi3 = 6254,
CODE_FOR_avx2_usaddv32qi3_mask = 6255,
CODE_FOR_avx2_sssubv32qi3 = 6256,
CODE_FOR_avx2_sssubv32qi3_mask = 6257,
CODE_FOR_avx2_ussubv32qi3 = 6258,
CODE_FOR_avx2_ussubv32qi3_mask = 6259,
CODE_FOR_sse2_ssaddv16qi3 = 6260,
CODE_FOR_sse2_ssaddv16qi3_mask = 6261,
CODE_FOR_sse2_usaddv16qi3 = 6262,
CODE_FOR_sse2_usaddv16qi3_mask = 6263,
CODE_FOR_sse2_sssubv16qi3 = 6264,
CODE_FOR_sse2_sssubv16qi3_mask = 6265,
CODE_FOR_sse2_ussubv16qi3 = 6266,
CODE_FOR_sse2_ussubv16qi3_mask = 6267,
CODE_FOR_avx512bw_ssaddv32hi3 = 6268,
CODE_FOR_avx512bw_ssaddv32hi3_mask = 6269,
CODE_FOR_avx512bw_usaddv32hi3 = 6270,
CODE_FOR_avx512bw_usaddv32hi3_mask = 6271,
CODE_FOR_avx512bw_sssubv32hi3 = 6272,
CODE_FOR_avx512bw_sssubv32hi3_mask = 6273,
CODE_FOR_avx512bw_ussubv32hi3 = 6274,
CODE_FOR_avx512bw_ussubv32hi3_mask = 6275,
CODE_FOR_avx2_ssaddv16hi3 = 6276,
CODE_FOR_avx2_ssaddv16hi3_mask = 6277,
CODE_FOR_avx2_usaddv16hi3 = 6278,
CODE_FOR_avx2_usaddv16hi3_mask = 6279,
CODE_FOR_avx2_sssubv16hi3 = 6280,
CODE_FOR_avx2_sssubv16hi3_mask = 6281,
CODE_FOR_avx2_ussubv16hi3 = 6282,
CODE_FOR_avx2_ussubv16hi3_mask = 6283,
CODE_FOR_sse2_ssaddv8hi3 = 6284,
CODE_FOR_sse2_ssaddv8hi3_mask = 6285,
CODE_FOR_sse2_usaddv8hi3 = 6286,
CODE_FOR_sse2_usaddv8hi3_mask = 6287,
CODE_FOR_sse2_sssubv8hi3 = 6288,
CODE_FOR_sse2_sssubv8hi3_mask = 6289,
CODE_FOR_sse2_ussubv8hi3 = 6290,
CODE_FOR_sse2_ussubv8hi3_mask = 6291,
CODE_FOR_mulv64qi3 = 6292,
CODE_FOR_mulv64qi3_mask = 6293,
CODE_FOR_mulv32qi3 = 6294,
CODE_FOR_mulv32qi3_mask = 6295,
CODE_FOR_mulv16qi3 = 6296,
CODE_FOR_mulv16qi3_mask = 6297,
CODE_FOR_mulv32hi3 = 6298,
CODE_FOR_mulv32hi3_mask = 6299,
CODE_FOR_mulv16hi3 = 6300,
CODE_FOR_mulv16hi3_mask = 6301,
CODE_FOR_mulv8hi3 = 6302,
CODE_FOR_mulv8hi3_mask = 6303,
CODE_FOR_smulv32hi3_highpart = 6304,
CODE_FOR_smulv32hi3_highpart_mask = 6305,
CODE_FOR_umulv32hi3_highpart = 6306,
CODE_FOR_umulv32hi3_highpart_mask = 6307,
CODE_FOR_smulv16hi3_highpart = 6308,
CODE_FOR_smulv16hi3_highpart_mask = 6309,
CODE_FOR_umulv16hi3_highpart = 6310,
CODE_FOR_umulv16hi3_highpart_mask = 6311,
CODE_FOR_smulv8hi3_highpart = 6312,
CODE_FOR_smulv8hi3_highpart_mask = 6313,
CODE_FOR_umulv8hi3_highpart = 6314,
CODE_FOR_umulv8hi3_highpart_mask = 6315,
CODE_FOR_vec_widen_umult_even_v16si = 6316,
CODE_FOR_vec_widen_umult_even_v16si_mask = 6317,
CODE_FOR_vec_widen_umult_even_v8si = 6318,
CODE_FOR_vec_widen_umult_even_v8si_mask = 6319,
CODE_FOR_vec_widen_umult_even_v4si = 6320,
CODE_FOR_vec_widen_umult_even_v4si_mask = 6321,
CODE_FOR_vec_widen_smult_even_v16si = 6322,
CODE_FOR_vec_widen_smult_even_v16si_mask = 6323,
CODE_FOR_vec_widen_smult_even_v8si = 6324,
CODE_FOR_vec_widen_smult_even_v8si_mask = 6325,
CODE_FOR_sse4_1_mulv2siv2di3 = 6326,
CODE_FOR_sse4_1_mulv2siv2di3_mask = 6327,
CODE_FOR_avx2_pmaddwd = 6328,
CODE_FOR_sse2_pmaddwd = 6329,
CODE_FOR_mulv16si3 = 6330,
CODE_FOR_mulv16si3_mask = 6331,
CODE_FOR_mulv8si3 = 6332,
CODE_FOR_mulv8si3_mask = 6333,
CODE_FOR_mulv4si3 = 6334,
CODE_FOR_mulv4si3_mask = 6335,
CODE_FOR_mulv8di3 = 6336,
CODE_FOR_mulv4di3 = 6337,
CODE_FOR_mulv2di3 = 6338,
CODE_FOR_vec_widen_smult_hi_v32qi = 6339,
CODE_FOR_vec_widen_umult_hi_v32qi = 6340,
CODE_FOR_vec_widen_smult_hi_v16qi = 6341,
CODE_FOR_vec_widen_umult_hi_v16qi = 6342,
CODE_FOR_vec_widen_smult_hi_v16hi = 6343,
CODE_FOR_vec_widen_umult_hi_v16hi = 6344,
CODE_FOR_vec_widen_smult_hi_v8hi = 6345,
CODE_FOR_vec_widen_umult_hi_v8hi = 6346,
CODE_FOR_vec_widen_smult_hi_v8si = 6347,
CODE_FOR_vec_widen_umult_hi_v8si = 6348,
CODE_FOR_vec_widen_smult_hi_v4si = 6349,
CODE_FOR_vec_widen_umult_hi_v4si = 6350,
CODE_FOR_vec_widen_smult_lo_v32qi = 6351,
CODE_FOR_vec_widen_umult_lo_v32qi = 6352,
CODE_FOR_vec_widen_smult_lo_v16qi = 6353,
CODE_FOR_vec_widen_umult_lo_v16qi = 6354,
CODE_FOR_vec_widen_smult_lo_v16hi = 6355,
CODE_FOR_vec_widen_umult_lo_v16hi = 6356,
CODE_FOR_vec_widen_smult_lo_v8hi = 6357,
CODE_FOR_vec_widen_umult_lo_v8hi = 6358,
CODE_FOR_vec_widen_smult_lo_v8si = 6359,
CODE_FOR_vec_widen_umult_lo_v8si = 6360,
CODE_FOR_vec_widen_smult_lo_v4si = 6361,
CODE_FOR_vec_widen_umult_lo_v4si = 6362,
CODE_FOR_vec_widen_smult_even_v4si = 6363,
CODE_FOR_vec_widen_smult_odd_v16si = 6364,
CODE_FOR_vec_widen_umult_odd_v16si = 6365,
CODE_FOR_vec_widen_smult_odd_v8si = 6366,
CODE_FOR_vec_widen_umult_odd_v8si = 6367,
CODE_FOR_vec_widen_smult_odd_v4si = 6368,
CODE_FOR_vec_widen_umult_odd_v4si = 6369,
CODE_FOR_sdot_prodv32hi = 6370,
CODE_FOR_sdot_prodv16hi = 6371,
CODE_FOR_sdot_prodv8hi = 6372,
CODE_FOR_sdot_prodv4si = 6373,
CODE_FOR_usadv16qi = 6374,
CODE_FOR_usadv32qi = 6375,
CODE_FOR_vec_shl_v16qi = 6376,
CODE_FOR_vec_shl_v8hi = 6377,
CODE_FOR_vec_shl_v4si = 6378,
CODE_FOR_vec_shl_v2di = 6379,
CODE_FOR_vec_shr_v16qi = 6380,
CODE_FOR_vec_shr_v8hi = 6381,
CODE_FOR_vec_shr_v4si = 6382,
CODE_FOR_vec_shr_v2di = 6383,
CODE_FOR_smaxv32qi3 = 6384,
CODE_FOR_sminv32qi3 = 6385,
CODE_FOR_umaxv32qi3 = 6386,
CODE_FOR_uminv32qi3 = 6387,
CODE_FOR_smaxv16hi3 = 6388,
CODE_FOR_sminv16hi3 = 6389,
CODE_FOR_umaxv16hi3 = 6390,
CODE_FOR_uminv16hi3 = 6391,
CODE_FOR_smaxv8si3 = 6392,
CODE_FOR_sminv8si3 = 6393,
CODE_FOR_umaxv8si3 = 6394,
CODE_FOR_uminv8si3 = 6395,
CODE_FOR_smaxv64qi3 = 6396,
CODE_FOR_sminv64qi3 = 6397,
CODE_FOR_umaxv64qi3 = 6398,
CODE_FOR_uminv64qi3 = 6399,
CODE_FOR_smaxv32hi3 = 6400,
CODE_FOR_sminv32hi3 = 6401,
CODE_FOR_umaxv32hi3 = 6402,
CODE_FOR_uminv32hi3 = 6403,
CODE_FOR_smaxv16si3 = 6404,
CODE_FOR_sminv16si3 = 6405,
CODE_FOR_umaxv16si3 = 6406,
CODE_FOR_uminv16si3 = 6407,
CODE_FOR_smaxv16si3_mask = 6408,
CODE_FOR_sminv16si3_mask = 6409,
CODE_FOR_umaxv16si3_mask = 6410,
CODE_FOR_uminv16si3_mask = 6411,
CODE_FOR_smaxv8si3_mask = 6412,
CODE_FOR_sminv8si3_mask = 6413,
CODE_FOR_umaxv8si3_mask = 6414,
CODE_FOR_uminv8si3_mask = 6415,
CODE_FOR_smaxv4si3_mask = 6416,
CODE_FOR_sminv4si3_mask = 6417,
CODE_FOR_umaxv4si3_mask = 6418,
CODE_FOR_uminv4si3_mask = 6419,
CODE_FOR_smaxv8di3_mask = 6420,
CODE_FOR_sminv8di3_mask = 6421,
CODE_FOR_umaxv8di3_mask = 6422,
CODE_FOR_uminv8di3_mask = 6423,
CODE_FOR_smaxv4di3_mask = 6424,
CODE_FOR_sminv4di3_mask = 6425,
CODE_FOR_umaxv4di3_mask = 6426,
CODE_FOR_uminv4di3_mask = 6427,
CODE_FOR_smaxv2di3_mask = 6428,
CODE_FOR_sminv2di3_mask = 6429,
CODE_FOR_umaxv2di3_mask = 6430,
CODE_FOR_uminv2di3_mask = 6431,
CODE_FOR_smaxv8di3 = 6432,
CODE_FOR_sminv8di3 = 6433,
CODE_FOR_umaxv8di3 = 6434,
CODE_FOR_uminv8di3 = 6435,
CODE_FOR_smaxv4di3 = 6436,
CODE_FOR_sminv4di3 = 6437,
CODE_FOR_umaxv4di3 = 6438,
CODE_FOR_uminv4di3 = 6439,
CODE_FOR_smaxv2di3 = 6440,
CODE_FOR_sminv2di3 = 6441,
CODE_FOR_umaxv2di3 = 6442,
CODE_FOR_uminv2di3 = 6443,
CODE_FOR_smaxv16qi3 = 6444,
CODE_FOR_sminv16qi3 = 6445,
CODE_FOR_smaxv8hi3 = 6446,
CODE_FOR_sminv8hi3 = 6447,
CODE_FOR_smaxv4si3 = 6448,
CODE_FOR_sminv4si3 = 6449,
CODE_FOR_umaxv16qi3 = 6450,
CODE_FOR_uminv16qi3 = 6451,
CODE_FOR_umaxv8hi3 = 6452,
CODE_FOR_uminv8hi3 = 6453,
CODE_FOR_umaxv4si3 = 6454,
CODE_FOR_uminv4si3 = 6455,
CODE_FOR_avx2_eqv32qi3 = 6456,
CODE_FOR_avx2_eqv16hi3 = 6457,
CODE_FOR_avx2_eqv8si3 = 6458,
CODE_FOR_avx2_eqv4di3 = 6459,
CODE_FOR_avx512bw_eqv64qi3 = 6460,
CODE_FOR_avx512bw_eqv64qi3_mask = 6461,
CODE_FOR_avx512vl_eqv16qi3 = 6462,
CODE_FOR_avx512vl_eqv16qi3_mask = 6463,
CODE_FOR_avx512vl_eqv32qi3 = 6464,
CODE_FOR_avx512vl_eqv32qi3_mask = 6465,
CODE_FOR_avx512bw_eqv32hi3 = 6466,
CODE_FOR_avx512bw_eqv32hi3_mask = 6467,
CODE_FOR_avx512vl_eqv16hi3 = 6468,
CODE_FOR_avx512vl_eqv16hi3_mask = 6469,
CODE_FOR_avx512vl_eqv8hi3 = 6470,
CODE_FOR_avx512vl_eqv8hi3_mask = 6471,
CODE_FOR_avx512f_eqv16si3 = 6472,
CODE_FOR_avx512f_eqv16si3_mask = 6473,
CODE_FOR_avx512vl_eqv8si3 = 6474,
CODE_FOR_avx512vl_eqv8si3_mask = 6475,
CODE_FOR_avx512vl_eqv4si3 = 6476,
CODE_FOR_avx512vl_eqv4si3_mask = 6477,
CODE_FOR_avx512f_eqv8di3 = 6478,
CODE_FOR_avx512f_eqv8di3_mask = 6479,
CODE_FOR_avx512vl_eqv4di3 = 6480,
CODE_FOR_avx512vl_eqv4di3_mask = 6481,
CODE_FOR_avx512vl_eqv2di3 = 6482,
CODE_FOR_avx512vl_eqv2di3_mask = 6483,
CODE_FOR_sse2_eqv16qi3 = 6484,
CODE_FOR_sse2_eqv8hi3 = 6485,
CODE_FOR_sse2_eqv4si3 = 6486,
CODE_FOR_sse4_1_eqv2di3 = 6487,
CODE_FOR_vcondv64qiv16si = 6488,
CODE_FOR_vcondv32hiv16si = 6489,
CODE_FOR_vcondv16siv16si = 6490,
CODE_FOR_vcondv8div16si = 6491,
CODE_FOR_vcondv16sfv16si = 6492,
CODE_FOR_vcondv8dfv16si = 6493,
CODE_FOR_vcondv64qiv8di = 6494,
CODE_FOR_vcondv32hiv8di = 6495,
CODE_FOR_vcondv16siv8di = 6496,
CODE_FOR_vcondv8div8di = 6497,
CODE_FOR_vcondv16sfv8di = 6498,
CODE_FOR_vcondv8dfv8di = 6499,
CODE_FOR_vcondv64qiv32hi = 6500,
CODE_FOR_vcondv32hiv32hi = 6501,
CODE_FOR_vcondv16siv32hi = 6502,
CODE_FOR_vcondv8div32hi = 6503,
CODE_FOR_vcondv16sfv32hi = 6504,
CODE_FOR_vcondv8dfv32hi = 6505,
CODE_FOR_vcondv64qiv64qi = 6506,
CODE_FOR_vcondv32hiv64qi = 6507,
CODE_FOR_vcondv16siv64qi = 6508,
CODE_FOR_vcondv8div64qi = 6509,
CODE_FOR_vcondv16sfv64qi = 6510,
CODE_FOR_vcondv8dfv64qi = 6511,
CODE_FOR_vcondv32qiv32qi = 6512,
CODE_FOR_vcondv32qiv16hi = 6513,
CODE_FOR_vcondv32qiv8si = 6514,
CODE_FOR_vcondv32qiv4di = 6515,
CODE_FOR_vcondv16hiv32qi = 6516,
CODE_FOR_vcondv16hiv16hi = 6517,
CODE_FOR_vcondv16hiv8si = 6518,
CODE_FOR_vcondv16hiv4di = 6519,
CODE_FOR_vcondv8siv32qi = 6520,
CODE_FOR_vcondv8siv16hi = 6521,
CODE_FOR_vcondv8siv8si = 6522,
CODE_FOR_vcondv8siv4di = 6523,
CODE_FOR_vcondv4div32qi = 6524,
CODE_FOR_vcondv4div16hi = 6525,
CODE_FOR_vcondv4div8si = 6526,
CODE_FOR_vcondv4div4di = 6527,
CODE_FOR_vcondv8sfv32qi = 6528,
CODE_FOR_vcondv8sfv16hi = 6529,
CODE_FOR_vcondv8sfv8si = 6530,
CODE_FOR_vcondv8sfv4di = 6531,
CODE_FOR_vcondv4dfv32qi = 6532,
CODE_FOR_vcondv4dfv16hi = 6533,
CODE_FOR_vcondv4dfv8si = 6534,
CODE_FOR_vcondv4dfv4di = 6535,
CODE_FOR_vcondv16qiv16qi = 6536,
CODE_FOR_vcondv8hiv16qi = 6537,
CODE_FOR_vcondv4siv16qi = 6538,
CODE_FOR_vcondv2div16qi = 6539,
CODE_FOR_vcondv4sfv16qi = 6540,
CODE_FOR_vcondv2dfv16qi = 6541,
CODE_FOR_vcondv16qiv8hi = 6542,
CODE_FOR_vcondv8hiv8hi = 6543,
CODE_FOR_vcondv4siv8hi = 6544,
CODE_FOR_vcondv2div8hi = 6545,
CODE_FOR_vcondv4sfv8hi = 6546,
CODE_FOR_vcondv2dfv8hi = 6547,
CODE_FOR_vcondv16qiv4si = 6548,
CODE_FOR_vcondv8hiv4si = 6549,
CODE_FOR_vcondv4siv4si = 6550,
CODE_FOR_vcondv2div4si = 6551,
CODE_FOR_vcondv4sfv4si = 6552,
CODE_FOR_vcondv2dfv4si = 6553,
CODE_FOR_vcondv2div2di = 6554,
CODE_FOR_vcondv2dfv2di = 6555,
CODE_FOR_vconduv64qiv16si = 6556,
CODE_FOR_vconduv32hiv16si = 6557,
CODE_FOR_vconduv16siv16si = 6558,
CODE_FOR_vconduv8div16si = 6559,
CODE_FOR_vconduv16sfv16si = 6560,
CODE_FOR_vconduv8dfv16si = 6561,
CODE_FOR_vconduv64qiv8di = 6562,
CODE_FOR_vconduv32hiv8di = 6563,
CODE_FOR_vconduv16siv8di = 6564,
CODE_FOR_vconduv8div8di = 6565,
CODE_FOR_vconduv16sfv8di = 6566,
CODE_FOR_vconduv8dfv8di = 6567,
CODE_FOR_vconduv64qiv32hi = 6568,
CODE_FOR_vconduv32hiv32hi = 6569,
CODE_FOR_vconduv16siv32hi = 6570,
CODE_FOR_vconduv8div32hi = 6571,
CODE_FOR_vconduv16sfv32hi = 6572,
CODE_FOR_vconduv8dfv32hi = 6573,
CODE_FOR_vconduv64qiv64qi = 6574,
CODE_FOR_vconduv32hiv64qi = 6575,
CODE_FOR_vconduv16siv64qi = 6576,
CODE_FOR_vconduv8div64qi = 6577,
CODE_FOR_vconduv16sfv64qi = 6578,
CODE_FOR_vconduv8dfv64qi = 6579,
CODE_FOR_vconduv32qiv32qi = 6580,
CODE_FOR_vconduv32qiv16hi = 6581,
CODE_FOR_vconduv32qiv8si = 6582,
CODE_FOR_vconduv32qiv4di = 6583,
CODE_FOR_vconduv16hiv32qi = 6584,
CODE_FOR_vconduv16hiv16hi = 6585,
CODE_FOR_vconduv16hiv8si = 6586,
CODE_FOR_vconduv16hiv4di = 6587,
CODE_FOR_vconduv8siv32qi = 6588,
CODE_FOR_vconduv8siv16hi = 6589,
CODE_FOR_vconduv8siv8si = 6590,
CODE_FOR_vconduv8siv4di = 6591,
CODE_FOR_vconduv4div32qi = 6592,
CODE_FOR_vconduv4div16hi = 6593,
CODE_FOR_vconduv4div8si = 6594,
CODE_FOR_vconduv4div4di = 6595,
CODE_FOR_vconduv8sfv32qi = 6596,
CODE_FOR_vconduv8sfv16hi = 6597,
CODE_FOR_vconduv8sfv8si = 6598,
CODE_FOR_vconduv8sfv4di = 6599,
CODE_FOR_vconduv4dfv32qi = 6600,
CODE_FOR_vconduv4dfv16hi = 6601,
CODE_FOR_vconduv4dfv8si = 6602,
CODE_FOR_vconduv4dfv4di = 6603,
CODE_FOR_vconduv16qiv16qi = 6604,
CODE_FOR_vconduv8hiv16qi = 6605,
CODE_FOR_vconduv4siv16qi = 6606,
CODE_FOR_vconduv2div16qi = 6607,
CODE_FOR_vconduv4sfv16qi = 6608,
CODE_FOR_vconduv2dfv16qi = 6609,
CODE_FOR_vconduv16qiv8hi = 6610,
CODE_FOR_vconduv8hiv8hi = 6611,
CODE_FOR_vconduv4siv8hi = 6612,
CODE_FOR_vconduv2div8hi = 6613,
CODE_FOR_vconduv4sfv8hi = 6614,
CODE_FOR_vconduv2dfv8hi = 6615,
CODE_FOR_vconduv16qiv4si = 6616,
CODE_FOR_vconduv8hiv4si = 6617,
CODE_FOR_vconduv4siv4si = 6618,
CODE_FOR_vconduv2div4si = 6619,
CODE_FOR_vconduv4sfv4si = 6620,
CODE_FOR_vconduv2dfv4si = 6621,
CODE_FOR_vconduv2div2di = 6622,
CODE_FOR_vconduv2dfv2di = 6623,
CODE_FOR_vcondeqv2div2di = 6624,
CODE_FOR_vcondeqv2dfv2di = 6625,
CODE_FOR_vec_permv16qi = 6626,
CODE_FOR_vec_permv8hi = 6627,
CODE_FOR_vec_permv4si = 6628,
CODE_FOR_vec_permv2di = 6629,
CODE_FOR_vec_permv4sf = 6630,
CODE_FOR_vec_permv2df = 6631,
CODE_FOR_vec_permv32qi = 6632,
CODE_FOR_vec_permv16hi = 6633,
CODE_FOR_vec_permv8si = 6634,
CODE_FOR_vec_permv4di = 6635,
CODE_FOR_vec_permv8sf = 6636,
CODE_FOR_vec_permv4df = 6637,
CODE_FOR_vec_permv16sf = 6638,
CODE_FOR_vec_permv8df = 6639,
CODE_FOR_vec_permv16si = 6640,
CODE_FOR_vec_permv8di = 6641,
CODE_FOR_vec_permv32hi = 6642,
CODE_FOR_vec_permv64qi = 6643,
CODE_FOR_vec_perm_constv4sf = 6644,
CODE_FOR_vec_perm_constv4si = 6645,
CODE_FOR_vec_perm_constv2df = 6646,
CODE_FOR_vec_perm_constv2di = 6647,
CODE_FOR_vec_perm_constv16qi = 6648,
CODE_FOR_vec_perm_constv8hi = 6649,
CODE_FOR_vec_perm_constv8sf = 6650,
CODE_FOR_vec_perm_constv4df = 6651,
CODE_FOR_vec_perm_constv8si = 6652,
CODE_FOR_vec_perm_constv4di = 6653,
CODE_FOR_vec_perm_constv32qi = 6654,
CODE_FOR_vec_perm_constv16hi = 6655,
CODE_FOR_vec_perm_constv16si = 6656,
CODE_FOR_vec_perm_constv8di = 6657,
CODE_FOR_vec_perm_constv16sf = 6658,
CODE_FOR_vec_perm_constv8df = 6659,
CODE_FOR_vec_perm_constv32hi = 6660,
CODE_FOR_vec_perm_constv64qi = 6661,
CODE_FOR_one_cmplv16si2 = 6662,
CODE_FOR_one_cmplv8di2 = 6663,
CODE_FOR_one_cmplv64qi2 = 6664,
CODE_FOR_one_cmplv32qi2 = 6665,
CODE_FOR_one_cmplv16qi2 = 6666,
CODE_FOR_one_cmplv32hi2 = 6667,
CODE_FOR_one_cmplv16hi2 = 6668,
CODE_FOR_one_cmplv8hi2 = 6669,
CODE_FOR_one_cmplv8si2 = 6670,
CODE_FOR_one_cmplv4si2 = 6671,
CODE_FOR_one_cmplv4di2 = 6672,
CODE_FOR_one_cmplv2di2 = 6673,
CODE_FOR_avx512bw_andnotv64qi3 = 6674,
CODE_FOR_avx2_andnotv32qi3 = 6675,
CODE_FOR_sse2_andnotv16qi3 = 6676,
CODE_FOR_avx512bw_andnotv32hi3 = 6677,
CODE_FOR_avx2_andnotv16hi3 = 6678,
CODE_FOR_sse2_andnotv8hi3 = 6679,
CODE_FOR_avx512f_andnotv16si3 = 6680,
CODE_FOR_avx2_andnotv8si3 = 6681,
CODE_FOR_sse2_andnotv4si3 = 6682,
CODE_FOR_avx512f_andnotv8di3 = 6683,
CODE_FOR_avx2_andnotv4di3 = 6684,
CODE_FOR_sse2_andnotv2di3 = 6685,
CODE_FOR_avx512f_andnotv16si3_mask = 6686,
CODE_FOR_avx2_andnotv8si3_mask = 6687,
CODE_FOR_sse2_andnotv4si3_mask = 6688,
CODE_FOR_avx512f_andnotv8di3_mask = 6689,
CODE_FOR_avx2_andnotv4di3_mask = 6690,
CODE_FOR_sse2_andnotv2di3_mask = 6691,
CODE_FOR_avx512bw_andnotv64qi3_mask = 6692,
CODE_FOR_sse2_andnotv16qi3_mask = 6693,
CODE_FOR_avx2_andnotv32qi3_mask = 6694,
CODE_FOR_avx512bw_andnotv32hi3_mask = 6695,
CODE_FOR_avx2_andnotv16hi3_mask = 6696,
CODE_FOR_sse2_andnotv8hi3_mask = 6697,
CODE_FOR_andv16si3 = 6698,
CODE_FOR_iorv16si3 = 6699,
CODE_FOR_xorv16si3 = 6700,
CODE_FOR_andv8di3 = 6701,
CODE_FOR_iorv8di3 = 6702,
CODE_FOR_xorv8di3 = 6703,
CODE_FOR_andv64qi3 = 6704,
CODE_FOR_iorv64qi3 = 6705,
CODE_FOR_xorv64qi3 = 6706,
CODE_FOR_andv32qi3 = 6707,
CODE_FOR_iorv32qi3 = 6708,
CODE_FOR_xorv32qi3 = 6709,
CODE_FOR_andv16qi3 = 6710,
CODE_FOR_iorv16qi3 = 6711,
CODE_FOR_xorv16qi3 = 6712,
CODE_FOR_andv32hi3 = 6713,
CODE_FOR_iorv32hi3 = 6714,
CODE_FOR_xorv32hi3 = 6715,
CODE_FOR_andv16hi3 = 6716,
CODE_FOR_iorv16hi3 = 6717,
CODE_FOR_xorv16hi3 = 6718,
CODE_FOR_andv8hi3 = 6719,
CODE_FOR_iorv8hi3 = 6720,
CODE_FOR_xorv8hi3 = 6721,
CODE_FOR_andv8si3 = 6722,
CODE_FOR_iorv8si3 = 6723,
CODE_FOR_xorv8si3 = 6724,
CODE_FOR_andv4si3 = 6725,
CODE_FOR_iorv4si3 = 6726,
CODE_FOR_xorv4si3 = 6727,
CODE_FOR_andv4di3 = 6728,
CODE_FOR_iorv4di3 = 6729,
CODE_FOR_xorv4di3 = 6730,
CODE_FOR_andv2di3 = 6731,
CODE_FOR_iorv2di3 = 6732,
CODE_FOR_xorv2di3 = 6733,
CODE_FOR_vec_pack_trunc_v32hi = 6734,
CODE_FOR_vec_pack_trunc_v16hi = 6735,
CODE_FOR_vec_pack_trunc_v8hi = 6736,
CODE_FOR_vec_pack_trunc_v16si = 6737,
CODE_FOR_vec_pack_trunc_v8si = 6738,
CODE_FOR_vec_pack_trunc_v4si = 6739,
CODE_FOR_vec_pack_trunc_v8di = 6740,
CODE_FOR_vec_pack_trunc_v4di = 6741,
CODE_FOR_vec_pack_trunc_v2di = 6742,
CODE_FOR_vec_pack_trunc_qi = 6743,
CODE_FOR_vec_pack_trunc_hi = 6744,
CODE_FOR_vec_pack_trunc_si = 6745,
CODE_FOR_vec_interleave_highv32qi = 6746,
CODE_FOR_vec_interleave_highv16hi = 6747,
CODE_FOR_vec_interleave_highv8si = 6748,
CODE_FOR_vec_interleave_highv4di = 6749,
CODE_FOR_vec_interleave_lowv32qi = 6750,
CODE_FOR_vec_interleave_lowv16hi = 6751,
CODE_FOR_vec_interleave_lowv8si = 6752,
CODE_FOR_vec_interleave_lowv4di = 6753,
CODE_FOR_avx512dq_vinsertf64x2_mask = 6754,
CODE_FOR_avx512dq_vinserti64x2_mask = 6755,
CODE_FOR_avx512f_vinsertf32x4_mask = 6756,
CODE_FOR_avx512f_vinserti32x4_mask = 6757,
CODE_FOR_avx512dq_vinsertf32x8_mask = 6758,
CODE_FOR_avx512dq_vinserti32x8_mask = 6759,
CODE_FOR_avx512f_vinsertf64x4_mask = 6760,
CODE_FOR_avx512f_vinserti64x4_mask = 6761,
CODE_FOR_avx512dq_shuf_i64x2_mask = 6762,
CODE_FOR_avx512dq_shuf_f64x2_mask = 6763,
CODE_FOR_avx512f_shuf_f64x2_mask = 6764,
CODE_FOR_avx512f_shuf_i64x2_mask = 6765,
CODE_FOR_avx512vl_shuf_i32x4_mask = 6766,
CODE_FOR_avx512vl_shuf_f32x4_mask = 6767,
CODE_FOR_avx512f_shuf_f32x4_mask = 6768,
CODE_FOR_avx512f_shuf_i32x4_mask = 6769,
CODE_FOR_avx512f_pshufdv3_mask = 6770,
CODE_FOR_avx512vl_pshufdv3_mask = 6771,
CODE_FOR_avx2_pshufdv3 = 6772,
CODE_FOR_avx512vl_pshufd_mask = 6773,
CODE_FOR_sse2_pshufd = 6774,
CODE_FOR_avx512vl_pshuflwv3_mask = 6775,
CODE_FOR_avx2_pshuflwv3 = 6776,
CODE_FOR_avx512vl_pshuflw_mask = 6777,
CODE_FOR_sse2_pshuflw = 6778,
CODE_FOR_avx2_pshufhwv3 = 6779,
CODE_FOR_avx512vl_pshufhwv3_mask = 6780,
CODE_FOR_avx512vl_pshufhw_mask = 6781,
CODE_FOR_sse2_pshufhw = 6782,
CODE_FOR_sse2_loadd = 6783,
CODE_FOR_vec_unpacks_lo_v64qi = 6784,
CODE_FOR_vec_unpacks_lo_v32qi = 6785,
CODE_FOR_vec_unpacks_lo_v16qi = 6786,
CODE_FOR_vec_unpacks_lo_v32hi = 6787,
CODE_FOR_vec_unpacks_lo_v16hi = 6788,
CODE_FOR_vec_unpacks_lo_v8hi = 6789,
CODE_FOR_vec_unpacks_lo_v16si = 6790,
CODE_FOR_vec_unpacks_lo_v8si = 6791,
CODE_FOR_vec_unpacks_lo_v4si = 6792,
CODE_FOR_vec_unpacks_hi_v64qi = 6793,
CODE_FOR_vec_unpacks_hi_v32qi = 6794,
CODE_FOR_vec_unpacks_hi_v16qi = 6795,
CODE_FOR_vec_unpacks_hi_v32hi = 6796,
CODE_FOR_vec_unpacks_hi_v16hi = 6797,
CODE_FOR_vec_unpacks_hi_v8hi = 6798,
CODE_FOR_vec_unpacks_hi_v16si = 6799,
CODE_FOR_vec_unpacks_hi_v8si = 6800,
CODE_FOR_vec_unpacks_hi_v4si = 6801,
CODE_FOR_vec_unpacku_lo_v64qi = 6802,
CODE_FOR_vec_unpacku_lo_v32qi = 6803,
CODE_FOR_vec_unpacku_lo_v16qi = 6804,
CODE_FOR_vec_unpacku_lo_v32hi = 6805,
CODE_FOR_vec_unpacku_lo_v16hi = 6806,
CODE_FOR_vec_unpacku_lo_v8hi = 6807,
CODE_FOR_vec_unpacku_lo_v16si = 6808,
CODE_FOR_vec_unpacku_lo_v8si = 6809,
CODE_FOR_vec_unpacku_lo_v4si = 6810,
CODE_FOR_vec_unpacks_lo_hi = 6811,
CODE_FOR_vec_unpacks_lo_si = 6812,
CODE_FOR_vec_unpacks_lo_di = 6813,
CODE_FOR_vec_unpacku_hi_v64qi = 6814,
CODE_FOR_vec_unpacku_hi_v32qi = 6815,
CODE_FOR_vec_unpacku_hi_v16qi = 6816,
CODE_FOR_vec_unpacku_hi_v32hi = 6817,
CODE_FOR_vec_unpacku_hi_v16hi = 6818,
CODE_FOR_vec_unpacku_hi_v8hi = 6819,
CODE_FOR_vec_unpacku_hi_v16si = 6820,
CODE_FOR_vec_unpacku_hi_v8si = 6821,
CODE_FOR_vec_unpacku_hi_v4si = 6822,
CODE_FOR_vec_unpacks_hi_hi = 6823,
CODE_FOR_vec_unpacks_hi_si = 6824,
CODE_FOR_vec_unpacks_hi_di = 6825,
CODE_FOR_avx512bw_uavgv64qi3 = 6826,
CODE_FOR_avx512bw_uavgv64qi3_mask = 6827,
CODE_FOR_avx2_uavgv32qi3 = 6828,
CODE_FOR_avx2_uavgv32qi3_mask = 6829,
CODE_FOR_sse2_uavgv16qi3 = 6830,
CODE_FOR_sse2_uavgv16qi3_mask = 6831,
CODE_FOR_avx512bw_uavgv32hi3 = 6832,
CODE_FOR_avx512bw_uavgv32hi3_mask = 6833,
CODE_FOR_avx2_uavgv16hi3 = 6834,
CODE_FOR_avx2_uavgv16hi3_mask = 6835,
CODE_FOR_sse2_uavgv8hi3 = 6836,
CODE_FOR_sse2_uavgv8hi3_mask = 6837,
CODE_FOR_sse2_maskmovdqu = 6838,
CODE_FOR_ssse3_pmulhrswv4hi3_mask = 6839,
CODE_FOR_ssse3_pmulhrswv8hi3_mask = 6840,
CODE_FOR_avx2_pmulhrswv16hi3_mask = 6841,
CODE_FOR_ssse3_pmulhrswv4hi3 = 6842,
CODE_FOR_ssse3_pmulhrswv8hi3 = 6843,
CODE_FOR_avx2_pmulhrswv16hi3 = 6844,
CODE_FOR_absv64qi2 = 6845,
CODE_FOR_absv32qi2 = 6846,
CODE_FOR_absv16qi2 = 6847,
CODE_FOR_absv32hi2 = 6848,
CODE_FOR_absv16hi2 = 6849,
CODE_FOR_absv8hi2 = 6850,
CODE_FOR_absv16si2 = 6851,
CODE_FOR_absv8si2 = 6852,
CODE_FOR_absv4si2 = 6853,
CODE_FOR_absv8di2 = 6854,
CODE_FOR_absv4di2 = 6855,
CODE_FOR_absv2di2 = 6856,
CODE_FOR_avx2_pblendw = 6857,
CODE_FOR_avx_roundps_sfix256 = 6858,
CODE_FOR_sse4_1_roundps_sfix = 6859,
CODE_FOR_avx512f_roundps512 = 6860,
CODE_FOR_avx512f_roundpd512 = 6861,
CODE_FOR_avx512f_roundps512_sfix = 6862,
CODE_FOR_avx512f_roundpd_vec_pack_sfix512 = 6863,
CODE_FOR_avx_roundpd_vec_pack_sfix256 = 6864,
CODE_FOR_sse4_1_roundpd_vec_pack_sfix = 6865,
CODE_FOR_roundv16sf2 = 6866,
CODE_FOR_roundv8sf2 = 6867,
CODE_FOR_roundv4sf2 = 6868,
CODE_FOR_roundv8df2 = 6869,
CODE_FOR_roundv4df2 = 6870,
CODE_FOR_roundv2df2 = 6871,
CODE_FOR_roundv16sf2_sfix = 6872,
CODE_FOR_roundv8sf2_sfix = 6873,
CODE_FOR_roundv4sf2_sfix = 6874,
CODE_FOR_roundv8df2_vec_pack_sfix = 6875,
CODE_FOR_roundv4df2_vec_pack_sfix = 6876,
CODE_FOR_roundv2df2_vec_pack_sfix = 6877,
CODE_FOR_avx512pf_gatherpfv16sisf = 6878,
CODE_FOR_avx512pf_gatherpfv8disf = 6879,
CODE_FOR_avx512pf_gatherpfv8sidf = 6880,
CODE_FOR_avx512pf_gatherpfv8didf = 6881,
CODE_FOR_avx512pf_scatterpfv16sisf = 6882,
CODE_FOR_avx512pf_scatterpfv8disf = 6883,
CODE_FOR_avx512pf_scatterpfv8sidf = 6884,
CODE_FOR_avx512pf_scatterpfv8didf = 6885,
CODE_FOR_rotlv16qi3 = 6886,
CODE_FOR_rotlv8hi3 = 6887,
CODE_FOR_rotlv4si3 = 6888,
CODE_FOR_rotlv2di3 = 6889,
CODE_FOR_rotrv16qi3 = 6890,
CODE_FOR_rotrv8hi3 = 6891,
CODE_FOR_rotrv4si3 = 6892,
CODE_FOR_rotrv2di3 = 6893,
CODE_FOR_vrotrv16qi3 = 6894,
CODE_FOR_vrotrv8hi3 = 6895,
CODE_FOR_vrotrv4si3 = 6896,
CODE_FOR_vrotrv2di3 = 6897,
CODE_FOR_vrotlv16qi3 = 6898,
CODE_FOR_vrotlv8hi3 = 6899,
CODE_FOR_vrotlv4si3 = 6900,
CODE_FOR_vrotlv2di3 = 6901,
CODE_FOR_vlshrv16qi3 = 6902,
CODE_FOR_vlshrv8hi3 = 6903,
CODE_FOR_vlshrv4si3 = 6904,
CODE_FOR_vlshrv2di3 = 6905,
CODE_FOR_vlshrv16si3 = 6906,
CODE_FOR_vlshrv8di3 = 6907,
CODE_FOR_vlshrv8si3 = 6908,
CODE_FOR_vlshrv4di3 = 6909,
CODE_FOR_vashrv8hi3 = 6910,
CODE_FOR_vashrv8hi3_mask = 6911,
CODE_FOR_vashrv16qi3 = 6912,
CODE_FOR_vashrv2di3 = 6913,
CODE_FOR_vashrv2di3_mask = 6914,
CODE_FOR_vashrv4si3 = 6915,
CODE_FOR_vashrv16si3 = 6916,
CODE_FOR_vashrv8si3 = 6917,
CODE_FOR_vashlv16qi3 = 6918,
CODE_FOR_vashlv8hi3 = 6919,
CODE_FOR_vashlv4si3 = 6920,
CODE_FOR_vashlv2di3 = 6921,
CODE_FOR_vashlv16si3 = 6922,
CODE_FOR_vashlv8di3 = 6923,
CODE_FOR_vashlv8si3 = 6924,
CODE_FOR_vashlv4di3 = 6925,
CODE_FOR_ashlv64qi3 = 6926,
CODE_FOR_lshrv64qi3 = 6927,
CODE_FOR_ashrv64qi3 = 6928,
CODE_FOR_ashlv32qi3 = 6929,
CODE_FOR_lshrv32qi3 = 6930,
CODE_FOR_ashrv32qi3 = 6931,
CODE_FOR_ashlv16qi3 = 6932,
CODE_FOR_lshrv16qi3 = 6933,
CODE_FOR_ashrv16qi3 = 6934,
CODE_FOR_ashrv2di3 = 6935,
CODE_FOR_xop_vmfrczv4sf2 = 6936,
CODE_FOR_xop_vmfrczv2df2 = 6937,
CODE_FOR_avx_vzeroall = 6938,
CODE_FOR_avx2_permv4di = 6939,
CODE_FOR_avx2_permv4df = 6940,
CODE_FOR_avx512vl_permv4di_mask = 6941,
CODE_FOR_avx512vl_permv4df_mask = 6942,
CODE_FOR_avx512f_permv8df = 6943,
CODE_FOR_avx512f_permv8di = 6944,
CODE_FOR_avx512f_permv8df_mask = 6945,
CODE_FOR_avx512f_permv8di_mask = 6946,
CODE_FOR_avx512f_vpermilv8df = 6947,
CODE_FOR_avx512f_vpermilv8df_mask = 6948,
CODE_FOR_avx_vpermilv4df = 6949,
CODE_FOR_avx_vpermilv4df_mask = 6950,
CODE_FOR_avx_vpermilv2df = 6951,
CODE_FOR_avx_vpermilv2df_mask = 6952,
CODE_FOR_avx512f_vpermilv16sf = 6953,
CODE_FOR_avx512f_vpermilv16sf_mask = 6954,
CODE_FOR_avx_vpermilv8sf = 6955,
CODE_FOR_avx_vpermilv8sf_mask = 6956,
CODE_FOR_avx_vpermilv4sf = 6957,
CODE_FOR_avx_vpermilv4sf_mask = 6958,
CODE_FOR_avx512f_vpermi2varv16si3_maskz = 6959,
CODE_FOR_avx512f_vpermi2varv16sf3_maskz = 6960,
CODE_FOR_avx512f_vpermi2varv8di3_maskz = 6961,
CODE_FOR_avx512f_vpermi2varv8df3_maskz = 6962,
CODE_FOR_avx512vl_vpermi2varv8si3_maskz = 6963,
CODE_FOR_avx512vl_vpermi2varv8sf3_maskz = 6964,
CODE_FOR_avx512vl_vpermi2varv4di3_maskz = 6965,
CODE_FOR_avx512vl_vpermi2varv4df3_maskz = 6966,
CODE_FOR_avx512vl_vpermi2varv4si3_maskz = 6967,
CODE_FOR_avx512vl_vpermi2varv4sf3_maskz = 6968,
CODE_FOR_avx512vl_vpermi2varv2di3_maskz = 6969,
CODE_FOR_avx512vl_vpermi2varv2df3_maskz = 6970,
CODE_FOR_avx512bw_vpermi2varv64qi3_maskz = 6971,
CODE_FOR_avx512vl_vpermi2varv16qi3_maskz = 6972,
CODE_FOR_avx512vl_vpermi2varv32qi3_maskz = 6973,
CODE_FOR_avx512vl_vpermi2varv8hi3_maskz = 6974,
CODE_FOR_avx512vl_vpermi2varv16hi3_maskz = 6975,
CODE_FOR_avx512bw_vpermi2varv32hi3_maskz = 6976,
CODE_FOR_avx512f_vpermt2varv16si3_maskz = 6977,
CODE_FOR_avx512f_vpermt2varv16sf3_maskz = 6978,
CODE_FOR_avx512f_vpermt2varv8di3_maskz = 6979,
CODE_FOR_avx512f_vpermt2varv8df3_maskz = 6980,
CODE_FOR_avx512vl_vpermt2varv8si3_maskz = 6981,
CODE_FOR_avx512vl_vpermt2varv8sf3_maskz = 6982,
CODE_FOR_avx512vl_vpermt2varv4di3_maskz = 6983,
CODE_FOR_avx512vl_vpermt2varv4df3_maskz = 6984,
CODE_FOR_avx512vl_vpermt2varv4si3_maskz = 6985,
CODE_FOR_avx512vl_vpermt2varv4sf3_maskz = 6986,
CODE_FOR_avx512vl_vpermt2varv2di3_maskz = 6987,
CODE_FOR_avx512vl_vpermt2varv2df3_maskz = 6988,
CODE_FOR_avx512bw_vpermt2varv64qi3_maskz = 6989,
CODE_FOR_avx512vl_vpermt2varv16qi3_maskz = 6990,
CODE_FOR_avx512vl_vpermt2varv32qi3_maskz = 6991,
CODE_FOR_avx512vl_vpermt2varv8hi3_maskz = 6992,
CODE_FOR_avx512vl_vpermt2varv16hi3_maskz = 6993,
CODE_FOR_avx512bw_vpermt2varv32hi3_maskz = 6994,
CODE_FOR_avx_vperm2f128v8si3 = 6995,
CODE_FOR_avx_vperm2f128v8sf3 = 6996,
CODE_FOR_avx_vperm2f128v4df3 = 6997,
CODE_FOR_avx512vl_vinsertv8si = 6998,
CODE_FOR_avx512vl_vinsertv8sf = 6999,
CODE_FOR_avx512vl_vinsertv4di = 7000,
CODE_FOR_avx512vl_vinsertv4df = 7001,
CODE_FOR_avx_vinsertf128v32qi = 7002,
CODE_FOR_avx_vinsertf128v16hi = 7003,
CODE_FOR_avx_vinsertf128v8si = 7004,
CODE_FOR_avx_vinsertf128v4di = 7005,
CODE_FOR_avx_vinsertf128v8sf = 7006,
CODE_FOR_avx_vinsertf128v4df = 7007,
CODE_FOR_maskloadv4sfv4si = 7008,
CODE_FOR_maskloadv2dfv2di = 7009,
CODE_FOR_maskloadv8sfv8si = 7010,
CODE_FOR_maskloadv4dfv4di = 7011,
CODE_FOR_maskloadv4siv4si = 7012,
CODE_FOR_maskloadv2div2di = 7013,
CODE_FOR_maskloadv8siv8si = 7014,
CODE_FOR_maskloadv4div4di = 7015,
CODE_FOR_maskloadv16sihi = 7016,
CODE_FOR_maskloadv8siqi = 7017,
CODE_FOR_maskloadv4siqi = 7018,
CODE_FOR_maskloadv8diqi = 7019,
CODE_FOR_maskloadv4diqi = 7020,
CODE_FOR_maskloadv2diqi = 7021,
CODE_FOR_maskloadv16sfhi = 7022,
CODE_FOR_maskloadv8sfqi = 7023,
CODE_FOR_maskloadv4sfqi = 7024,
CODE_FOR_maskloadv8dfqi = 7025,
CODE_FOR_maskloadv4dfqi = 7026,
CODE_FOR_maskloadv2dfqi = 7027,
CODE_FOR_maskloadv64qidi = 7028,
CODE_FOR_maskloadv16qihi = 7029,
CODE_FOR_maskloadv32qisi = 7030,
CODE_FOR_maskloadv32hisi = 7031,
CODE_FOR_maskloadv16hihi = 7032,
CODE_FOR_maskloadv8hiqi = 7033,
CODE_FOR_maskstorev4sfv4si = 7034,
CODE_FOR_maskstorev2dfv2di = 7035,
CODE_FOR_maskstorev8sfv8si = 7036,
CODE_FOR_maskstorev4dfv4di = 7037,
CODE_FOR_maskstorev4siv4si = 7038,
CODE_FOR_maskstorev2div2di = 7039,
CODE_FOR_maskstorev8siv8si = 7040,
CODE_FOR_maskstorev4div4di = 7041,
CODE_FOR_maskstorev16sihi = 7042,
CODE_FOR_maskstorev8siqi = 7043,
CODE_FOR_maskstorev4siqi = 7044,
CODE_FOR_maskstorev8diqi = 7045,
CODE_FOR_maskstorev4diqi = 7046,
CODE_FOR_maskstorev2diqi = 7047,
CODE_FOR_maskstorev16sfhi = 7048,
CODE_FOR_maskstorev8sfqi = 7049,
CODE_FOR_maskstorev4sfqi = 7050,
CODE_FOR_maskstorev8dfqi = 7051,
CODE_FOR_maskstorev4dfqi = 7052,
CODE_FOR_maskstorev2dfqi = 7053,
CODE_FOR_maskstorev64qidi = 7054,
CODE_FOR_maskstorev16qihi = 7055,
CODE_FOR_maskstorev32qisi = 7056,
CODE_FOR_maskstorev32hisi = 7057,
CODE_FOR_maskstorev16hihi = 7058,
CODE_FOR_maskstorev8hiqi = 7059,
CODE_FOR_cbranchv4si4 = 7060,
CODE_FOR_cbranchv2di4 = 7061,
CODE_FOR_cbranchv8si4 = 7062,
CODE_FOR_cbranchv4di4 = 7063,
CODE_FOR_vec_initv32qi = 7064,
CODE_FOR_vec_initv16hi = 7065,
CODE_FOR_vec_initv8si = 7066,
CODE_FOR_vec_initv4di = 7067,
CODE_FOR_vec_initv8sf = 7068,
CODE_FOR_vec_initv4df = 7069,
CODE_FOR_vec_initv16si = 7070,
CODE_FOR_vec_initv16sf = 7071,
CODE_FOR_vec_initv8di = 7072,
CODE_FOR_vec_initv8df = 7073,
CODE_FOR_vec_initv32hi = 7074,
CODE_FOR_vec_initv64qi = 7075,
CODE_FOR_vcvtps2ph_mask = 7076,
CODE_FOR_vcvtps2ph = 7077,
CODE_FOR_avx2_gathersiv2di = 7078,
CODE_FOR_avx2_gathersiv2df = 7079,
CODE_FOR_avx2_gathersiv4di = 7080,
CODE_FOR_avx2_gathersiv4df = 7081,
CODE_FOR_avx2_gathersiv4si = 7082,
CODE_FOR_avx2_gathersiv4sf = 7083,
CODE_FOR_avx2_gathersiv8si = 7084,
CODE_FOR_avx2_gathersiv8sf = 7085,
CODE_FOR_avx2_gatherdiv2di = 7086,
CODE_FOR_avx2_gatherdiv2df = 7087,
CODE_FOR_avx2_gatherdiv4di = 7088,
CODE_FOR_avx2_gatherdiv4df = 7089,
CODE_FOR_avx2_gatherdiv4si = 7090,
CODE_FOR_avx2_gatherdiv4sf = 7091,
CODE_FOR_avx2_gatherdiv8si = 7092,
CODE_FOR_avx2_gatherdiv8sf = 7093,
CODE_FOR_avx512f_gathersiv16si = 7094,
CODE_FOR_avx512f_gathersiv16sf = 7095,
CODE_FOR_avx512f_gathersiv8di = 7096,
CODE_FOR_avx512f_gathersiv8df = 7097,
CODE_FOR_avx512vl_gathersiv8si = 7098,
CODE_FOR_avx512vl_gathersiv8sf = 7099,
CODE_FOR_avx512vl_gathersiv4di = 7100,
CODE_FOR_avx512vl_gathersiv4df = 7101,
CODE_FOR_avx512vl_gathersiv4si = 7102,
CODE_FOR_avx512vl_gathersiv4sf = 7103,
CODE_FOR_avx512vl_gathersiv2di = 7104,
CODE_FOR_avx512vl_gathersiv2df = 7105,
CODE_FOR_avx512f_gatherdiv16si = 7106,
CODE_FOR_avx512f_gatherdiv16sf = 7107,
CODE_FOR_avx512f_gatherdiv8di = 7108,
CODE_FOR_avx512f_gatherdiv8df = 7109,
CODE_FOR_avx512vl_gatherdiv8si = 7110,
CODE_FOR_avx512vl_gatherdiv8sf = 7111,
CODE_FOR_avx512vl_gatherdiv4di = 7112,
CODE_FOR_avx512vl_gatherdiv4df = 7113,
CODE_FOR_avx512vl_gatherdiv4si = 7114,
CODE_FOR_avx512vl_gatherdiv4sf = 7115,
CODE_FOR_avx512vl_gatherdiv2di = 7116,
CODE_FOR_avx512vl_gatherdiv2df = 7117,
CODE_FOR_avx512f_scattersiv16si = 7118,
CODE_FOR_avx512f_scattersiv16sf = 7119,
CODE_FOR_avx512f_scattersiv8di = 7120,
CODE_FOR_avx512f_scattersiv8df = 7121,
CODE_FOR_avx512vl_scattersiv8si = 7122,
CODE_FOR_avx512vl_scattersiv8sf = 7123,
CODE_FOR_avx512vl_scattersiv4di = 7124,
CODE_FOR_avx512vl_scattersiv4df = 7125,
CODE_FOR_avx512vl_scattersiv4si = 7126,
CODE_FOR_avx512vl_scattersiv4sf = 7127,
CODE_FOR_avx512vl_scattersiv2di = 7128,
CODE_FOR_avx512vl_scattersiv2df = 7129,
CODE_FOR_avx512f_scatterdiv16si = 7130,
CODE_FOR_avx512f_scatterdiv16sf = 7131,
CODE_FOR_avx512f_scatterdiv8di = 7132,
CODE_FOR_avx512f_scatterdiv8df = 7133,
CODE_FOR_avx512vl_scatterdiv8si = 7134,
CODE_FOR_avx512vl_scatterdiv8sf = 7135,
CODE_FOR_avx512vl_scatterdiv4di = 7136,
CODE_FOR_avx512vl_scatterdiv4df = 7137,
CODE_FOR_avx512vl_scatterdiv4si = 7138,
CODE_FOR_avx512vl_scatterdiv4sf = 7139,
CODE_FOR_avx512vl_scatterdiv2di = 7140,
CODE_FOR_avx512vl_scatterdiv2df = 7141,
CODE_FOR_avx512f_expandv16si_maskz = 7142,
CODE_FOR_avx512f_expandv16sf_maskz = 7143,
CODE_FOR_avx512f_expandv8di_maskz = 7144,
CODE_FOR_avx512f_expandv8df_maskz = 7145,
CODE_FOR_avx512vl_expandv8si_maskz = 7146,
CODE_FOR_avx512vl_expandv8sf_maskz = 7147,
CODE_FOR_avx512vl_expandv4di_maskz = 7148,
CODE_FOR_avx512vl_expandv4df_maskz = 7149,
CODE_FOR_avx512vl_expandv4si_maskz = 7150,
CODE_FOR_avx512vl_expandv4sf_maskz = 7151,
CODE_FOR_avx512vl_expandv2di_maskz = 7152,
CODE_FOR_avx512vl_expandv2df_maskz = 7153,
CODE_FOR_vpamdd52huqv8di_maskz = 7154,
CODE_FOR_vpamdd52huqv4di_maskz = 7155,
CODE_FOR_vpamdd52huqv2di_maskz = 7156,
CODE_FOR_vpamdd52luqv8di_maskz = 7157,
CODE_FOR_vpamdd52luqv4di_maskz = 7158,
CODE_FOR_vpamdd52luqv2di_maskz = 7159,
CODE_FOR_movv64sf = 7160,
CODE_FOR_movv64si = 7161,
CODE_FOR_sse2_lfence = 7162,
CODE_FOR_sse_sfence = 7163,
CODE_FOR_sse2_mfence = 7164,
CODE_FOR_mem_thread_fence = 7165,
CODE_FOR_atomic_loadqi = 7166,
CODE_FOR_atomic_loadhi = 7167,
CODE_FOR_atomic_loadsi = 7168,
CODE_FOR_atomic_loaddi = 7169,
CODE_FOR_atomic_storeqi = 7170,
CODE_FOR_atomic_storehi = 7171,
CODE_FOR_atomic_storesi = 7172,
CODE_FOR_atomic_storedi = 7173,
CODE_FOR_atomic_compare_and_swapqi = 7174,
CODE_FOR_atomic_compare_and_swaphi = 7175,
CODE_FOR_atomic_compare_and_swapsi = 7176,
CODE_FOR_atomic_compare_and_swapdi = 7177,
CODE_FOR_atomic_compare_and_swapti = 7178,
CODE_FOR_atomic_bit_test_and_sethi = 7179,
CODE_FOR_atomic_bit_test_and_setsi = 7180,
CODE_FOR_atomic_bit_test_and_setdi = 7181,
CODE_FOR_atomic_bit_test_and_complementhi = 7182,
CODE_FOR_atomic_bit_test_and_complementsi = 7183,
CODE_FOR_atomic_bit_test_and_complementdi = 7184,
CODE_FOR_atomic_bit_test_and_resethi = 7185,
CODE_FOR_atomic_bit_test_and_resetsi = 7186,
CODE_FOR_atomic_bit_test_and_resetdi = 7187
};
const unsigned int NUM_INSN_CODES = 7188;
#endif /* GCC_INSN_CODES_H */ | c |
assignment-6/my-solution/test/demo/expat-demo/namespace.c | helloShen/programming-paradigms | 0 | 7076302 | /*****************************************************************
* namespace.c
*
* Copyright 1999, <NAME>
* All rights reserved.
*
* This program is free software; you can distribute it and/or modify
* it under the same terms as Perl.
*
*================================================================
*
* Read an XML document from standard input and print an element outline
* (but only to depth MAX_INDENT) annotated with namespace scope.
*
*/
#include <stdio.h>
#include <unistd.h>
#include <errno.h>
#include "xmlparse.h"
#define CHUNK_SIZE 8192
#define MAX_INDENT 30
typedef struct app_data {
int depth;
char indent[MAX_INDENT * 2];
} AppData;
void
start(void *data, const char *el, const char **attr) {
AppData *ad = (AppData *) data;
int i;
if (ad->depth < MAX_INDENT) {
char *indent_tail = &ad->indent[ad->depth * 2];
*indent_tail++ = ' ';
*indent_tail++ = ' ';
*indent_tail = '\0';
printf("%s%s:\n", ad->indent, el);
for (i = 0; attr[i]; i += 2) {
printf("%s-Attr: %s = %s\n", ad->indent, attr[i], attr[i + 1]);
}
}
else if (ad->depth == MAX_INDENT) {
printf ("%s ****\n", ad->indent);
}
ad->depth++;
} /* End start */
void
end(void *data, const char *el) {
AppData *ad = (AppData *) data;
ad->depth--;
ad->indent[ad->depth * 2] = '\0';
} /* End end */
void
ns_start(void *data, const char *prefix, const char *uri) {
AppData *ad = (AppData *) data;
printf("%s ++NS %s => %s\n", ad->indent,
prefix ? prefix : "(null)",
uri ? uri : "(null)");
} /* End ns_start */
void
ns_end(void *data, const char *prefix) {
AppData *ad = (AppData *) data;
printf("%s --NS %s\n", ad->indent, prefix ? prefix : "(null)");
} /* End ns_end */
AppData *
newAppData() {
AppData *ret;
ret = (AppData *) malloc(sizeof(AppData));
if (ret == NULL) {
fprintf(stderr, "Couldn't allocate memory for application data\n");
exit(-1);
}
/* Initialize */
ret->depth = 0;
ret->indent[0] = '\0';
} /* End */
void
main(int argc, char **argv) {
AppData *ad;
XML_Parser p = XML_ParserCreateNS(NULL, '|');
if (! p) {
fprintf(stderr, "Couldn't allocate memory for parser\n");
exit(-1);
}
ad = newAppData();
XML_SetUserData(p, (void *) ad);
XML_SetElementHandler(p, start, end);
XML_SetNamespaceDeclHandler(p, ns_start, ns_end);
for (;;) {
char *buff;
int len;
buff = XML_GetBuffer(p, CHUNK_SIZE);
if (! buff) {
fprintf(stderr, "Ran out of memory for parse buffer\n");
exit(-1);
}
len = read(0, buff, CHUNK_SIZE);
if (len < 0) {
perror("namespace - read error");
exit(-1);
}
if (! XML_ParseBuffer(p, len, len == 0)) {
fprintf(stderr, "Parse error at line %d:\n%s\n",
XML_GetCurrentLineNumber(p),
XML_ErrorString(XML_GetErrorCode(p)));
exit(-1);
}
if (len == 0)
break;
}
} /* End main */ | c |
cookbook/05-Plugin/PluginReposity/SignPlugin/SignPlugin.h | Jie-Fang/trt-samples-for-hackathon-cn | 0 | 5564868 | /*
* Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <NvInfer.h>
#define CEIL(x, y) (((x) + (y)-1) / (y))
using namespace nvinfer1;
class SignPlugin : public IPluginV2Ext
{
private:
struct
{
int nElement;
} m;
public:
int getNbOutputs() const override
{
return 1;
}
DataType getOutputDataType(int index, const DataType *inputTypes, int nbInputs) const
{
return DataType::kFLOAT;
}
Dims getOutputDimensions(int index, const Dims *pInputDim, int nInputDim) override
{
return pInputDim[0];
}
bool supportsFormat(DataType type, PluginFormat format) const override
{
return type == DataType::kFLOAT && format == PluginFormat::kNCHW;
}
size_t getWorkspaceSize(int nBatch) const override
{
return 0;
}
void configurePlugin(const Dims *inputDims, int nbInputs, const Dims *outputDims, int nbOutputs, const DataType *inputTypes, const DataType *outputTypes, const bool *inputIsBroadcast, const bool *outputIsBroadcast, PluginFormat floatFormat, int maxBatchSize)
{
m.nElement = inputDims[0].d[0];
}
int enqueue(int nBatch, const void *const *inputs, void **outputs, void *workspace, cudaStream_t stream) override;
SignPlugin() {}
SignPlugin(const void *buffer, size_t length)
{
memcpy(&m, buffer, sizeof(m));
}
IPluginV2Ext *clone() const override
{
return new SignPlugin(&m, sizeof(m));
}
int initialize() override
{
return 0;
}
void terminate() override {}
void destroy() override
{
delete this;
}
bool isOutputBroadcastAcrossBatch(int outputIndex, const bool *inputIsBroadcasted, int nbInputs) const
{
return false;
}
bool canBroadcastInputAcrossBatch(int inputIndex) const
{
return false;
}
void attachToContext(cudnnContext *contextCudnn, cublasContext *contextCublas, IGpuAllocator *gpuAllocator) {}
void detachFromContext() {}
const char *getPluginType() const override
{
return "SignPlugin";
}
const char *getPluginVersion() const override
{
return "0";
}
void setPluginNamespace(const char *szNamespace) override {}
const char *getPluginNamespace() const override
{
return "";
}
virtual size_t getSerializationSize() const override
{
return sizeof(m);
}
virtual void serialize(void *buffer) const override
{
memcpy(buffer, &m, sizeof(m));
}
};
class SignPluginCreator : public IPluginCreator
{
public:
IPluginV2 *createPlugin(const char *name, const PluginFieldCollection *fc) override
{
return new SignPlugin();
}
const char *getPluginName() const override
{
return "SignPlugin";
}
const char *getPluginVersion() const override
{
return "0";
}
void setPluginNamespace(const char *szNamespace) override {}
const char *getPluginNamespace() const override
{
return "";
}
const PluginFieldCollection *getFieldNames() override
{
return nullptr;
}
IPluginV2 *deserializePlugin(const char *name, const void *serialData, size_t serialLength) override
{
return new SignPlugin(serialData, serialLength);
}
}; | c |
HttpServer/ServiceThread.h | wangweijun120/HttpServer | 1 | 7333541 | #pragma once
#ifndef SERVICE_THREAD_H
#define SERVICE_THREAD_H
#include "Thread.h"
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>
#include "HttpRequest.h"
#include "HttpResponse.h"
#include "DefaultHttpProcessor.h"
#include "util.h"
#include "Server.h"
class ServiceThread : public Thread
{
public:
ServiceThread(int conn) {
this->conn = conn;
response.setConn(conn);
}
~ServiceThread() {
int a = 1;
cout << "123" << a<<endl;
}
void run()
{
try
{
read();
parse();
preDispatch();
dispatch();
}
catch (const std::exception)
{
close(conn);
}
close(conn);
}
void dispatch() {
if (request.getMethod() == "GET")
{
processor.doGet(request, response);
}
else if (request.getMethod() == "HEAD")
{
processor.doHead(request, response);
}
else if (request.getMethod() == "POST")
{
processor.doPost(request, response);
}
}
void read() {
while (true)
{
char buffer[1024];
memset(buffer, 0, sizeof(buffer));
printf("%s", buffer);
int len = recv(conn, buffer, sizeof(buffer), 0);
if (len <= 0)
{
break;
}
requestStr.append(buffer);
if (requestStr.find("\r\n\r\n") != -1)
break;
}
}
//存在一定问题
void parse() {
vector<string>vec = split(requestStr, "\r\n");
request.setRequestLine(vec[0]);
for (int i = 1; i < vec.size(); i++)
{
vector<string>header = split(vec[i], ":");
if (header.size() < 2)
continue;
request.addHeader(header[0], header[1]);
}
}
void preDispatch() {
char buf[30] = {0};
getGmtTime(buf);
response.addHeader("Date",string(buf) );
response.addHeader("Server", "my_server");
response.addHeader("Connection", "Close");
response.addHeader("Pragma","no-cache");
string uri = request.getUri();
int pos = uri.rfind(".");
if (pos!=-1)
{
string extensionName = uri.substr(pos+1);
response.addHeader("Content-Type", getType(extensionName));
}
}
private:
int conn;
HttpRequest request;
HttpResponse response;
DefaultHttpProcessor processor;
string requestStr;
};
#endif // !SERVICE_THREAD_H | c |
matlab/src/cpp/arrow/matlab/mex/mex_functions.h | davisusanibar/arrow | 1 | 7825226 | // Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
#include <string>
#include <functional>
#include <unordered_map>
#include <mex.h>
#include "arrow/matlab/feather/feather_functions.h"
namespace arrow {
namespace matlab {
namespace mex {
using namespace arrow::matlab::feather;
using mex_fcn_t =
std::function<void(int nlhs, mxArray* plhs[], int nrhs, const mxArray* prhs[])>;
static const std::unordered_map<std::string, mex_fcn_t> FUNCTION_MAP = {
{"featherread", featherread}, {"featherwrite", featherwrite}};
} // namespace mex
} // namespace matlab
} // namespace arrow | c |
dds.c | brianpopow/detex | 136 | 1951178 | /*
Copyright (c) 2015 <NAME> <<EMAIL>>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "detex.h"
#include "file-info.h"
#include "misc.h"
// Load texture from DDS file with mip-maps. Returns true if successful.
// nu_levels is a return parameter that returns the number of mipmap levels found.
// textures_out is a return parameter for an array of detexTexture pointers that is allocated,
// free with free(). textures_out[i] are allocated textures corresponding to each level, free
// with free();
bool detexLoadDDSFileWithMipmaps(const char *filename, int max_mipmaps, detexTexture ***textures_out,
int *nu_levels_out) {
FILE *f = fopen(filename, "rb");
if (f == NULL) {
detexSetErrorMessage("detexLoadDDSFileWithMipmaps: Could not open file %s", filename);
return false;
}
// Read signature.
char id[4];
size_t s = fread(id, 1, 4, f);
if (s != 4) {
detexSetErrorMessage("detexLoadDDSFileWithMipmaps: Error reading file %s", filename);
return false;
}
if (id[0] != 'D' || id[1] != 'D' || id[2] != 'S' || id[3] != ' ') {
detexSetErrorMessage("detexLoadDDSFileWithMipmaps: Couldn't find DDS signature");
return false;
}
uint8_t header[124];
s = fread(header, 1, 124, f);
if (s != 124) {
detexSetErrorMessage("detexLoadDDSFileWithMipmaps: Error reading file %s", filename);
return false;
}
uint8_t *headerp = &header[0];
int width = *(uint32_t *)(headerp + 12);
int height = *(uint32_t *)(headerp + 8);
// int pitch = *(uint32_t *)(headerp + 16);
int pixel_format_flags = *(uint32_t *)(headerp + 76);
int block_width = 4;
int block_height = 4;
int bitcount = *(uint32_t *)(headerp + 84);
uint32_t red_mask = *(uint32_t *)(headerp + 88);
uint32_t green_mask = *(uint32_t *)(headerp + 92);
uint32_t blue_mask = *(uint32_t *)(headerp + 96);
uint32_t alpha_mask = *(uint32_t *)(headerp + 100);
char four_cc[5];
strncpy(four_cc, (char *)&header[80], 4);
four_cc[4] = '\0';
uint32_t dx10_format = 0;
if (strncmp(four_cc, "DX10", 4) == 0) {
uint32_t dx10_header[5];
s = fread(dx10_header, 1, 20, f);
if (s != 20) {
detexSetErrorMessage("detexLoadDDSFileWithMipmaps: Error reading file %s", filename);
return false;
}
dx10_format = dx10_header[0];
uint32_t resource_dimension = dx10_header[1];
if (resource_dimension != 3) {
detexSetErrorMessage("detexLoadDDSFileWithMipmaps: Only 2D textures supported for .dds files");
return false;
}
}
const detexTextureFileInfo *info = detexLookupDDSFileInfo(four_cc, dx10_format, pixel_format_flags, bitcount,
red_mask, green_mask, blue_mask, alpha_mask);
if (info == NULL) {
detexSetErrorMessage("detexLoadDDSFileWithMipmaps: Unsupported format in .dds file (fourCC = %s, "
"DX10 format = %d).", four_cc, dx10_format);
return false;
}
// Maybe implement option to treat BC1 as BC1A?
int bytes_per_block;
if (detexFormatIsCompressed(info->texture_format))
bytes_per_block = detexGetCompressedBlockSize(info->texture_format);
else
bytes_per_block = detexGetPixelSize(info->texture_format);
block_width = info->block_width;
block_height = info->block_height;
int extended_width = ((width + block_width - 1) / block_width) * block_width;
int extended_height = ((height + block_height - 1) / block_height) * block_height;
uint32_t flags = *(uint32_t *)(headerp + 4);
int nu_file_mipmaps = 1;
if (flags & 0x20000) {
nu_file_mipmaps = *(uint32_t *)(headerp + 24);
// if (nu_file_mipmaps > 1 && max_mipmaps == 1) {
// detexSetErrorMessage("Disregarding mipmaps beyond the first level.\n");
// }
}
int nu_mipmaps;
if (nu_file_mipmaps > max_mipmaps)
nu_mipmaps = max_mipmaps;
else
nu_mipmaps = nu_file_mipmaps;
detexTexture **textures = (detexTexture **)malloc(sizeof(detexTexture *) * nu_mipmaps);
for (int i = 0; i < nu_mipmaps; i++) {
int n = (extended_height / block_width) * (extended_width / block_height);
// Allocate texture.
textures[i] = (detexTexture *)malloc(sizeof(detexTexture));
textures[i]->format = info->texture_format;
textures[i]->data = (uint8_t *)malloc(n * bytes_per_block);
textures[i]->width = width;
textures[i]->height = height;
textures[i]->width_in_blocks = extended_width / block_width;
textures[i]->height_in_blocks = extended_height / block_height;
size_t r = fread(textures[i]->data, 1, n * bytes_per_block, f);
if (r < n * bytes_per_block) {
detexSetErrorMessage("detexLoadDDSFileWithMipmaps: Error reading file %s", filename);
return false;
}
// Divide by two for the next mipmap level, rounding down.
width >>= 1;
height >>= 1;
extended_width = ((width + block_width - 1) / block_width) * block_width;
extended_height = ((height + block_height - 1) / block_height) * block_height;
}
fclose(f);
*nu_levels_out = nu_mipmaps;
*textures_out = textures;
return true;
}
// Load texture from DDS file (first mip-map only). Returns true if successful.
// The texture is allocated, free with free().
bool detexLoadDDSFile(const char *filename, detexTexture **texture_out) {
int nu_mipmaps;
detexTexture **textures;
bool r = detexLoadDDSFileWithMipmaps(filename, 1, &textures, &nu_mipmaps);
if (!r)
return false;
*texture_out = textures[0];
free(textures);
return true;
}
static const char dds_id[4] = {
'D', 'D', 'S', ' '
};
// Save textures to DDS file (multiple mip-maps levels). Return true if succesful.
bool detexSaveDDSFileWithMipmaps(detexTexture **textures, int nu_levels, const char *filename) {
FILE *f = fopen(filename, "wb");
if (f == NULL) {
detexSetErrorMessage("detexSaveDDSFileWithMipmaps: Could not open file %s for writing", filename);
return false;
}
const detexTextureFileInfo *info = detexLookupTextureFormatFileInfo(textures[0]->format);
if (info == NULL) {
detexSetErrorMessage("detexSaveDDSFileWithMipmaps: Could not match texture format with file format");
return false;
}
if (!info->dds_support) {
detexSetErrorMessage("detexSaveDDSFileWithMipmaps: Could not match texture format with DDS file format");
return false;
}
size_t r = fwrite(dds_id, 1, 4, f);
if (r != 4) {
detexSetErrorMessage("detexSaveDDSFileWithMipmaps: Error writing to file %s", filename);
return false;
}
int n;
int block_size;
if (detexFormatIsCompressed(textures[0]->format)) {
n = textures[0]->width_in_blocks * textures[0]->height_in_blocks;
block_size = detexGetCompressedBlockSize(textures[0]->format);
}
else {
n = textures[0]->width * textures[0]->height;
block_size = detexGetPixelSize(textures[0]->format);
}
uint8_t header[124];
uint8_t dx10_header[20];
memset(header, 0, 124);
memset(dx10_header, 0, 20);
uint32_t *header32 = (uint32_t *)header;
*(uint32_t *)header32 = 124;
uint32_t flags = 0x1007;
if (nu_levels > 1)
flags |= 0x20000;
if (!detexFormatIsCompressed(textures[0]->format))
flags |= 0x8; // Pitch specified.
else
flags |= 0x80000; // Linear size specified.
*(uint32_t *)(header + 4) = flags; // Flags
*(uint32_t *)(header + 8) = textures[0]->height;
*(uint32_t *)(header + 12) = textures[0]->width;
*(uint32_t *)(header + 16) = n * block_size; // Linear size for compressed textures.
*(uint32_t *)(header + 24) = nu_levels; // Mipmap count.
*(uint32_t *)(header + 72) = 32;
*(uint32_t *)(header + 76) = 0x4; // Pixel format flags (fourCC present).
bool write_dx10_header = false;
if (strncmp(info->dx_four_cc, "DX10", 4) == 0) {
write_dx10_header = true;
uint32_t *dx10_header32 = (uint32_t *)dx10_header;
*(uint32_t *)dx10_header32 = info->dx10_format;
*(uint32_t *)(dx10_header + 4) = 3; // Resource dimensions = 2D.
*(uint32_t *)(dx10_header + 12) = 1; // Array size.
}
if (!detexFormatIsCompressed(info->texture_format)) {
uint64_t red_mask, green_mask, blue_mask, alpha_mask;
detexGetComponentMasks(info->texture_format, &red_mask, &green_mask, &blue_mask, &alpha_mask);
int component_size = detexGetComponentSize(info->texture_format) * 8;
int nu_components = detexGetNumberOfComponents(info->texture_format);
// Note: Some readers don't like the absence of other fields (such as the component masks and pixel
// formats) for uncompressed data with a DX10 header.
*(uint32_t *)(header + 84) = nu_components * component_size; // bit count
*(uint32_t *)(header + 88) = red_mask;
*(uint32_t *)(header + 92) = green_mask;
*(uint32_t *)(header + 96) = blue_mask;
*(uint32_t *)(header + 100) = alpha_mask;
// Format does not have a FOURCC code (legacy uncompressed format).
uint32_t pixel_format_flags = 0x40; // Uncompressed RGB data present.
if (strlen(info->dx_four_cc) > 0)
pixel_format_flags |= 0x04; // FourCC present.
if (detexFormatHasAlpha(info->texture_format))
pixel_format_flags |= 0x01;
*(uint32_t *)(header + 76) = pixel_format_flags;
}
if (strlen(info->dx_four_cc) > 0) {
// In case of DXTn or DX10 fourCC, set it.
strncpy((char *)(header + 80), info->dx_four_cc, 4);
// Pixel format field was already set to 0x4 (FourCC present) by default.
}
uint32_t caps = 0x1000;
if (nu_levels > 1)
caps |= 0x400008;
*(uint32_t *)(header + 104) = caps; // Caps.
int pitch = textures[0]->width * detexGetPixelSize(textures[0]->format);
if (!detexFormatIsCompressed(textures[0]->format))
*(uint32_t *)(header + 16) = pitch;
r = fwrite(header, 1, 124, f);
if (r != 124) {
detexSetErrorMessage("detexSaveDDSFileWithMipmaps: Error writing to file %s", filename);
return false;
}
if (write_dx10_header) {
r = fwrite(dx10_header, 1, 20, f);
if (r != 20) {
detexSetErrorMessage("detexSaveDDSFileWithMipmaps: Error writing to file %s", filename);
return false;
}
}
// Write data.
for (int i = 0; i < nu_levels; i++) {
uint32_t pixel_size = detexGetPixelSize(textures[i]->format);
// Block size is block size for compressed textures and the pixel size for
// uncompressed textures.
int n;
int block_size;
if (detexFormatIsCompressed(textures[i]->format)) {
n = textures[i]->width_in_blocks * textures[i]->height_in_blocks;
block_size = detexGetCompressedBlockSize(textures[i]->format);
}
else {
n = textures[i]->width * textures[i]->height;
block_size = pixel_size;
}
// Write level data.
r = fwrite(textures[i]->data, 1, n * block_size, f);
if (r != n * block_size) {
detexSetErrorMessage("detexSaveDDSFileWithMipmaps: Error writing to file %s", filename);
return false;
}
}
fclose(f);
return true;
}
// Save texture to DDS file (single mip-map level). Returns true if succesful.
bool detexSaveDDSFile(detexTexture *texture, const char *filename) {
detexTexture *textures[1];
textures[0] = texture;
return detexSaveDDSFileWithMipmaps(textures, 1, filename);
} | c |
Plug-ins/Kerberos/CommonKClient/mac_kclient/des/enc_writ.c | mulberry-mail/mulberry4-client | 12 | 7985895 | /* crypto/des/enc_writ.c */
/* Copyright (C) 1995-1997 <NAME> (<EMAIL>)
* All rights reserved.
*
* This package is an SSL implementation written
* by <NAME> (<EMAIL>).
* The implementation was written so as to conform with Netscapes SSL.
*
* This library is free for commercial and non-commercial use as long as
* the following conditions are aheared to. The following conditions
* apply to all code found in this distribution, be it the RC4, RSA,
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
* included with this distribution is covered by the same copyright terms
* except that the holder is <NAME> (<EMAIL>).
*
* Copyright remains <NAME>'s, and as such any Copyright notices in
* the code are not to be removed.
* If this package is used in a product, Eric Young should be given attribution
* as the author of the parts of the library used.
* This can be in the form of a textual message at program startup or
* in documentation (online or textual) provided with the package.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* "This product includes cryptographic software written by
* <NAME> (<EMAIL>)"
* The word 'cryptographic' can be left out if the rouines from the library
* being used are not cryptographic related :-).
* 4. If you include any Windows specific code (or a derivative thereof) from
* the apps directory (application code) you must include an acknowledgement:
* "This product includes software written by <NAME> (<EMAIL>)"
*
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* The licence and distribution terms for any publically available version or
* derivative of this code cannot be changed. i.e. this code cannot simply be
* copied and put under another distribution licence
* [including the GNU Public Licence.]
*/
#include <errno.h>
#include <time.h>
#include "des_locl.h"
int des_enc_write(fd, buf, len, sched, iv)
int fd;
char *buf;
int len;
des_key_schedule sched;
des_cblock (*iv);
{
#ifdef _LIBC
extern int srandom();
extern unsigned long time();
extern int random();
extern int write();
#endif
long rnum;
int i,j,k,outnum;
char *outbuf=NULL;
char shortbuf[8];
char *p;
static int start=1;
if (outbuf == NULL)
{
outbuf=(char *)malloc(BSIZE+HDRSIZE);
if (outbuf == NULL) return(-1);
}
/* If we are sending less than 8 bytes, the same char will look
* the same if we don't pad it out with random bytes */
if (start)
{
start=0;
srandom((unsigned int)time(NULL));
}
/* lets recurse if we want to send the data in small chunks */
if (len > MAXWRITE)
{
j=0;
for (i=0; i<len; i+=k)
{
k=des_enc_write(fd,&(buf[i]),
((len-i) > MAXWRITE)?MAXWRITE:(len-i),sched,iv);
if (k < 0)
return(k);
else
j+=k;
}
return(j);
}
/* write length first */
p=outbuf;
l2n(len,p);
/* pad short strings */
if (len < 8)
{
p=shortbuf;
memcpy(shortbuf,buf,(unsigned int)len);
for (i=len; i<8; i++)
shortbuf[i]=random();
rnum=8;
}
else
{
p=buf;
rnum=((len+7)/8*8); /* round up to nearest eight */
}
if (des_rw_mode & DES_PCBC_MODE)
des_pcbc_encrypt((des_cblock *)p,
(des_cblock *)&(outbuf[HDRSIZE]),
(long)((len<8)?8:len),sched,iv,DES_ENCRYPT);
else
des_cbc_encrypt((des_cblock *)p,
(des_cblock *)&(outbuf[HDRSIZE]),
(long)((len<8)?8:len),sched,iv,DES_ENCRYPT);
/* output */
outnum=(int)rnum+HDRSIZE;
for (j=0; j<outnum; j+=i)
{
/* eay 26/08/92 I was not doing writing from where we
* got upto. */
i=write(fd,&(outbuf[j]),(unsigned int)(outnum-j));
if (i == -1)
{
if (errno == EINTR)
i=0;
else /* This is really a bad error - very bad
* It will stuff-up both ends. */
return(-1);
}
}
return(len);
} | c |
src/secp256k1/include/secp256k1_recovery.h | yinchengtsinghua/RippleCPPChinese | 5 | 199750 | //此源码被清华学神尹成大魔王专业翻译分析并修改
//尹成QQ77025077
//尹成微信18510341407
//尹成所在QQ群721929980
//尹成邮箱 <EMAIL>
//尹成毕业于清华大学,微软区块链领域全球最有价值专家
//https://mvp.microsoft.com/zh-cn/PublicProfile/4033620
#ifndef _SECP256K1_RECOVERY_
# define _SECP256K1_RECOVERY_
# include "secp256k1.h"
# ifdef __cplusplus
extern "C" {
# endif
/*不透明的数据结构，包含已解析的ECDSA签名，
*支持pubkey恢复。
*
*内部数据的准确表示是实现定义的，而不是
*保证在不同平台或版本之间可移植。它是
*但是保证大小为65字节，并且可以安全地复制/移动。
*如果需要转换为适合存储或传输的格式，请使用
*secp256k1_ecdsa_signature_serialize_ux和
*secp256k1_ecdsa_signature_parse_ux函数。
*
*此外，保证相同的签名（包括
*可恢复性）具有相同的表示，因此它们可以
* MeMCP'ED.
**/
typedef struct {
unsigned char data[65];
} secp256k1_ecdsa_recoverable_signature;
/*解析一个紧凑的ECDSA签名（64字节+恢复ID）。
*
*当可以解析签名时返回1，否则返回0
*args:ctx:secp256k1上下文对象
*out:sig：指向签名对象的指针
*in:input64：指向64字节压缩签名的指针
*recid：恢复ID（0、1、2或3）
**/
SECP256K1_API int secp256k1_ecdsa_recoverable_signature_parse_compact(
const secp256k1_context* ctx,
secp256k1_ecdsa_recoverable_signature* sig,
const unsigned char *input64,
int recid
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
/*将可恢复签名转换为普通签名。
*
*返回：1
*out:sig：指向普通签名的指针（不能为空）。
*in:sigin：指向可恢复签名的指针（不能为空）。
**/
SECP256K1_API int secp256k1_ecdsa_recoverable_signature_convert(
const secp256k1_context* ctx,
secp256k1_ecdsa_signature* sig,
const secp256k1_ecdsa_recoverable_signature* sigin
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3);
/*以压缩格式（64字节+恢复ID）序列化ECDSA签名。
*
*返回：1
*args:ctx:secp256k1上下文对象
*out:output64:指向压缩签名的64字节数组的指针（不能为空）
*recid：指向整数的指针，用于保存恢复ID（可以为空）。
*in:sig：指向已初始化签名对象的指针（不能为空）
**/
SECP256K1_API int secp256k1_ecdsa_recoverable_signature_serialize_compact(
const secp256k1_context* ctx,
unsigned char *output64,
int *recid,
const secp256k1_ecdsa_recoverable_signature* sig
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
/*创建可恢复的ECDSA签名。
*
*返回：1:已创建签名
*0:nonce生成函数失败，或者私钥无效。
*args:ctx:指向上下文对象的指针，已初始化以便签名（不能为空）
*out:sig：指向将放置签名的数组的指针（不能为空）
*in:msg32:正在签名的32字节消息哈希（不能为空）
*seckey：指向32字节密钥的指针（不能为空）
*noncefp：指向nonce生成函数的指针。如果为空，则使用secp256k1_nonce_函数_default
*data：指向nonce生成函数使用的任意数据的指针（可以为空）
**/
SECP256K1_API int secp256k1_ecdsa_sign_recoverable(
const secp256k1_context* ctx,
secp256k1_ecdsa_recoverable_signature *sig,
const unsigned char *msg32,
const unsigned char *seckey,
secp256k1_nonce_function noncefp,
const void *ndata
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
/*从签名恢复ECDSA公钥。
*
*返回：1:公钥恢复成功（保证签名正确）。
*0：否则。
*args:ctx:指向上下文对象的指针，已初始化以供验证（不能为空）
*out:pubkey：指向恢复的公钥的指针（不能为空）
*in:sig：指向支持pubkey恢复的初始化签名的指针（不能为空）
*msg32:假定32字节消息哈希已签名（不能为空）
**/
SECP256K1_API SECP256K1_WARN_UNUSED_RESULT int secp256k1_ecdsa_recover(
const secp256k1_context* ctx,
secp256k1_pubkey *pubkey,
const secp256k1_ecdsa_recoverable_signature *sig,
const unsigned char *msg32
) SECP256K1_ARG_NONNULL(1) SECP256K1_ARG_NONNULL(2) SECP256K1_ARG_NONNULL(3) SECP256K1_ARG_NONNULL(4);
# ifdef __cplusplus
}
# endif
#endif | c |
Code/HeapSort.h | TuanNguyen1999/Sorting-Algorithms | 0 | 2070224 | #pragma once
#include "BaseSorting.h"
class HeapSort :
public BaseSorting
{
public:
HeapSort(size_t n = 0) : BaseSorting(n) {}
HeapSort(const vector<int> &vec) : BaseSorting(vec) {}
HeapSort(const int* arr, size_t n) : BaseSorting(arr, n) {}
HeapSort(const string& file_name) : BaseSorting(file_name) {}
HeapSort(const BaseSorting& obj) : BaseSorting(obj) {}
virtual ~HeapSort() {}
HeapSort& operator=(const BaseSorting& obj);
virtual long long sort(size_t = 100);
virtual string name() const { return string("HeapSort"); }
private:
void HeapSortTlk(size_t);
void pull(size_t parent, size_t temp_size);
}; | c |
include/algorithms/mf_sgd/mf_sgd_batch.h | francktcheng/Harp-DAAL-Local | 2 | 6247539 | /* file: mf_sgd_batch.h */
/*******************************************************************************
* Copyright 2014-2016 Intel Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
/*
//++
// Implementation of the interface for the mf_sgd decomposition algorithm in the
// batch processing mode
//--
*/
#ifndef __MF_SGD_BATCH_H__
#define __MF_SGD_BATCH_H__
#include "algorithms/algorithm.h"
#include "data_management/data/numeric_table.h"
#include "services/daal_defines.h"
#include "algorithms/mf_sgd/mf_sgd_types.h"
namespace daal
{
namespace algorithms
{
namespace mf_sgd
{
namespace interface1
{
/** @defgroup mf_sgd_batch Batch
* @ingroup mf_sgd_without_pivoting
* @{
*/
/**
* <a name="DAAL-CLASS-ALGORITHMS__mf_sgd__BATCHCONTAINER"></a>
* \brief Provides methods to run implementations of the mf_sgd decomposition algorithm in the batch processing mode
*
* \tparam algorithmFPType Data type to use in intermediate computations of the mf_sgd decomposition algorithm, double or float
* \tparam method Computation method of the mf_sgd decomposition algorithm, \ref daal::algorithms::mf_sgd::Method
*
*/
template<typename algorithmFPType, Method method, CpuType cpu>
class DAAL_EXPORT BatchContainer : public daal::algorithms::AnalysisContainerIface<batch>
{
public:
/**
* Constructs a container for the mf_sgd decomposition algorithm with a specified environment
* in the batch processing mode
* \param[in] daalEnv Environment object
*/
BatchContainer(daal::services::Environment::env *daalEnv);
/** Default destructor */
virtual ~BatchContainer();
/**
* Computes the result of the mf_sgd decomposition algorithm in the batch processing mode
*/
virtual daal::services::interface1::Status compute() DAAL_C11_OVERRIDE;
};
/**
* <a name="DAAL-CLASS-ALGORITHMS__mf_sgd__BATCH"></a>
* \brief Computes the results of the mf_sgd decomposition algorithm in the batch processing mode.
* \n<a href="DAAL-REF-mf_sgd-ALGORITHM">mf_sgd decomposition algorithm description and usage models</a>
*
* \tparam algorithmFPType Data type to use in intermediate computations for the mf_sgd decomposition algorithm, double or float
* \tparam method Computation method of the algorithm, \ref daal::algorithms::mf_sgd::Method
*
* \par Enumerations
* - \ref Method Computation methods for the mf_sgd decomposition algorithm
*/
template<typename algorithmFPType = double, Method method = defaultSGD>
class DAAL_EXPORT Batch : public daal::algorithms::Analysis<batch>
{
public:
Input input; /*!< Input object */
Parameter parameter; /*!< mf_sgd decomposition parameters */
Batch()
{
initialize();
}
/**
* Constructs a mf_sgd decomposition algorithm by copying input objects and parameters
* of another mf_sgd decomposition algorithm
* \param[in] other An algorithm to be used as the source to initialize the input objects
* and parameters of the algorithm
*/
Batch(const Batch<algorithmFPType, method> &other)
{
initialize();
input.set(dataTrain, other.input.get(dataTrain)); /* !< copy input training dataset */
input.set(dataTest, other.input.get(dataTest)); /* !< copy input test dataset */
parameter = other.parameter;
}
/**
* Returns method of the algorithm
* \return Method of the algorithm
*/
virtual int getMethod() const DAAL_C11_OVERRIDE { return(int)method; }
/**
* Returns the structure that contains the results of the mf_sgd decomposition algorithm
* \return Structure that contains the results of the mf_sgd decomposition algorithm
*/
services::SharedPtr<Result> getResult() { return _result; }
/**
* Register user-allocated memory to store the results of the mf_sgd decomposition algorithm
* \return Structure to store the results of the mf_sgd decomposition algorithm
*/
daal::services::interface1::Status setResult(const services::SharedPtr<Result>& res)
{
daal::services::interface1::Status status;
DAAL_CHECK(res, daal::services::ErrorNullResult)
_result = res;
_res = _result.get();
return status;
}
/**
* Returns a pointer to the newly allocated mf_sgd decomposition algorithm
* with a copy of input objects and parameters of this mf_sgd decomposition algorithm
* \return Pointer to the newly allocated algorithm
*/
services::SharedPtr<Batch<algorithmFPType, method> > clone() const
{
return services::SharedPtr<Batch<algorithmFPType, method> >(cloneImpl());
}
protected:
virtual Batch<algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
{
return new Batch<algorithmFPType, method>(*this);
}
virtual daal::services::interface1::Status allocateResult() DAAL_C11_OVERRIDE
{
services::Status status;
/* the function to allocate the result */
_result = services::SharedPtr<Result>(new Result());
_result->allocate<algorithmFPType>(&input, _par, 0);
_res = _result.get();
return status;
}
void initialize()
{
Analysis<batch>::_ac = new __DAAL_ALGORITHM_CONTAINER(batch, BatchContainer, algorithmFPType, method)(&_env);
_in = &input;
_par = ¶meter;
}
private:
services::SharedPtr<Result> _result;
};
/** @} */
} // namespace interface1
using interface1::BatchContainer;
using interface1::Batch;
} // namespace daal::algorithms::mf_sgd
}
} // namespace daal
#endif | c |
PrivateFrameworks/ContactsAutocomplete.framework/CNAutocompleteCalendarServerResult.h | shaojiankui/iOS10-Runtime-Headers | 36 | 1421746 | /* Generated by RuntimeBrowser
Image: /System/Library/PrivateFrameworks/ContactsAutocomplete.framework/ContactsAutocomplete
*/
@interface CNAutocompleteCalendarServerResult : CNAutocompleteResult
+ (unsigned long long)category;
@end | c |
examples/omp/benchmarks/bots/templates/template.c | tianyi93/hpxMP_mirror | 22 | 2152259 | /***********************************************************************
* template.c -- description
**********************************************************************/
#include "../../common/common.h"
#include "../../common/extern.h"
#include "../../common/main.h"
/**********************************************************************/
#include <stdio.h>
#include <string.h>
/***********************************************************************
* GLOBAL SYMBOLS & DEFAULT VALUES
*********************************************************************/
/***********************************************************************
* function:
**********************************************************************/
/***********************************************************************
***********************************************************************
* bsc_sequential:
***********************************************************************
**********************************************************************/
/***********************************************************************
* bsc_sequential_ini: Executed just after the sequential function
**********************************************************************/
void bsc_sequential_ini ()
{
}
/***********************************************************************
* bsc_sequential: Equivalent sequential version of the program
***********************************************************************
* If the function returns (0) main take cares about execution
* time measurement. Otherwise the returned value will be used
* as execution time reference (in usecs). You can use bsc_usecs()
* function in order to get punctual timestamp.
**********************************************************************/
long bsc_sequential ()
{
return 0;
}
/***********************************************************************
* bsc_sequential_fini: Executed just before the sequential function
**********************************************************************/
void bsc_sequential_fini ()
{
}
/***********************************************************************
***********************************************************************
* bsc_program *********************************************************
***********************************************************************
**********************************************************************/
/***********************************************************************
* bsc_program_ini: Executed just after the program function
**********************************************************************/
void bsc_program_ini ()
{
}
/***********************************************************************
* bsc_program: Program executed code (according with programmin model)
***********************************************************************
* If the function returns (0) main take cares about execution
* time measurement. Otherwise the returned value will be used
* as execution time reference (in usecs). You can use bsc_usecs()
* function in order to get punctual timestamp.
**********************************************************************/
long bsc_program ()
{
return 0;
}
/***********************************************************************
* bsc_program_fini: Executed just before the program function
**********************************************************************/
void bsc_program_fini ()
{
}
/***********************************************************************
* bsc_initialize: Executed at the beginning of the benchmark
**********************************************************************/
void bsc_initialize ()
{
}
/***********************************************************************
* bsc_finalize: Executed at the end of the benchmark
**********************************************************************/
void bsc_finalize ()
{
}
/***********************************************************************
* bsc_check_result: Performs a verification of correctness.
***********************************************************************
* Returns:
* - BSC_RESULT_NA (not available)
* - BSC_RESULT_SUCCESSFUL
* - BSC_RESULT_UNSUCCESSFUL
**********************************************************************/
int
bsc_check_result ()
{
int check_result = BSC_RESULT_NA;
return check_result;
}
/***********************************************************************
* bsc_print_usage_specific: Show some specific help
***********************************************************************
* To keep output format use the function bsc_print_usage_option().
* Parameters are (in order):
* char: flag identifier
* int: argument type
* - BSC_PARAM_TYPE_NONE: without argument
* - BSC_PARAM_TYPE_INT: integer argument
* - BSC_PARAM_TYPE_STR: string argument
* - BSC_PARAM_TYPE_BOOL: boolean argument
* char*: parameter desccription
* char*: argument default value (NULL if none)
* int: number of aditional description lines (dl)
* char**: aditional description lines
**********************************************************************/
void bsc_print_usage_specific ()
{
}
/***********************************************************************
* bsc_get_params_specific: Capture program paramenters
**********************************************************************/
void bsc_get_params_specific (int argc, char **argv)
{
int i;
for (i=1; i<argc; i++)
{
if (argv[i][0] == '-')
{
switch (argv[i][1])
{
#if 0
case ' ': /* parameter description */
i++; /* read argument (if needed) */
if (argc == i){bsc_error(BSC_ERROR_UNRECOGNIZED_PARAMETER, NULL);}
INT_GOBAL_VALUE = atoi(argv[i]);
BOOL_GOBAL_VALUE = atoi(argv[i]);
strcpy(STR_GLOBAL_VALUE,argv[i]);
break;
#endif
case '+': /* already proccessed paramenters no-argument */
break;
case '*': /* already proccessed paramenters w/-argument */
i++;
break;
default: /* unrecognized parameter: error */
bsc_error(BSC_ERROR_UNRECOGNIZED_PARAMETER, NULL);
}
}
else {bsc_error(BSC_ERROR_UNRECOGNIZED_PARAMETER, NULL);}
}
}
/***********************************************************************
* bsc_set_info: Initialize some global (extern) variables
***********************************************************************
* Global variables to initialize:
* - bsc_paramenters: executed paramenters separated by comma
* - bsc_model: programming model
* - bsc_resources: machine resources (e.g. number of threads)
* - bsc_comp_date: compilation date
* - bsc_comp_message: user's message at compile time
* - bsc_cc: compiler name
* - bsc_cflags: flags used by the compiler
* - bsc_ld: linker name
* - bsc_ldflags: flags used by the linker
**********************************************************************/
void bsc_set_info ()
{
/* program specific info */
sprintf(bsc_parameters,"par1,par2,...");
sprintf(bsc_model,"Programming-Model");
sprintf(bsc_resources,"%d", omp_get_max_threads());
/* compilation info (do not modify) */
strcpy(bsc_comp_date,CDATE);
strcpy(bsc_comp_message,CMESSAGE);
strcpy(bsc_cc,CC);
strcpy(bsc_cflags,CFLAGS);
strcpy(bsc_ld,LD);
strcpy(bsc_ldflags,LDFLAGS);
} | c |
dir600b_v2.03/kernels/rt305x/drivers/net/ehea/ehea_ethtool.c | ghsecuritylab/DIR600B2 | 1 | 7504461 | /*
* linux/drivers/net/ehea/ehea_ethtool.c
*
* eHEA ethernet device driver for IBM eServer System p
*
* (C) Copyright IBM Corp. 2006
*
* Authors:
* <NAME> <<EMAIL>>
* <NAME> <<EMAIL>>
* <NAME> <<EMAIL>>
*
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "ehea.h"
#include "ehea_phyp.h"
static int ehea_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
struct ehea_port *port = netdev_priv(dev);
int ret;
ret = ehea_sense_port_attr(port);
if (ret)
return ret;
if (netif_carrier_ok(dev)) {
switch(port->port_speed) {
case EHEA_SPEED_10M: cmd->speed = SPEED_10; break;
case EHEA_SPEED_100M: cmd->speed = SPEED_100; break;
case EHEA_SPEED_1G: cmd->speed = SPEED_1000; break;
case EHEA_SPEED_10G: cmd->speed = SPEED_10000; break;
}
cmd->duplex = port->full_duplex == 1 ?
DUPLEX_FULL : DUPLEX_HALF;
} else {
cmd->speed = -1;
cmd->duplex = -1;
}
cmd->supported = (SUPPORTED_10000baseT_Full | SUPPORTED_1000baseT_Full
| SUPPORTED_100baseT_Full | SUPPORTED_100baseT_Half
| SUPPORTED_10baseT_Full | SUPPORTED_10baseT_Half
| SUPPORTED_Autoneg | SUPPORTED_FIBRE);
cmd->advertising = (ADVERTISED_10000baseT_Full | ADVERTISED_Autoneg
| ADVERTISED_FIBRE);
cmd->port = PORT_FIBRE;
cmd->autoneg = port->autoneg == 1 ? AUTONEG_ENABLE : AUTONEG_DISABLE;
return 0;
}
static int ehea_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
struct ehea_port *port = netdev_priv(dev);
int ret = 0;
u32 sp;
if (cmd->autoneg == AUTONEG_ENABLE) {
sp = EHEA_SPEED_AUTONEG;
goto doit;
}
switch(cmd->speed) {
case SPEED_10:
if (cmd->duplex == DUPLEX_FULL)
sp = H_SPEED_10M_F;
else
sp = H_SPEED_10M_H;
break;
case SPEED_100:
if (cmd->duplex == DUPLEX_FULL)
sp = H_SPEED_100M_F;
else
sp = H_SPEED_100M_H;
break;
case SPEED_1000:
if (cmd->duplex == DUPLEX_FULL)
sp = H_SPEED_1G_F;
else
ret = -EINVAL;
break;
case SPEED_10000:
if (cmd->duplex == DUPLEX_FULL)
sp = H_SPEED_10G_F;
else
ret = -EINVAL;
break;
default:
ret = -EINVAL;
break;
}
if (ret)
goto out;
doit:
ret = ehea_set_portspeed(port, sp);
if (!ret)
ehea_info("%s: Port speed succesfully set: %dMbps "
"%s Duplex",
port->netdev->name, port->port_speed,
port->full_duplex == 1 ? "Full" : "Half");
out:
return ret;
}
static int ehea_nway_reset(struct net_device *dev)
{
struct ehea_port *port = netdev_priv(dev);
int ret;
ret = ehea_set_portspeed(port, EHEA_SPEED_AUTONEG);
if (!ret)
ehea_info("%s: Port speed succesfully set: %dMbps "
"%s Duplex",
port->netdev->name, port->port_speed,
port->full_duplex == 1 ? "Full" : "Half");
return ret;
}
static void ehea_get_drvinfo(struct net_device *dev,
struct ethtool_drvinfo *info)
{
strlcpy(info->driver, DRV_NAME, sizeof(info->driver) - 1);
strlcpy(info->version, DRV_VERSION, sizeof(info->version) - 1);
}
static u32 ehea_get_msglevel(struct net_device *dev)
{
struct ehea_port *port = netdev_priv(dev);
return port->msg_enable;
}
static void ehea_set_msglevel(struct net_device *dev, u32 value)
{
struct ehea_port *port = netdev_priv(dev);
port->msg_enable = value;
}
static u32 ehea_get_rx_csum(struct net_device *dev)
{
return 1;
}
static char ehea_ethtool_stats_keys[][ETH_GSTRING_LEN] = {
{"poll_max_processed"},
{"queue_stopped"},
{"min_swqe_avail"},
{"poll_receive_err"},
{"pkt_send"},
{"pkt_xmit"},
{"send_tasklet"},
{"ehea_poll"},
{"nwqe"},
{"swqe_available_0"},
{"sig_comp_iv"},
{"swqe_refill_th"},
{"port resets"},
{"rxo"},
{"rx64"},
{"rx65"},
{"rx128"},
{"rx256"},
{"rx512"},
{"rx1024"},
{"txo"},
{"tx64"},
{"tx65"},
{"tx128"},
{"tx256"},
{"tx512"},
{"tx1024"},
};
static void ehea_get_strings(struct net_device *dev, u32 stringset, u8 *data)
{
if (stringset == ETH_SS_STATS) {
memcpy(data, &ehea_ethtool_stats_keys,
sizeof(ehea_ethtool_stats_keys));
}
}
static int ehea_get_stats_count(struct net_device *dev)
{
return ARRAY_SIZE(ehea_ethtool_stats_keys);
}
static void ehea_get_ethtool_stats(struct net_device *dev,
struct ethtool_stats *stats, u64 *data)
{
u64 hret;
int i;
struct ehea_port *port = netdev_priv(dev);
struct ehea_adapter *adapter = port->adapter;
struct ehea_port_res *pr = &port->port_res[0];
struct port_state *p_state = &pr->p_state;
struct hcp_ehea_port_cb6 *cb6;
for (i = 0; i < ehea_get_stats_count(dev); i++)
data[i] = 0;
i = 0;
data[i++] = p_state->poll_max_processed;
data[i++] = p_state->queue_stopped;
data[i++] = p_state->min_swqe_avail;
data[i++] = p_state->poll_receive_errors;
data[i++] = p_state->pkt_send;
data[i++] = p_state->pkt_xmit;
data[i++] = p_state->send_tasklet;
data[i++] = p_state->ehea_poll;
data[i++] = p_state->nwqe;
data[i++] = atomic_read(&port->port_res[0].swqe_avail);
data[i++] = port->sig_comp_iv;
data[i++] = port->port_res[0].swqe_refill_th;
data[i++] = port->resets;
cb6 = kzalloc(PAGE_SIZE, GFP_KERNEL);
if (!cb6) {
ehea_error("no mem for cb6");
return;
}
hret = ehea_h_query_ehea_port(adapter->handle, port->logical_port_id,
H_PORT_CB6, H_PORT_CB6_ALL, cb6);
if (netif_msg_hw(port))
ehea_dump(cb6, sizeof(*cb6), "ehea_get_ethtool_stats");
if (hret == H_SUCCESS) {
data[i++] = cb6->rxo;
data[i++] = cb6->rx64;
data[i++] = cb6->rx65;
data[i++] = cb6->rx128;
data[i++] = cb6->rx256;
data[i++] = cb6->rx512;
data[i++] = cb6->rx1024;
data[i++] = cb6->txo;
data[i++] = cb6->tx64;
data[i++] = cb6->tx65;
data[i++] = cb6->tx128;
data[i++] = cb6->tx256;
data[i++] = cb6->tx512;
data[i++] = cb6->tx1024;
} else
ehea_error("query_ehea_port failed");
kfree(cb6);
}
const struct ethtool_ops ehea_ethtool_ops = {
.get_settings = ehea_get_settings,
.get_drvinfo = ehea_get_drvinfo,
.get_msglevel = ehea_get_msglevel,
.set_msglevel = ehea_set_msglevel,
.get_link = ethtool_op_get_link,
.get_tx_csum = ethtool_op_get_tx_csum,
.get_sg = ethtool_op_get_sg,
.get_tso = ethtool_op_get_tso,
.set_tso = ethtool_op_set_tso,
.get_strings = ehea_get_strings,
.get_stats_count = ehea_get_stats_count,
.get_ethtool_stats = ehea_get_ethtool_stats,
.get_rx_csum = ehea_get_rx_csum,
.set_settings = ehea_set_settings,
.nway_reset = ehea_nway_reset, /* Restart autonegotiation */
};
void ehea_set_ethtool_ops(struct net_device *netdev)
{
SET_ETHTOOL_OPS(netdev, &ehea_ethtool_ops);
} | c |
src/h/Framework/Managers/Graphics Manager/Toolkit/DirectX 12/CommandAllocator.h | MeepSplize/Uniquis-Framework | 0 | 239353 | #pragma once
#include <WRL.h>
#include "Flags.h"
#include "Device.h"
namespace Uniquis::DirectX12
{
class CommandAllocator
{
private:
Microsoft::WRL::ComPtr<ID3D12CommandAllocator> pCommandAllocator;
public:
CommandAllocator(const Device& device, const CommandAllocatorFlags& flags);
public:
~CommandAllocator();
public:
void reset();
public:
ID3D12CommandAllocator* operator*() const noexcept;
ID3D12CommandAllocator* operator->() const noexcept;
};
} | c |
src/graphics/display/drivers/intel-i915/dp-display.h | allansrc/fuchsia | 2 | 521280 | // Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SRC_GRAPHICS_DISPLAY_DRIVERS_INTEL_I915_DP_DISPLAY_H_
#define SRC_GRAPHICS_DISPLAY_DRIVERS_INTEL_I915_DP_DISPLAY_H_
#include <fuchsia/hardware/i2cimpl/c/banjo.h>
#include <lib/inspect/cpp/inspect.h>
#include "src/graphics/display/drivers/intel-i915/display-device.h"
#include "src/graphics/display/drivers/intel-i915/dpcd.h"
namespace i915 {
// Abstraction over the DPCD register transactions that are performed over the DisplayPort Auxiliary
// channel.
class DpcdChannel {
public:
virtual ~DpcdChannel() = default;
virtual bool DpcdRead(uint32_t addr, uint8_t* buf, size_t size) = 0;
virtual bool DpcdWrite(uint32_t addr, const uint8_t* buf, size_t size) = 0;
};
class DpAuxMessage;
class DpAux : public DpcdChannel {
public:
explicit DpAux(registers::Ddi ddi);
zx_status_t I2cTransact(const i2c_impl_op_t* ops, size_t count);
// DpcdChannel overrides:
bool DpcdRead(uint32_t addr, uint8_t* buf, size_t size) final override;
bool DpcdWrite(uint32_t addr, const uint8_t* buf, size_t size) final override;
void set_mmio_space(ddk::MmioBuffer* mmio_space) {
fbl::AutoLock lock(&lock_);
mmio_space_ = mmio_space;
}
private:
const registers::Ddi ddi_;
// The lock protects the registers this class writes to, not the whole register io space.
ddk::MmioBuffer* mmio_space_ __TA_GUARDED(lock_);
mtx_t lock_;
zx_status_t DpAuxRead(uint32_t dp_cmd, uint32_t addr, uint8_t* buf, size_t size)
__TA_REQUIRES(lock_);
zx_status_t DpAuxReadChunk(uint32_t dp_cmd, uint32_t addr, uint8_t* buf, uint32_t size_in,
size_t* size_out) __TA_REQUIRES(lock_);
zx_status_t DpAuxWrite(uint32_t dp_cmd, uint32_t addr, const uint8_t* buf, size_t size)
__TA_REQUIRES(lock_);
zx_status_t SendDpAuxMsg(const DpAuxMessage& request, DpAuxMessage* reply) __TA_REQUIRES(lock_);
zx_status_t SendDpAuxMsgWithRetry(const DpAuxMessage& request, DpAuxMessage* reply)
__TA_REQUIRES(lock_);
};
// DpCapabilities is a utility for reading and storing DisplayPort capabilities supported by the
// display based on a copy of read-only DPCD capability registers. Data is also published to
// inspect.
struct DpCapabilities final {
public:
// Initializes the DPCD capability array with all zeros and the EDP DPCD capabilities as
// non-present.
DpCapabilities();
// Explicitly disallow copy (implicitly disallowed by the contained inspect::Node).
DpCapabilities(const DpCapabilities&) = delete;
DpCapabilities& operator=(const DpCapabilities&) = delete;
// Allow move.
DpCapabilities(DpCapabilities&&) = default;
DpCapabilities& operator=(DpCapabilities&&) = default;
// Read and parse DPCD capabilities. Clears any previously initialized content
static fpromise::result<DpCapabilities> Read(DpcdChannel* dp_aux, inspect::Node* parent_node);
// Get the cached value of a DPCD register using its DPCD address.
uint8_t dpcd_at(dpcd::Register address) const {
ZX_ASSERT(address < dpcd::DPCD_SUPPORTED_LINK_RATE_START);
return dpcd_[address - dpcd::DPCD_CAP_START];
}
// Get the cached value of a EDP DPCD register using its address. Asserts if the eDP capabilities
// are not available.
uint8_t edp_dpcd_at(dpcd::EdpRegister address) const {
ZX_ASSERT(edp_dpcd_.has_value());
ZX_ASSERT(address < dpcd::DPCD_EDP_RESERVED && address >= dpcd::DPCD_EDP_CAP_START);
return edp_dpcd_->bytes[address - dpcd::DPCD_EDP_CAP_START];
}
template <typename T, dpcd::Register A>
T dpcd_reg() const {
T reg;
reg.set_reg_value(dpcd_at(A));
return reg;
}
// Asserts if eDP capabilities are not available.
template <typename T, dpcd::EdpRegister A>
T edp_dpcd_reg() const {
T reg;
reg.set_reg_value(edp_dpcd_at(A));
return reg;
}
dpcd::Revision dpcd_revision() const { return dpcd::Revision(dpcd_[dpcd::DPCD_REV]); }
std::optional<dpcd::EdpRevision> edp_revision() const {
if (edp_dpcd_) {
return edp_dpcd_->revision;
}
return std::nullopt;
}
// Total number of stream sinks within this Sink device.
size_t sink_count() const { return sink_count_.count(); }
// Maximum number of DisplayPort lanes.
uint8_t max_lane_count() const { return max_lane_count_.lane_count_set(); }
// True for SST mode displays that support the Enhanced Framing symbol sequence (see DP v1.4a
// Section 2.2.1.2).
bool enhanced_frame_capability() const { return max_lane_count_.enhanced_frame_enabled(); }
// True for eDP displays that support the `backlight_enable` bit in the
// dpcd::DPCD_EDP_DISPLAY_CTRL register (see dpcd.h).
bool backlight_aux_power() const { return edp_dpcd_ && edp_dpcd_->backlight_aux_power; }
// True for eDP displays that support backlight adjustment through the
// dpcd::DPCD_EDP_BACKLIGHT_BRIGHTNESS_[MSB|LSB] registers.
bool backlight_aux_brightness() const { return edp_dpcd_ && edp_dpcd_->backlight_aux_brightness; }
// The list of supported link rates in ascending order, measured in units of Mbps/lane.
const std::vector<uint32_t>& supported_link_rates_mbps() const {
return supported_link_rates_mbps_;
}
// True if the contents of vector returned by `supported_link_rates_mbps()` was populated using
// the "Link Rate Table" method. If true, the link rate must be selected by writing the vector
// index to the DPCD LINK_RATE_SET register. Otherwise, the selected link rate must be programmed
// using the DPCD LINK_BW_SET register.
bool use_link_rate_table() const { return use_link_rate_table_; }
private:
// DpCapabilities that are only present in eDP displays.
struct Edp {
Edp();
std::array<uint8_t, dpcd::DPCD_EDP_RESERVED - dpcd::DPCD_EDP_CAP_START> bytes;
dpcd::EdpRevision revision;
bool backlight_aux_power = false;
bool backlight_aux_brightness = false;
};
explicit DpCapabilities(inspect::Node* parent_node);
bool ProcessEdp(DpcdChannel* dp_aux);
bool ProcessSupportedLinkRates(DpcdChannel* dp_aux);
void PublishInspect();
std::array<uint8_t, dpcd::DPCD_SUPPORTED_LINK_RATE_START - dpcd::DPCD_CAP_START> dpcd_;
dpcd::SinkCount sink_count_;
dpcd::LaneCount max_lane_count_;
std::vector<uint32_t> supported_link_rates_mbps_;
bool use_link_rate_table_ = false;
std::optional<Edp> edp_dpcd_;
inspect::Node node_;
inspect::ValueList inspect_properties_;
};
class DpDisplay : public DisplayDevice {
public:
DpDisplay(Controller* controller, uint64_t id, registers::Ddi ddi, DpcdChannel* dp_aux,
inspect::Node* parent_node);
// Gets the backlight brightness as a coefficient on the maximum brightness,
// between the minimum brightness and 1.
double GetBacklightBrightness();
// DisplayDevice overrides:
bool Query() final;
void InitWithDpllState(struct dpll_state* dpll_state) final;
uint8_t lane_count() const { return dp_lane_count_; }
uint32_t link_rate_mhz() const { return dp_link_rate_mhz_; }
private:
// DisplayDevice overrides:
bool InitDdi() final;
bool DdiModeset(const display_mode_t& mode, registers::Pipe pipe, registers::Trans trans) final;
bool PipeConfigPreamble(const display_mode_t& mode, registers::Pipe pipe,
registers::Trans trans) final;
bool PipeConfigEpilogue(const display_mode_t& mode, registers::Pipe pipe,
registers::Trans trans) final;
bool ComputeDpllState(uint32_t pixel_clock_10khz, struct dpll_state* config) final;
uint32_t LoadClockRateForTranscoder(registers::Trans transcoder) final;
bool CheckPixelRate(uint64_t pixel_rate) final;
uint32_t i2c_bus_id() const final { return ddi() + registers::kDdiCount; }
bool DpcdWrite(uint32_t addr, const uint8_t* buf, size_t size);
bool DpcdRead(uint32_t addr, uint8_t* buf, size_t size);
bool DpcdRequestLinkTraining(const dpcd::TrainingPatternSet& tp_set,
const dpcd::TrainingLaneSet lanes[]);
bool DpcdUpdateLinkTraining(const dpcd::TrainingLaneSet lanes[]);
template <uint32_t addr, typename T>
bool DpcdReadPairedRegs(hwreg::RegisterBase<T, typename T::ValueType>* status);
bool DpcdHandleAdjustRequest(dpcd::TrainingLaneSet* training, dpcd::AdjustRequestLane* adjust);
bool DoLinkTraining();
bool LinkTrainingSetup();
// For locking Clock Recovery Circuit of the DisplayPort receiver
bool LinkTrainingStage1(dpcd::TrainingPatternSet* tp_set, dpcd::TrainingLaneSet* lanes);
// For optimizing equalization, determining symbol boundary, and achieving inter-lane alignment
bool LinkTrainingStage2(dpcd::TrainingPatternSet* tp_set, dpcd::TrainingLaneSet* lanes);
bool SetBacklightOn(bool on);
bool InitBacklightHw() override;
bool IsBacklightOn();
// Sets the backlight brightness with |val| as a coefficient on the maximum
// brightness. |val| must be in [0, 1]. If the panel has a minimum fractional
// brightness, then |val| will be clamped to [min, 1].
bool SetBacklightBrightness(double val);
bool HandleHotplug(bool long_pulse) override;
bool HasBacklight() override;
zx_status_t SetBacklightState(bool power, double brightness) override;
zx_status_t GetBacklightState(bool* power, double* brightness) override;
void SetLinkRate(uint32_t value);
// The object referenced by this pointer must outlive the DpDisplay.
DpcdChannel* dp_aux_; // weak
// Contains a value only if successfully initialized via Query().
std::optional<DpCapabilities> capabilities_;
// The current lane count and link rate. 0 if invalid/uninitialized.
uint8_t dp_lane_count_ = 0;
// The current per-lane link rate configuration. Use SetLinkRate to mutate the value which also
// updates the related inspect properties.
//
// These values can be initialized by:
// 1. InitWithDpllState based on an the current DPLL state
// 2. Init, which selects the highest supported link rate
//
// The lane count is always initialized to the maximum value that the device can support in
// Query().
uint32_t dp_link_rate_mhz_ = 0;
std::optional<uint8_t> dp_link_rate_table_idx_;
// The backlight brightness coefficient, in the range [min brightness, 1].
double backlight_brightness_ = 1.0f;
// Debug
inspect::Node inspect_node_;
inspect::UintProperty dp_lane_count_inspect_;
inspect::UintProperty dp_link_rate_mhz_inspect_;
};
} // namespace i915
#endif // SRC_GRAPHICS_DISPLAY_DRIVERS_INTEL_I915_DP_DISPLAY_H_ | c |
SomeUIKit/Classes/ViewController/WQSubTransitionViewController.h | wang68543/SomeUIKit | 0 | 2693862 | //
// WQSubTransitionViewController.h
// SomeUIKit
//
// Created by WangQiang on 2017/3/6.
// Copyright © 2017年 WangQiang. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface WQSubTransitionViewController : UIViewController
@end | c |
core/Component/GuideViewController.h | ArminZhang/Core_IOS | 0 | 5490111 | //
// GuideViewController.h
// 初次使用时的新手指引界面组件
//
// Created by apple on 16/1/5.
// Copyright © 2016年 armin. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface GuideViewController : UIViewController
{
BOOL _animating;
UIScrollView *_pageScroll;
}
@property (nonatomic, assign) BOOL animating;
@property (nonatomic, strong) UIScrollView *pageScroll;
+ (GuideViewController *)sharedGuide;
+ (void)show:(NSArray *)imgArray enter:(UIButton *)enterButton;
+ (void)hide;
@end | c |
src/cps/cps_receiver/cps_receiver.h | vaibhavkhanduja/CPS | 3 | 1223788 | /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <fcntl.h>
#include <signal.h>
#include <getopt.h>
#include <sys/epoll.h>
#include <linux/kdev_t.h>
#include <time.h>
#include "../../common/mem_ops.h"
#include "../../common/structures.h"
#include "../../common/deserialize.h"
#ifndef __NO_KMOD__
#include "lkm.h"
#endif
#include "utils.h"
#include "netlink.h"
#define CPS_VERSION 0.1
#define CPS_MODULE_NAME "cps"
#define CPS_MODULE_PATH "./cps.ko"
#define MAXEVENTS 2
#define MEM_LIMIT 30000
void do_segfault();
void add_data(syscall_intercept_info *i);
void free_data(syscall_intercept_info *i); | c |
Example/Pods/Target Support Files/Pods-EBUITools_Tests/Pods-EBUITools_Tests-umbrella.h | ezequielbrrt/EBUITools | 0 | 6147551 | #ifdef __OBJC__
#import <UIKit/UIKit.h>
#else
#ifndef FOUNDATION_EXPORT
#if defined(__cplusplus)
#define FOUNDATION_EXPORT extern "C"
#else
#define FOUNDATION_EXPORT extern
#endif
#endif
#endif
FOUNDATION_EXPORT double Pods_EBUITools_TestsVersionNumber;
FOUNDATION_EXPORT const unsigned char Pods_EBUITools_TestsVersionString[]; | c |
src/images/fighters/enemyOne/EnemyOne_42.h | filmote/Karateka_Pokitto | 1 | 3655738 | // Automatically generated file, do not edit.
#pragma once
const uint8_t EnemyOne_42[] = {
12, 8,
0xee,0xe6,0x6e,0xee,0xee,0xee,
0xee,0x66,0x66,0xee,0xee,0xee,
0xe6,0x66,0x66,0x6e,0xee,0xee,
0x66,0x66,0x66,0x6e,0xee,0xee,
0xee,0xcc,0x66,0x6e,0xee,0xee,
0xe6,0x66,0x66,0x6e,0xee,0xee,
0x66,0x66,0x66,0x6e,0xee,0xee,
0x66,0x6c,0xcc,0xee,0xee,0xee
}; | c |
test/features/mutex_test/mutex_recursive.c | nbeaver/mx-trunk | 0 | 7115790 | #include <stdio.h>
#include <stdlib.h>
#include "mx_osdef.h"
#include "mx_util.h"
#include "mx_mutex.h"
int
main( int argc, char *argv[] )
{
MX_MUTEX *mutex;
int i;
long status;
mx_status_type mx_status;
fprintf(stderr, "Recursive mutex test started.\n");
fprintf(stderr, "Creating the mutex.\n");
mx_status = mx_mutex_create( &mutex );
if ( mx_status.code != MXE_SUCCESS )
exit( mx_status.code );
/* Try to lock the mutex 3 times in a row. */
for ( i = 0; i < 3; i++ ) {
fprintf(stderr, "Lock attempt %d\n", i+1);
status = mx_mutex_lock( mutex );
if ( status != MXE_SUCCESS ) {
fprintf(stderr,
"Attempt %d to lock the mutex failed with MX status = %ld\n",
i+1, status );
exit( status );
}
}
fprintf(stderr, "All lock attempts succeeded.\n");
/* Try to unlock the mutex 3 times in a row. */
for ( i = 0; i < 3; i++ ) {
fprintf(stderr, "Unlock attempt %d\n", i+1);
status = mx_mutex_unlock( mutex );
if ( status != MXE_SUCCESS ) {
fprintf(stderr,
"Attempt %d to unlock the mutex failed with MX status = %ld\n",
i+1, status );
exit( status );
}
}
fprintf(stderr, "All unlock attempts succeeded.\n");
/* Try to unlock one more time, just to see what happens. */
fprintf(stderr, "About to attempt to unlock one time too many.\n");
fprintf(stderr,
"This _should_ result in an error code of some sort.\n");
status = mx_mutex_unlock( mutex );
if ( status == MXE_SUCCESS ) {
fprintf(stderr,
"Attempt to unlock the mutex succeeded when it should have failed.\n" );
exit( MXE_SUCCESS );
}
if ( status != MXE_SUCCESS ) {
fprintf(stderr,
"Attempt %d to unlock the mutex failed with MX status = %ld\n",
i+1, status );
exit( status );
}
/* Destroy the mutex. */
fprintf(stderr, "Destroying the mutex.\n");
mx_status = mx_mutex_destroy( mutex );
if ( mx_status.code != MXE_SUCCESS )
exit( mx_status.code );
exit(0);
} | c |
android/nv_drv/nvidia-uvm/uvm8_range_tree.c | yakuizhao/intel-vaapi-driver | 0 | 2167170 | /*******************************************************************************
Copyright (c) 2015-2019 NVIDIA Corporation
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to
deal in the Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
sell copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*******************************************************************************/
#include "uvm_common.h"
#include "uvm8_range_tree.h"
static uvm_range_tree_node_t *get_range_node(struct rb_node *rb_node)
{
return rb_entry(rb_node, uvm_range_tree_node_t, rb_node);
}
static bool range_nodes_overlap(uvm_range_tree_node_t *a, uvm_range_tree_node_t *b)
{
return uvm_ranges_overlap(a->start, a->end, b->start, b->end);
}
// Workhorse tree walking function.
//
// The parent and next pointers may be NULL if the caller doesn't need them.
// They facilitate node addition and range-based searches.
//
// If a node contains addr:
// - That node is returned
// - The parent pointer is set to node's parent, or to NULL if the node is the
// root.
// - The next pointer is set to the next node in address order in the tree, or
// to NULL if node is the last node in the tree.
//
// If no node contains addr:
// - NULL is returned
// - The parent pointer is set to the node under which a new node containing
// addr should be inserted. This will be NULL if the tree is empty.
// - The next pointer is set to the first node containing an address > addr, or
// NULL if there are no such nodes in the tree.
static uvm_range_tree_node_t *range_node_find(uvm_range_tree_t *tree,
NvU64 addr,
uvm_range_tree_node_t **parent,
uvm_range_tree_node_t **next)
{
struct rb_node *rb_node = tree->rb_root.rb_node;
uvm_range_tree_node_t *node = NULL;
uvm_range_tree_node_t *_parent = NULL;
while (rb_node) {
node = get_range_node(rb_node);
if (addr < node->start)
rb_node = rb_node->rb_left;
else if (addr > node->end)
rb_node = rb_node->rb_right;
else // node contains addr
break;
_parent = node;
}
if (!rb_node)
node = NULL;
if (parent)
*parent = _parent;
if (next) {
*next = NULL; // Handles the empty tree case
if (node) {
*next = uvm_range_tree_next(tree, node);
}
else if (_parent) {
if (_parent->start > addr)
*next = _parent;
else
*next = uvm_range_tree_next(tree, _parent);
}
}
return node;
}
void uvm_range_tree_init(uvm_range_tree_t *tree)
{
memset(tree, 0, sizeof(*tree));
tree->rb_root = RB_ROOT;
INIT_LIST_HEAD(&tree->head);
}
NV_STATUS uvm_range_tree_add(uvm_range_tree_t *tree, uvm_range_tree_node_t *node)
{
uvm_range_tree_node_t *match, *parent, *prev, *next;
UVM_ASSERT(node->start <= node->end);
match = range_node_find(tree, node->start, &parent, NULL);
if (match)
return NV_ERR_UVM_ADDRESS_IN_USE;
// If no match we know that the new start isn't contained in any existing
// node, but we still have to check for overlap on the rest of the new range.
// If there's no parent and we didn't match on the root node, the tree is
// empty.
if (!parent) {
rb_link_node(&node->rb_node, NULL, &tree->rb_root.rb_node);
rb_insert_color(&node->rb_node, &tree->rb_root);
list_add(&node->list, &tree->head);
return NV_OK;
}
// We know that start isn't contained in parent, but the rest of the new
// range might be.
if (range_nodes_overlap(node, parent))
return NV_ERR_UVM_ADDRESS_IN_USE;
// Verify that the new node doesn't overlap with its neighbor and insert
if (node->start < parent->start) {
// parent's prev can't overlap with node, otherwise it must overlap with
// start and would've been found by range_node_find above.
prev = uvm_range_tree_prev(tree, parent);
if (prev)
UVM_ASSERT(!range_nodes_overlap(node, prev));
rb_link_node(&node->rb_node, &parent->rb_node, &parent->rb_node.rb_left);
list_add_tail(&node->list, &parent->list);
}
else {
next = uvm_range_tree_next(tree, parent);
if (next && range_nodes_overlap(node, next))
return NV_ERR_UVM_ADDRESS_IN_USE;
rb_link_node(&node->rb_node, &parent->rb_node, &parent->rb_node.rb_right);
list_add(&node->list, &parent->list);
}
rb_insert_color(&node->rb_node, &tree->rb_root);
return NV_OK;
}
void uvm_range_tree_shrink_node(uvm_range_tree_t *tree, uvm_range_tree_node_t *node, NvU64 new_start, NvU64 new_end)
{
UVM_ASSERT_MSG(new_start <= new_end, "new_start 0x%llx new_end 0x%llx\n", new_start, new_end);
UVM_ASSERT_MSG(node->start <= new_start, "start 0x%llx new_start 0x%llx\n", node->start, new_start);
UVM_ASSERT_MSG(node->end >= new_end, "end 0x%llx new_end 0x%llx\n", node->end, new_end);
// The tree is not needed currently, but might be in the future.
(void)tree;
node->start = new_start;
node->end = new_end;
}
void uvm_range_tree_split(uvm_range_tree_t *tree,
uvm_range_tree_node_t *existing,
uvm_range_tree_node_t *new)
{
NV_STATUS status;
UVM_ASSERT(new->start > existing->start);
UVM_ASSERT(new->start <= existing->end);
// existing doesn't have to move anywhere, we just need to adjust its
// ranges. new will need to be inserted into the tree.
//
// Future optimization: insertion could walk down the tree starting from
// existing rather than from the root.
new->end = existing->end;
existing->end = new->start - 1;
status = uvm_range_tree_add(tree, new);
UVM_ASSERT(status == NV_OK); // There shouldn't be any collisions
}
uvm_range_tree_node_t *uvm_range_tree_merge_prev(uvm_range_tree_t *tree, uvm_range_tree_node_t *node)
{
uvm_range_tree_node_t *prev = uvm_range_tree_prev(tree, node);
if (!prev || prev->end != node->start - 1)
return NULL;
uvm_range_tree_remove(tree, prev);
node->start = prev->start;
return prev;
}
uvm_range_tree_node_t *uvm_range_tree_merge_next(uvm_range_tree_t *tree, uvm_range_tree_node_t *node)
{
uvm_range_tree_node_t *next = uvm_range_tree_next(tree, node);
if (!next || next->start != node->end + 1)
return NULL;
uvm_range_tree_remove(tree, next);
node->end = next->end;
return next;
}
uvm_range_tree_node_t *uvm_range_tree_find(uvm_range_tree_t *tree, NvU64 addr)
{
return range_node_find(tree, addr, NULL, NULL);
}
uvm_range_tree_node_t *uvm_range_tree_iter_first(uvm_range_tree_t *tree, NvU64 start, NvU64 end)
{
uvm_range_tree_node_t *node, *next;
UVM_ASSERT(start <= end);
node = range_node_find(tree, start, NULL, &next);
if (node)
return node;
// We didn't find a node containing start itself. Check if the target range
// overlaps with the next node after start.
if (next) {
// Sanity checks
UVM_ASSERT(start < next->start);
if (uvm_range_tree_prev(tree, next))
UVM_ASSERT(uvm_range_tree_prev(tree, next)->end < start);
if (next->start <= end)
return next;
}
return NULL;
} | c |
base/core/include/motis/core/common/date_time_util.h | julianharbarth/motis | 0 | 5152885 | #pragma once
#include <ctime>
#include <string>
namespace boost::gregorian {
class date;
} // namespace boost::gregorian
namespace motis {
std::time_t to_unix_time(int year, int month, int day);
int hhmm_to_min(int hhmm);
std::string format_unixtime(time_t t);
std::time_t to_unix_time(boost::gregorian::date const&);
} // namespace motis | c |
runtime/Log.h | 0xxd0/SxCocoa | 3 | 7071252 | //
// Log.h
//
// Created by <NAME> on 2016/12/1.
// Copyright (c) 2021 <NAME>. All rights reserved.
//
_Pragma("once")
#ifdef __OBJC__
#define NSLog(format, ...) \
do { \
fprintf(stderr, "<%s : %d> %s\n", \
[[[NSString stringWithUTF8String:__FILE__] lastPathComponent] UTF8String], \
__LINE__, \
__func__); \
(NSLog)((format), ##__VA_ARGS__); \
fprintf(stderr, "-----------\n"); \
} while (0)
#endif | c |
c/allergies/src/allergies.c | rootbeersoup/exercism | 0 | 380738 | #include "allergies.h"
bool is_allergic_to(allergen_t allergen, unsigned int score) {
return !!(score & (1 << allergen));
}
allergen_list_t get_allergens(unsigned int score) {
allergen_list_t list = {0, {0}};
for (int i = 0; i < ALLERGEN_COUNT; i++) {
if (is_allergic_to(i, score)) {
list.allergens[i] = true;
list.count++;
}
}
return list;
} | c |
include/plotter.h | VedantParanjape/pid-plotter-component | 4 | 4252317 | #ifndef PLOTTER_H
#define PLOTTER_H
#include "json_handler.h"
#include "udp_handler.h"
#include "tcp_handler.h"
#include "transport.h"
void plotter();
#endif | c |
Carinfo.c | 9yon6yon-6yon/100DaysChallenge | 0 | 4660925 | #include <stdio.h>
struct car
{
int car_id;
char brand_name[15];
int model;
};
void print(struct car info[], int n)
{
int i;
FILE *otp = fopen("caroutput.txt", "a");
for (i = 0; i < n; i++)
{
fprintf(otp, "\nID : %d \n Name : %s \n Model : %d ", info[i].car_id, info[i].brand_name, info[i].model);
}
fclose(otp);
}
int latestModel(struct car info[], int n)
{
int i, p;
FILE *otp = fopen("caroutput.txt", "a");
int latest = info[0].model;
for (i = 0; i < n; i++)
{
if (latest < info[i].model)
{
latest = info[i].model;
p = i;
}
}
fprintf(otp, "\n========================");
fprintf(otp, "\nLatest Model :\n ID : %d \n Name : %s \n Model : %d", info[p].car_id, info[p].brand_name, info[p].model);
fclose(otp);
}
int main()
{
int i, n;
int milestone1, milestone2;
FILE *inp = fopen("carinput.txt", "r");
FILE *otp = fopen("caroutput.txt", "w");
if (inp == NULL)
{
printf("404 not found\n");
}
fscanf(inp, "%d", &n);
struct car info[n];
for (i = 0; i < n; i++)
{
fscanf(inp, "%d \t %s \t %d \n", &info[i].car_id, info[i].brand_name, &info[i].model);
}
print(info, n);
latestModel(info, n);
fclose(inp);
fclose(otp);
return 0;
}
/*Declare a structure car with attributes car_id, brand_name(Toyota, Nissan etc.),
model(2016, 2018 etc.), mileage(value in the range 0‐200 denoting thousands of miles).
Write a program to
Take five cars’ information as input.
Print all four attributes of the car which is the latest model.
Take a mileage range as input from user. Find the car_id of all cars within that mileage range.
Note: All inputs must be taken from a file “input.txt” and all outputs must be sent to a file “output.txt”.
You must submit the source code, the input file and the output file.*/ | c |
libs/airmapd/include/airmap/outcome.h | uavosky/uavosky-qgroundcontrol | 12 | 2914774 | #ifndef AIRMAP_OUTCOME_H_
#define AIRMAP_OUTCOME_H_
#include <type_traits>
namespace airmap {
/// Outcome models a return value from a function XOR an error object
/// describing the error condition if no value can be returned.
template <typename Value, typename Error>
class Outcome {
public:
/// @cond
static_assert(not std::is_same<Value, Error>::value, "Value and Error must not be the same type");
static_assert(std::is_copy_constructible<Value>::value && std::is_move_constructible<Value>::value,
"Value must be copy- and move-constructible");
static_assert(std::is_copy_constructible<Error>::value && std::is_move_constructible<Error>::value,
"Error must be copy- and move-constructible");
/// @endcond
/// Outcome initializes a new instance with value.
explicit Outcome(const Value& value) : type{Type::value} {
new (&data.value) Value{value};
}
/// Outcome initializes a new instance with error.
explicit Outcome(const Error& error) : type{Type::error} {
new (&data.error) Error{error};
}
/// Outcome initializes a new instance with the value or error of 'other'.
Outcome(const Outcome& other) : type{other.type} {
switch (type) {
case Type::error:
new (&data.error) Error{other.data.error};
break;
case Type::value:
new (&data.value) Value{other.data.value};
break;
}
}
/// Outcome initializes a new instance with the value or error of 'other'.
Outcome(Outcome&& other) : type{other.type} {
switch (type) {
case Type::error:
new (&data.error) Error{other.data.error};
break;
case Type::value:
new (&data.value) Value{other.data.value};
break;
}
}
/// Outcome assigns the value or error contained in 'other' to this instance.
Outcome& operator=(const Outcome& other) {
switch (type) {
case Type::error: {
(&data.error)->~Error();
break;
}
case Type::value: {
(&data.value)->~Value();
break;
}
}
type = other.type;
switch (type) {
case Type::error: {
new (&data.error) Error{other.data.error};
break;
}
case Type::value: {
new (&data.value) Value{other.data.value};
break;
}
}
return *this;
}
/// Outcome assigns the value or error contained in 'other' to this instance.
Outcome& operator=(Outcome&& other) {
switch (type) {
case Type::error: {
(&data.error)->~Error();
break;
}
case Type::value: {
(&data.value)->~Value();
break;
}
}
type = other.type;
switch (type) {
case Type::error: {
new (&data.error) Error{other.data.error};
break;
}
case Type::value: {
new (&data.value) Value{other.data.value};
break;
}
}
return *this;
}
/// ~Outcome frees up the contained error or value contained in this instance.
~Outcome() {
switch (type) {
case Type::error:
data.error.~Error();
break;
case Type::value:
data.value.~Value();
break;
}
}
/// operator bool returns true if a value is contained in this instance.
explicit operator bool() const {
return !has_error();
}
/// has_error returns true if this instance carries an error.
inline bool has_error() const {
return type == Type::error;
}
/// has_value returns true if this instance carries a value.
inline bool has_value() const {
return type == Type::value;
}
/// error returns an immutable reference to the Error contained in this instance.
/// The result of this call is undefined if has_error() returns false.
inline const Error& error() const {
return data.error;
}
/// value returns an immutable reference to the Value contained in this instance.
/// The result of this call is undefined if has_value() returns false.
inline const Value& value() const {
return data.value;
}
private:
enum class Type { value, error };
Type type;
union Data {
Data() : value{} {
}
~Data() {
}
Value value;
Error error;
} data;
};
} // namespace airmap
#endif // AIRMAP_OUTCOME_H_ | c |
src/trusted/validator_arm/ncvalidate.h | eseidel/native_client_patches | 4 | 2217935 | /*
* Copyright 2009 The Native Client Authors. All rights reserved.
* Use of this source code is governed by a BSD-style license that can
* be found in the LICENSE file.
* Copyright 2009, Google Inc.
*/
#ifndef NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_V2_NCVALIDATE_H
#define NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_V2_NCVALIDATE_H
/*
* The C interface to the validator, for use by the sel_ldr (which isn't
* C++). This provides a restricted version of the validation process,
* without detailed user feedback, etc.
*
* This header file must be valid C and C++!
*/
#include <stdint.h>
#include "native_client/src/include/portability.h"
EXTERN_C_BEGIN
/*
* Validates a complete code segment.
* Arguments:
* mbase location of the code in memory right now.
* vbase virtual address where the code will appear at runtime.
* size number of bytes of code provided.
* Result: 0 if validation succeeded, non-zero if we found problems.
*/
int NCValidateSegment(uint8_t *mbase, uint32_t vbase, size_t size);
EXTERN_C_END
#endif // NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_ARM_V2_NCVALIDATE_H | c |
EasyBimehLanding/Models/ElectronicEquipmentInsurance.h | kmelodi/EasyBimehLanding_IOS | 0 | 2315930 | //
// EasyBimehLanding
//
// This file was automatically generated by APIMATIC v2.0 ( https://apimatic.io ).
//
#ifndef APIMATIC_ELECTRONICEQUIPMENTINSURANCE
#define APIMATIC_ELECTRONICEQUIPMENTINSURANCE
#import <Foundation/Foundation.h>
#import "JSONModel.h"
#import "APIHelper.h"
#import "Franchisee.h"
#import "DeviceType.h"
#import "InsuranceCompany.h"
#import "InsurancePolicyTerm.h"
#import "Province.h"
#import "ShippingType.h"
#import "PostType.h"
#import "InsurancePolicyCondition.h"
#import "InsuranceData.h"
//protocol defined for deserialization of JSON
@protocol ElectronicEquipmentInsurance
@end
@interface ElectronicEquipmentInsurance : JSONModel
/**
* آیا این نوع بیمه نامه، طرح بیمه ای دارد؟
*/
@property BOOL hasPlan;
/**
* لیست فرانشیز های بیمه ی تجهیزات الکترونیک
*/
@property NSArray<Franchisee> * franchisees;
/**
* انواع دستگاه ها
*/
@property NSArray<DeviceType> * deviceTypes;
/**
* برند های دستگاه ها
*/
@property NSArray* deviceBrands;
/**
* مدل های دستگاه ها
*/
@property NSArray* deviceModels;
/**
* شرکت های بیمه ی ارائه دهنده ی بیمه ی تجهیزات الکترونیک
*/
@property NSArray<InsuranceCompany> * insuranceCompanies;
/**
* پوشش های اضافه
*/
@property NSArray* insuranceExtraCoverage;
/**
* دوره های بیمه نامه
*/
@property NSArray<InsurancePolicyTerm> * insurancePolicyTerms;
/**
* لیست استان ها
*/
@property NSArray<Province> * provinces;
/**
* لیست شهر ها
*/
@property NSArray* cities;
/**
* لیست محله ها
*/
@property NSArray* cityRegions;
/**
* روش های دریافت بیمه نامه
*/
@property NSArray<ShippingType> * shippingTypes;
/**
* روش های ارسال بیمه نامه
*/
@property NSArray<PostType> * postTypes;
/**
* شرایط بیمه نامه
*/
@property InsurancePolicyCondition* insurancePolicyCondition;
/**
* اطلاعات بیمه نامه
*/
@property InsuranceData* insuranceData;
/**
* Key mappings for the json serialization and deserialization
*/
+(NSDictionary*) keyMap;
/**
* Key mapper for json serialization and deserialization
*/
+(JSONKeyMapper*) keyMapper;
/**
* Helps avoiding deserialization errors when one or more properties are missing
* @returns True, indicating that all properties are optional for deserialization
*/
+(BOOL)propertyIsOptional:(NSString*) propertyName;
@end
#endif | c |
test/3d/mpi/test_planes.h | cedar-framework/cedar | 9 | 6516872 | #ifndef CEDAR_TEST_3D_MPI_PLANES_H
#define CEDAR_TEST_3D_MPI_PLANES_H
#include <gtest/gtest.h>
#include <cedar/3d/gallery.h>
#include <cedar/3d/mpi/gallery.h>
#include <cedar/3d/util/topo.h>
#include <cedar/3d/types.h>
#include <cedar/3d/mpi/types.h>
#include <cedar/3d/kernel_manager.h>
#include <cedar/3d/mpi/kernel_manager.h>
void set_rhs(cedar::cdr3::grid_func & b);
void set_rhs(cedar::cdr3::mpi::grid_func & b);
void set_sol(cedar::cdr3::grid_func & x);
void set_sol(cedar::cdr3::mpi::grid_func & x);
template<class sten>
cedar::cdr3::stencil_op<sten> create_op_ser(cedar::len_t nx, cedar::len_t ny, cedar::len_t nz);
template<class sten>
cedar::cdr3::mpi::stencil_op<sten> create_op_mpi(cedar::topo_ptr grid);
template<cedar::relax_dir rdir, class sten>
void plane_test(cedar::len_t nx, cedar::len_t ny, cedar::len_t nz)
{
using namespace cedar;
using namespace cedar::cdr3;
config conf("test-planes-mpi.json");
log::init(conf);
int nsweeps = 3;
auto kman_ser = build_kernel_manager(conf);
auto kman_mpi = mpi::build_kernel_manager(conf);
auto grid = util::create_topo_global(MPI_COMM_WORLD, nx, ny, nz);
auto so_ser = create_op_ser<sten>(nx, ny, nz);
grid_func b_ser(nx, ny, nz), x_ser(nx, ny, nz);
set_rhs(b_ser);
set_sol(x_ser);
auto so_mpi = create_op_mpi<sten>(grid);
mpi::grid_func b_mpi(grid), x_mpi(grid);
set_rhs(b_mpi);
set_sol(x_mpi);
// setup halo
{
auto & halo_service = kman_mpi->services().get<mpi::halo_exchange>();
std::vector<topo_ptr> topos{{so_mpi.grid_ptr()}};
halo_service.setup(topos);
halo_service.run(so_mpi);
halo_service.run(x_mpi);
halo_service.run(b_mpi);
}
kman_ser->setup<plane_relax<rdir>>(so_ser);
kman_mpi->setup<mpi::plane_relax<rdir>>(so_mpi);
for (auto i : range(nsweeps)) {
(void)i;
kman_ser->run<plane_relax<rdir>>(so_ser, x_ser, b_ser, cycle::Dir::DOWN);
kman_ser->run<plane_relax<rdir>>(so_ser, x_ser, b_ser, cycle::Dir::UP);
kman_mpi->run<mpi::plane_relax<rdir>>(so_mpi, x_mpi, b_mpi, cycle::Dir::DOWN);
kman_mpi->run<mpi::plane_relax<rdir>>(so_mpi, x_mpi, b_mpi, cycle::Dir::UP);
}
mpi::grid_func diff(grid);
diff.set(0.0);
for (auto k : x_mpi.range(2)) {
for (auto j : x_mpi.range(1)) {
for (auto i : x_mpi.range(0)) {
len_t is = grid->is(0) + i - 1;
len_t js = grid->is(1) + j - 1;
len_t ks = grid->is(2) + k - 1;
diff(i,j,k) = std::abs(x_mpi(i,j,k) - x_ser(is,js,ks));
}
}
}
ASSERT_EQ(diff.inf_norm(), 0);
}
#endif | c |
Sources/Elastos/Packages/Apps/Dialer/inc/elastos/droid/dialer/calllog/CallLogQuery.h | jingcao80/Elastos | 7 | 2012454 | //=========================================================================
// Copyright (C) 2012 The Elastos Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//=========================================================================
#ifndef __ELASTOS_DROID_DIALER_CALLLOG_CALLLOGQUERY_H__
#define __ELASTOS_DROID_DIALER_CALLLOG_CALLLOGQUERY_H__
#include "_Elastos.Droid.Dialer.h"
namespace Elastos {
namespace Droid {
namespace Dialer {
namespace CallLog {
/**
* The query for the call log table.
*/
class CallLogQuery
{
public:
static const AutoPtr<ArrayOf<String> > _PROJECTION;
static const Int32 ID = 0;
static const Int32 NUMBER = 1;
static const Int32 DATE = 2;
static const Int32 DURATION = 3;
static const Int32 CALL_TYPE = 4;
static const Int32 COUNTRY_ISO = 5;
static const Int32 VOICEMAIL_URI = 6;
static const Int32 GEOCODED_LOCATION = 7;
static const Int32 CACHED_NAME = 8;
static const Int32 CACHED_NUMBER_TYPE = 9;
static const Int32 CACHED_NUMBER_LABEL = 10;
static const Int32 CACHED_LOOKUP_URI = 11;
static const Int32 CACHED_MATCHED_NUMBER = 12;
static const Int32 CACHED_NORMALIZED_NUMBER = 13;
static const Int32 CACHED_PHOTO_ID = 14;
static const Int32 CACHED_FORMATTED_NUMBER = 15;
static const Int32 IS_READ = 16;
static const Int32 NUMBER_PRESENTATION = 17;
static const Int32 ACCOUNT_COMPONENT_NAME = 18;
static const Int32 ACCOUNT_ID = 19;
static const Int32 FEATURES = 20;
static const Int32 DATA_USAGE = 21;
static const Int32 TRANSCRIPTION = 22;
};
} // CallLog
} // Dialer
} // Droid
} // Elastos
#endif //__ELASTOS_DROID_DIALER_CALLLOG_CALLLOGQUERY_H__ | c |
Pods/TunnelKit/TunnelKit/Sources/Protocols/OpenVPN/PacketMacros.h | sundaleek/VPNCore | 0 | 7442133 | //
// PacketMacros.h
// TunnelKit
//
// Created by <NAME> on 7/11/18.
// Copyright (c) 2020 <NAME>. All rights reserved.
//
// https://github.com/passepartoutvpn
//
// This file is part of TunnelKit.
//
// TunnelKit is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// TunnelKit is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with TunnelKit. If not, see <http://www.gnu.org/licenses/>.
//
// This file incorporates work covered by the following copyright and
// permission notice:
//
// Copyright (c) 2018-Present Private Internet Access
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
#import <Foundation/Foundation.h>
NS_ASSUME_NONNULL_BEGIN
#define PacketOpcodeLength ((NSInteger)1)
#define PacketIdLength ((NSInteger)4)
#define PacketSessionIdLength ((NSInteger)8)
#define PacketAckLengthLength ((NSInteger)1)
#define PacketPeerIdLength ((NSInteger)3)
#define PacketPeerIdDisabled ((uint32_t)0xffffffu)
#define PacketReplayIdLength ((NSInteger)4)
#define PacketReplayTimestampLength ((NSInteger)4)
typedef NS_ENUM(uint8_t, PacketCode) {
PacketCodeSoftResetV1 = 0x03,
PacketCodeControlV1 = 0x04,
PacketCodeAckV1 = 0x05,
PacketCodeDataV1 = 0x06,
PacketCodeHardResetClientV2 = 0x07,
PacketCodeHardResetServerV2 = 0x08,
PacketCodeDataV2 = 0x09,
PacketCodeUnknown = 0xff
};
#define DataPacketNoCompress 0xfa
#define DataPacketNoCompressSwap 0xfb
#define DataPacketLZOCompress 0x66
extern const uint8_t DataPacketPingData[16];
static inline void PacketOpcodeGet(const uint8_t *from, PacketCode *_Nullable code, uint8_t *_Nullable key)
{
if (code) {
*code = (PacketCode)(*from >> 3);
}
if (key) {
*key = *from & 0b111;
}
}
// Ruby: header
static inline int PacketHeaderSet(uint8_t *to, PacketCode code, uint8_t key, const uint8_t *_Nullable sessionId)
{
*(uint8_t *)to = (code << 3) | (key & 0b111);
int offset = PacketOpcodeLength;
if (sessionId) {
memcpy(to + offset, sessionId, PacketSessionIdLength);
offset += PacketSessionIdLength;
}
return offset;
}
static inline int PacketHeaderSetDataV2(uint8_t *to, uint8_t key, uint32_t peerId)
{
*(uint32_t *)to = ((PacketCodeDataV2 << 3) | (key & 0b111)) | htonl(peerId & 0xffffff);
return PacketOpcodeLength + PacketPeerIdLength;
}
static inline int PacketHeaderGetDataV2PeerId(const uint8_t *from)
{
return ntohl(*(const uint32_t *)from & 0xffffff00);
}
#pragma mark - Utils
static inline void PacketSwap(uint8_t *ptr, NSInteger len1, NSInteger len2)
{
// two buffers due to overlapping
uint8_t buf1[len1];
uint8_t buf2[len2];
memcpy(buf1, ptr, len1);
memcpy(buf2, ptr + len1, len2);
memcpy(ptr, buf2, len2);
memcpy(ptr + len2, buf1, len1);
}
static inline void PacketSwapCopy(uint8_t *dst, NSData *src, NSInteger len1, NSInteger len2)
{
NSCAssert(src.length >= len1 + len2, @"src is smaller than expected");
memcpy(dst, src.bytes + len1, len2);
memcpy(dst + len2, src.bytes, len1);
const NSInteger preambleLength = len1 + len2;
memcpy(dst + preambleLength, src.bytes + preambleLength, src.length - preambleLength);
}
NS_ASSUME_NONNULL_END | c |
gdb/rust-lang.h | greyblue9/binutils-gdb | 1 | 5150023 | /* Rust language support definitions for GDB, the GNU debugger.
Copyright (C) 2016-2021 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef RUST_LANG_H
#define RUST_LANG_H
#include "demangle.h"
#include "language.h"
#include "value.h"
#include "c-lang.h"
struct parser_state;
struct type;
/* Return true if TYPE is a tuple type; otherwise false. */
extern bool rust_tuple_type_p (struct type *type);
/* Return true if TYPE is a tuple struct type; otherwise false. */
extern bool rust_tuple_struct_type_p (struct type *type);
/* Given a block, find the name of the block's crate. Returns an empty
stringif no crate name can be found. */
extern std::string rust_crate_for_block (const struct block *block);
/* Returns the last segment of a Rust path like foo::bar::baz. Will
not handle cases where the last segment contains generics. */
extern const char *rust_last_path_segment (const char *path);
/* Create a new slice type. NAME is the name of the type. ELT_TYPE
is the type of the elements of the slice. USIZE_TYPE is the Rust
"usize" type to use. The new type is allocated whereever ELT_TYPE
is allocated. */
extern struct type *rust_slice_type (const char *name, struct type *elt_type,
struct type *usize_type);
/* Class representing the Rust language. */
class rust_language : public language_defn
{
public:
rust_language ()
: language_defn (language_rust)
{ /* Nothing. */ }
/* See language.h. */
const char *name () const override
{ return "rust"; }
/* See language.h. */
const char *natural_name () const override
{ return "Rust"; }
/* See language.h. */
const std::vector<const char *> &filename_extensions () const override
{
static const std::vector<const char *> extensions = { ".rs" };
return extensions;
}
/* See language.h. */
void language_arch_info (struct gdbarch *gdbarch,
struct language_arch_info *lai) const override;
/* See language.h. */
bool sniff_from_mangled_name (const char *mangled,
char **demangled) const override
{
*demangled = gdb_demangle (mangled, DMGL_PARAMS | DMGL_ANSI);
return *demangled != NULL;
}
/* See language.h. */
char *demangle_symbol (const char *mangled, int options) const override
{
return gdb_demangle (mangled, options);
}
/* See language.h. */
void print_type (struct type *type, const char *varstring,
struct ui_file *stream, int show, int level,
const struct type_print_options *flags) const override;
/* See language.h. */
gdb::unique_xmalloc_ptr<char> watch_location_expression
(struct type *type, CORE_ADDR addr) const override
{
type = check_typedef (TYPE_TARGET_TYPE (check_typedef (type)));
std::string name = type_to_string (type);
return gdb::unique_xmalloc_ptr<char>
(xstrprintf ("*(%s as *mut %s)", core_addr_to_string (addr),
name.c_str ()));
}
/* See language.h. */
void value_print_inner
(struct value *val, struct ui_file *stream, int recurse,
const struct value_print_options *options) const override;
/* See language.h. */
struct block_symbol lookup_symbol_nonlocal
(const char *name, const struct block *block,
const domain_enum domain) const override
{
struct block_symbol result = {};
if (symbol_lookup_debug)
{
fprintf_unfiltered (gdb_stdlog,
"rust_lookup_symbol_non_local"
" (%s, %s (scope %s), %s)\n",
name, host_address_to_string (block),
block_scope (block), domain_name (domain));
}
/* Look up bare names in the block's scope. */
std::string scopedname;
if (name[cp_find_first_component (name)] == '\0')
{
const char *scope = block_scope (block);
if (scope[0] != '\0')
{
scopedname = std::string (scope) + "::" + name;
name = scopedname.c_str ();
}
else
name = NULL;
}
if (name != NULL)
{
result = lookup_symbol_in_static_block (name, block, domain);
if (result.symbol == NULL)
result = lookup_global_symbol (name, block, domain);
}
return result;
}
/* See language.h. */
int parser (struct parser_state *ps) const override;
/* See language.h. */
void emitchar (int ch, struct type *chtype,
struct ui_file *stream, int quoter) const override;
/* See language.h. */
void printchar (int ch, struct type *chtype,
struct ui_file *stream) const override
{
fputs_filtered ("'", stream);
emitchar (ch, chtype, stream, '\'');
fputs_filtered ("'", stream);
}
/* See language.h. */
void printstr (struct ui_file *stream, struct type *elttype,
const gdb_byte *string, unsigned int length,
const char *encoding, int force_ellipses,
const struct value_print_options *options) const override;
/* See language.h. */
void print_typedef (struct type *type, struct symbol *new_symbol,
struct ui_file *stream) const override
{
type = check_typedef (type);
fprintf_filtered (stream, "type %s = ", new_symbol->print_name ());
type_print (type, "", stream, 0);
fprintf_filtered (stream, ";");
}
/* See language.h. */
bool is_string_type_p (struct type *type) const override;
/* See language.h. */
bool range_checking_on_by_default () const override
{ return true; }
private:
/* Helper for value_print_inner, arguments are as for that function.
Prints structs and untagged unions. */
void val_print_struct (struct value *val, struct ui_file *stream,
int recurse,
const struct value_print_options *options) const;
/* Helper for value_print_inner, arguments are as for that function.
Prints discriminated unions (Rust enums). */
void print_enum (struct value *val, struct ui_file *stream, int recurse,
const struct value_print_options *options) const;
};
#endif /* RUST_LANG_H */ | c |
System/Library/Frameworks/TVServices.framework/TVSMediaRemoteManager.h | lechium/tvOS10Headers | 4 | 6345472 | /*
* This header is generated by classdump-dyld 1.0
* on Wednesday, March 22, 2017 at 9:05:54 AM Mountain Standard Time
* Operating System: Version 10.1 (Build 14U593)
* Image Source: /System/Library/Frameworks/TVServices.framework/TVServices
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by <NAME>.
*/
@protocol TVSPlayback, TVSMediaItem;
@class TVSMediaRemoteCommandHandler, NSDate, NSDictionary, TVSImageProxy;
@interface TVSMediaRemoteManager : NSObject {
BOOL _usingPlayerForCommandHandlerOnly;
BOOL _artworkNeedsUpdate;
id<TVSPlayback> _player;
TVSMediaRemoteCommandHandler* _remoteCommandHandler;
id<TVSMediaItem> _currentMediaItem;
id _elapsedTimeObserverToken;
NSDate* _lastPushDate;
NSDictionary* _lastNowPlayingInfo;
TVSImageProxy* _artworkProxy;
}
@property (nonatomic,retain) id<TVSMediaItem> currentMediaItem; //@synthesize currentMediaItem=_currentMediaItem - In the implementation block
@property (nonatomic,retain) id elapsedTimeObserverToken; //@synthesize elapsedTimeObserverToken=_elapsedTimeObserverToken - In the implementation block
@property (nonatomic,retain) NSDate * lastPushDate; //@synthesize lastPushDate=_lastPushDate - In the implementation block
@property (nonatomic,copy) NSDictionary * lastNowPlayingInfo; //@synthesize lastNowPlayingInfo=_lastNowPlayingInfo - In the implementation block
@property (assign,nonatomic) BOOL artworkNeedsUpdate; //@synthesize artworkNeedsUpdate=_artworkNeedsUpdate - In the implementation block
@property (nonatomic,retain) TVSImageProxy * artworkProxy; //@synthesize artworkProxy=_artworkProxy - In the implementation block
@property (assign,nonatomic) BOOL usingPlayerForCommandHandlerOnly; //@synthesize usingPlayerForCommandHandlerOnly=_usingPlayerForCommandHandlerOnly - In the implementation block
@property (assign,nonatomic,__weak) id<TVSPlayback> player; //@synthesize player=_player - In the implementation block
@property (nonatomic,retain) TVSMediaRemoteCommandHandler * remoteCommandHandler; //@synthesize remoteCommandHandler=_remoteCommandHandler - In the implementation block
+(id)sharedInstance;
+(id)_artworkDictionaryFromImage:(id)arg1 ;
+(id)_mediaItemMetadataProperties;
+(id)_mediaRemotePropertyForMediaItemProperty:(id)arg1 ;
+(id)_mediaRemoteMediaTypeForMediaItemMediaType:(id)arg1 ;
+(int)_mediaRemoteRepeatModeWithPlaylist:(id)arg1 ;
+(int)_mediaRemoteShuffleModeWithPlaylist:(id)arg1 ;
+(void*)_createMediaRemoteLanguageOptionGroupWithAudioOptions:(id)arg1 ;
+(void*)_createMediaRemoteLanguageOptionGroupWithSubtitleOptions:(id)arg1 ;
+(void*)_createMediaRemoteLanguageOptionWithAudioOption:(id)arg1 ;
+(void*)_createMediaRemoteLanguageOptionWithSubtitleOption:(id)arg1 ;
+(id)_mediaItemPropertyToMediaRemotePropertyMapping;
+(id)_mediaRemoteLanguageOptionCharacteristicsForAVMediaSelectionOption:(id)arg1 ;
+(id)_avMediaCharacteristics;
+(id)_mediaRemoteLanguageOptionCharacteristicForAVMediaCharacteristic:(id)arg1 ;
+(unsigned)_MRPlaybackStateFromTVSPlaybackState:(id)arg1 ;
-(void)dealloc;
-(id)init;
-(id)_init;
-(void)_applicationDidBecomeActive:(id)arg1 ;
-(void)setPlayer:(id<TVSPlayback>)arg1 ;
-(id<TVSPlayback>)player;
-(id<TVSMediaItem>)currentMediaItem;
-(void)_playbackStateDidChange:(id)arg1 ;
-(id)SelectedAudioOptionBinding;
-(void)_updateBoundSelectedAudioOption;
-(id)SelectedSubtitleOptionBinding;
-(void)_updateBoundSelectedSubtitleOption;
-(id)ShuffleModeBinding;
-(void)_updateBoundShuffleMode;
-(id)RepeatModeBinding;
-(void)_updateBoundRepeatMode;
-(TVSMediaRemoteCommandHandler *)remoteCommandHandler;
-(id)elapsedTimeObserverToken;
-(void)setElapsedTimeObserverToken:(id)arg1 ;
-(void)setLastNowPlayingInfo:(NSDictionary *)arg1 ;
-(void)setCurrentMediaItem:(id<TVSMediaItem>)arg1 ;
-(void)_pushNowPlayingInfo:(BOOL)arg1 invalidateArtwork:(BOOL)arg2 pushImmediately:(BOOL)arg3 ;
-(void)_currentMediaItemDidChange:(id)arg1 ;
-(void)_currentMediaItemMetadataDidChange:(id)arg1 ;
-(void)setArtworkNeedsUpdate:(BOOL)arg1 ;
-(void)_pushNowPlayingInfoRetry:(BOOL)arg1 pushImmediately:(BOOL)arg2 ;
-(id)_nowPlayingInfo;
-(BOOL)_nowPlayingUpdateCanMerge:(id)arg1 ;
-(id)_nowPlayingArtworkImageProxy;
-(TVSImageProxy *)artworkProxy;
-(void)setArtworkProxy:(TVSImageProxy *)arg1 ;
-(void)_resetPushDate;
-(NSDictionary *)lastNowPlayingInfo;
-(void)tvs_bindSelectedAudioOptionBindingToObject:(id)arg1 withKeyPath:(id)arg2 options:(id)arg3 ;
-(void)tvs_bindSelectedSubtitleOptionBindingToObject:(id)arg1 withKeyPath:(id)arg2 options:(id)arg3 ;
-(void)tvs_bindShuffleModeBindingToObject:(id)arg1 withKeyPath:(id)arg2 options:(id)arg3 ;
-(void)tvs_bindRepeatModeBindingToObject:(id)arg1 withKeyPath:(id)arg2 options:(id)arg3 ;
-(void)setPlayerForCommandHandler:(id)arg1 ;
-(void)startRespondingToRemoteControlEvents;
-(void)stopRespondingToRemoteControlEvents;
-(void)setRemoteCommandHandler:(TVSMediaRemoteCommandHandler *)arg1 ;
-(BOOL)usingPlayerForCommandHandlerOnly;
-(void)setUsingPlayerForCommandHandlerOnly:(BOOL)arg1 ;
-(NSDate *)lastPushDate;
-(void)setLastPushDate:(NSDate *)arg1 ;
-(BOOL)artworkNeedsUpdate;
@end | c |
SSTableView/SSTableView/objc/SSColorButtonCell.h | scrumsnail/SSTableView | 2 | 2652089 | //
// SSColorButtonCell.h
// SSTableView
//
// Created by allthings_LuYD on 2016/12/29.
// Copyright © 2016年 scrum_snail. All rights reserved.
//
#import <UIKit/UIKit.h>
#import "SSCommonTableViewCell.h"
typedef NS_ENUM(NSInteger, ColorButtonCellStyle){
ColorButtonCellStyleRed,
ColorButtonCellStyleBlue,
};
@class SSColorButton;
@interface SSColorButtonCell : UITableViewCell<SSCommonTableViewCell>
@property (nonatomic,strong) SSColorButton *button;
@end
@interface SSColorButton : UIButton
@property (nonatomic,assign) ColorButtonCellStyle style;
@end | c |
VirtualBox-5.0.0/src/VBox/Additions/WINNT/SharedFolders/driver/vbsfhlp.h | egraba/vbox_openbsd | 1 | 7460830 | /* $Id: vbsfhlp.h $ */
/** @file
*
* VirtualBox Windows Guest Shared Folders
*
* File System Driver helpers
*/
/*
* Copyright (C) 2012 Oracle Corporation
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* you can redistribute it and/or modify it under the terms of the GNU
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*/
#ifndef __VBSFHLP__H
#define __VBSFHLP__H
#include <ntifs.h>
#include <ntverp.h>
#include "VBoxGuestR0LibSharedFolders.h"
void vbsfHlpSleep (ULONG ulMillies);
NTSTATUS vbsfHlpCreateDriveLetter (WCHAR Letter, UNICODE_STRING *pDeviceName);
NTSTATUS vbsfHlpDeleteDriveLetter (WCHAR Letter);
/**
* Convert VBox IRT file attributes to NT file attributes
*
* @returns NT file attributes
* @param fMode IRT file attributes
*
*/
uint32_t VBoxToNTFileAttributes (uint32_t fMode);
/**
* Convert VBox IRT file attributes to NT file attributes
*
* @returns NT file attributes
* @param fMode IRT file attributes
*
*/
uint32_t NTToVBoxFileAttributes (uint32_t fMode);
/**
* Convert VBox error code to NT status code
*
* @returns NT status code
* @param vboxRC VBox error code
*
*/
NTSTATUS VBoxErrorToNTStatus (int vboxRC);
PVOID vbsfAllocNonPagedMem (ULONG ulSize);
void vbsfFreeNonPagedMem (PVOID lpMem);
#if defined(DEBUG) || defined (LOG_ENABLED)
PCHAR MajorFunctionString(UCHAR MajorFunction, LONG MinorFunction);
#endif
NTSTATUS vbsfShflStringFromUnicodeAlloc(PSHFLSTRING *ppShflString, const WCHAR *pwc, uint16_t cb);
#endif /* __VBSFHLP__H */ | c |
connectors/mysql/include/sqlpp20/mysql/direct_execution_result.h | rbock/sqlpp20 | 10 | 1486227 | #pragma once
/*
Copyright (c) 2017 - 2020, <NAME>
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sqlpp20/mysql/mysql.h>
#include <sqlpp20/result_row.h>
#include <functional>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
namespace sqlpp ::mysql::detail {
struct result_cleanup_t {
auto operator()(MYSQL_RES* result) const noexcept -> void {
if (result) {
mysql_free_result(result);
}
}
};
using unique_result_ptr = std::unique_ptr<MYSQL_RES, result_cleanup_t>;
inline auto assert_field(char* data) -> void {
if (data == nullptr)
throw std::logic_error("Trying to obtain NULL for non-nullable value");
}
} // namespace sqlpp::mysql::detail
namespace sqlpp ::mysql {
inline auto read_field(char* data, unsigned long length, bool& value) -> void {
detail::assert_field(data);
switch (data[0]) {
case 't':
[[fallthrough]];
case '1':
value = true;
default:
value = false;
}
}
inline auto read_field(char* data, unsigned long length, std::int32_t& value)
-> void {
detail::assert_field(data);
value = std::strtol(data, nullptr, 10);
}
inline auto read_field(char* data, unsigned long length, std::int64_t& value)
-> void {
detail::assert_field(data);
value = std::strtoll(data, nullptr, 10);
}
inline auto read_field(char* data, unsigned long length, float& value) -> void {
detail::assert_field(data);
value = std::strtof(data, nullptr);
}
inline auto read_field(char* data, unsigned long length, double& value)
-> void {
detail::assert_field(data);
value = std::strtod(data, nullptr);
}
inline auto read_field(char* data, unsigned long length,
std::string_view& value) -> void {
detail::assert_field(data);
value = std::string_view(data, length);
}
template <typename T>
auto read_field(char* data, unsigned long length, std::optional<T>& value)
-> void {
if (not data) {
value.reset();
} else {
value = T{};
read_field(data, length, *value);
}
}
template <typename... ColumnSpecs>
auto read_fields(MYSQL_ROW data, unsigned long* lengths,
result_row_t<ColumnSpecs...>& row) -> void {
if (!data)
throw std::logic_error("Trying to obtain value from non-existing row");
std::size_t index = 0;
(..., (read_field(data[index], lengths[index],
static_cast<result_column_base<ColumnSpecs>&>(row)()),
++index));
}
template <typename ResultRow>
class direct_execution_result_t {
static_assert(wrong<ResultRow>, "ResultRow must be a result_row_t<...>");
};
template <typename... ColumnSpecs>
class direct_execution_result_t<result_row_t<ColumnSpecs...>> {
detail::unique_result_ptr _handle;
MYSQL_ROW _data = nullptr;
unsigned long* _lengths = nullptr;
result_row_t<ColumnSpecs...> _row;
public:
using row_type = decltype(_row);
direct_execution_result_t() = default;
direct_execution_result_t(detail::unique_result_ptr handle)
: _handle(std::move(handle)) {}
direct_execution_result_t(const direct_execution_result_t&) = delete;
direct_execution_result_t(direct_execution_result_t&& rhs) = default;
direct_execution_result_t& operator=(const direct_execution_result_t&) =
delete;
direct_execution_result_t& operator=(direct_execution_result_t&&) = default;
~direct_execution_result_t() = default;
[[nodiscard]] operator bool() const { return !!_handle; }
auto get_next_row() -> void {
_data = mysql_fetch_row(_handle.get());
_lengths = mysql_fetch_lengths(_handle.get());
if (_data != nullptr) {
read_fields(_data, _lengths, _row);
} else {
reset();
}
}
[[nodiscard]] auto& row() const { return _row; }
auto* get() const { return _handle.get(); }
auto* get_data() const { return _data; }
auto* get_lengths() const { return _lengths; }
auto reset() { *this = direct_execution_result_t{}; }
};
} // namespace sqlpp::mysql | c |
third_party/mplayer/loader/win32.h | Narflex/sagetv | 292 | 2316440 | /*
* Modified for use with MPlayer, detailed changelog at
* http://svn.mplayerhq.hu/mplayer/trunk/
* $Id: win32.h,v 1.3 2007-04-10 19:33:29 Narflex Exp $
*/
#ifndef loader_win32_h
#define loader_win32_h
#include <time.h>
#include "wine/windef.h"
#include "wine/winbase.h"
#include "com.h"
#ifdef AVIFILE
#ifdef __GNUC__
#include "avm_output.h"
#ifndef __cplusplus
#define printf(a, ...) avm_printf("Win32 plugin", a, ## __VA_ARGS__)
#endif
#endif
#endif
extern void my_garbagecollection(void);
typedef struct {
UINT uDriverSignature;
HINSTANCE hDriverModule;
DRIVERPROC DriverProc;
DWORD dwDriverID;
} DRVR;
typedef DRVR *PDRVR;
typedef DRVR *NPDRVR;
typedef DRVR *LPDRVR;
typedef struct tls_s tls_t;
extern void* LookupExternal(const char* library, int ordinal);
extern void* LookupExternalByName(const char* library, const char* name);
#endif | c |
system_checks/check_pwrite_O_APPEND.c | chkn/logdb | 4 | 3107073 | /*
Tests that `pwrite` doesn't suffer from https://bugzilla.kernel.org/show_bug.cgi?id=43178
*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int
main(int argc, char *argv[])
{
int fd = open("test.dat", O_RDWR | O_CREAT | O_TRUNC | O_APPEND, S_IRUSR | S_IWUSR);
if (fd == -1) {
perror("open");
return 1;
}
/* First write 10 "b"s */
const char* buf = "bbbbbbbbbb";
if (write(fd, buf, 10) == -1) {
perror("write");
return 1;
}
/* Now overwrite first 5 "b"s with "a"s */
buf = "aaaaa";
if (pwrite(fd, buf, 5, 0) == -1) {
perror("pwrite");
return 1;
}
fsync(fd);
char result[10];
if (pread(fd, result, 10, 0) == -1) {
perror("pread");
return 2;
}
int ev = strncmp(result, "aaaaabbbbb", 10);
if (!ev)
unlink("test.dat");
return (ev == 0)? 0 : 3;
} | c |
Source/dldelete.h | powervr-graphics/PowerVR-Series1 | 215 | 5347002 | /******************************************************************************
* Name : dldelete.h
* Title : Display List, "delete" routine
* Author : <NAME>
* Created : 1/06/1995
*
* Copyright : 1995-2022 Imagination Technologies (c)
* License : MIT
*
* Description : various SGL Routines for deleting a node ..
*
* Most of this is covered in TRDD027x.doc
*
* Platform : ANSI compatible
*
* Modifications:-
* $Log: dldelete.h,v $
* Revision 1.1 1995/06/06 15:39:41 sjf
* Initial revision
*
*
*
*****************************************************************************/
extern void DlDeleteNode(DL_NODE_STRUCT * pNode);
/*
// ---------------------- END OF FILE ----------------------------
*/ | c |
lib/cppunit/include/cppunit/TestCaller.h | d8euAI8sMs/qa-1-all | 0 | 1887158 | #ifndef CPPUNIT_TESTCALLER_H // -*- C++ -*-
#define CPPUNIT_TESTCALLER_H
#include <cppunit/Exception.h>
#include <cppunit/TestCase.h>
#include <cppunit/extensions/TestFixtureFactory.h>
#if CPPUNIT_USE_TYPEINFO_NAME
# include <cppunit/extensions/TypeInfoHelper.h>
#endif
CPPUNIT_NS_BEGIN
#if 0
/*! \brief Marker class indicating that no exception is expected by TestCaller.
* This class is an implementation detail. You should never use this class directly.
*/
class CPPUNIT_API NoExceptionExpected
{
private:
//! Prevent class instantiation.
NoExceptionExpected();
};
/*! \brief (Implementation) Traits used by TestCaller to expect an exception.
*
* This class is an implementation detail. You should never use this class directly.
*/
template<class ExceptionType>
struct ExpectedExceptionTraits
{
static void expectedException()
{
#if CPPUNIT_USE_TYPEINFO_NAME
throw Exception( Message(
"expected exception not thrown",
"Expected exception type: " +
TypeInfoHelper::getClassName( typeid( ExceptionType ) ) ) );
#else
throw Exception( "expected exception not thrown" );
#endif
}
};
/*! \brief (Implementation) Traits specialization used by TestCaller to
* expect no exception.
*
* This class is an implementation detail. You should never use this class directly.
*/
template<>
struct ExpectedExceptionTraits<NoExceptionExpected>
{
static void expectedException()
{
}
};
#endif
//*** FIXME: rework this when class Fixture is implemented. ***//
/*! \brief Generate a test case from a fixture method.
* \ingroup WritingTestFixture
*
* A test caller provides access to a test case method
* on a test fixture class. Test callers are useful when
* you want to run an individual test or add it to a
* suite.
* Test Callers invoke only one Test (i.e. test method) on one
* Fixture of a TestFixture.
*
* Here is an example:
* \code
* class MathTest : public CppUnit::TestFixture {
* ...
* public:
* void setUp();
* void tearDown();
*
* void testAdd();
* void testSubtract();
* };
*
* CppUnit::Test *MathTest::suite() {
* CppUnit::TestSuite *suite = new CppUnit::TestSuite;
*
* suite->addTest( new CppUnit::TestCaller<MathTest>( "testAdd", testAdd ) );
* return suite;
* }
* \endcode
*
* You can use a TestCaller to bind any test method on a TestFixture
* class, as long as it accepts void and returns void.
*
* \see TestCase
*/
template <class Fixture>
class TestCaller : public TestCase
{
typedef void (Fixture::*TestMethod)();
public:
/*!
* Constructor for TestCaller.
* \param name name of this TestCaller
* \param test the method this TestCaller calls in runTest()
* \param factory the TestFixtureFactory.
*/
TestCaller(std::string name, TestMethod test, TestFixtureFactory* factory) :
TestCase( name ),
m_fixture( 0 ),
m_test( test ),
m_factory( factory )
{
}
~TestCaller()
{
delete m_factory;
}
void runTest()
{
(m_fixture->*m_test)();
}
void setUp()
{
m_fixture = static_cast<Fixture*>(m_factory->makeFixture());
m_fixture->setUp ();
}
void tearDown()
{
m_fixture->tearDown ();
delete m_fixture;
}
std::string toString() const
{
return "TestCaller " + getName();
}
private:
TestCaller( const TestCaller &other );
TestCaller &operator =( const TestCaller &other );
private:
Fixture *m_fixture;
TestMethod m_test;
TestFixtureFactory *m_factory;
};
CPPUNIT_NS_END
#endif // CPPUNIT_TESTCALLER_H | c |
example/lion.c | mark4th/uCurses | 4 | 4690675 | // -----------------------------------------------------------------------
#include <inttypes.h>
#include "../h/uCurses.h"
#include "demo.h"
screen_t *scr;
window_t *win;
// -----------------------------------------------------------------------
// this image is 100 dots wide and 120 dots high. the glyphs above are
// all two pixles wide and four high. as each character is four dots high
// we only need 30 rows.
#define LION_WIDTH 25
#define LION_HEIGHT 120
uint8_t lion_data[] =
{
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xff,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xff,0xf9,0xe0,0x00,0x00,0x00,0x00,0x03,0xff,0xfc,0x00,0x00,
0x00,0x00,0x03,0xf8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0xfe,0x00,0x00,0x00,0x00,0x00,0x7e,0x1f,0xff,0xe0,0x00,
0x00,0x00,0x00,0x79,0xc0,0x70,0x00,0x00,0x00,0x00,0x00,0x00,0x62,0x27,0x81,0xf8,0x00,0x00,0x00,0x07,0xe1,0xe0,0x07,0xfc,0x00,
0x00,0x00,0x00,0x0f,0x00,0x70,0x00,0x00,0x00,0x00,0x00,0x01,0xc6,0x0f,0xff,0x0c,0x40,0x00,0x00,0x1e,0x77,0x00,0x00,0x7f,0x00,
0x00,0x00,0x00,0x1e,0x42,0x60,0x00,0x00,0x00,0x00,0x00,0x1f,0xfc,0x7f,0xfc,0x02,0x70,0x00,0x00,0x79,0xec,0x00,0x00,0x0f,0xc0,
0x00,0x01,0x9c,0x0f,0xcf,0xe0,0x00,0x00,0x00,0x00,0x1f,0xff,0xe0,0x99,0xfe,0x03,0x3c,0x00,0x01,0xe3,0xd8,0x00,0x60,0x03,0xe0,
0x00,0x07,0x1e,0x07,0xde,0xe0,0x00,0x00,0x00,0x00,0x07,0xf5,0xff,0xff,0xff,0xf3,0x3c,0x00,0x03,0xb6,0xd8,0x00,0x04,0x01,0xf0,
0x00,0x00,0x3f,0xb3,0xff,0x80,0x00,0x00,0x00,0x00,0x7f,0xff,0xff,0xff,0xff,0xf3,0x3e,0x00,0x07,0x6c,0xd8,0x00,0x03,0x00,0xf8,
0x00,0x00,0x1f,0xff,0xfc,0x00,0x00,0x00,0x00,0x00,0x7f,0xff,0xff,0xff,0xff,0xc7,0x3f,0x00,0x0e,0xec,0xec,0x00,0x03,0x00,0x78,
0x00,0x00,0x01,0x7f,0xf8,0x00,0x00,0x00,0x00,0x00,0x7f,0xff,0xff,0x8f,0xff,0x9e,0x7f,0x80,0x0d,0xec,0xee,0x00,0x07,0x00,0x38,
0x00,0x03,0xf0,0xff,0xb8,0x00,0x01,0xe0,0x00,0x00,0x1f,0x03,0xef,0x7f,0xff,0xf1,0xdf,0xe0,0x0b,0xe6,0xf3,0xc0,0x1e,0x00,0x3c,
0x00,0x01,0xff,0xfe,0x98,0x00,0x00,0xf8,0x00,0x00,0x00,0x00,0x19,0xff,0xff,0x3f,0xe3,0xf8,0x1b,0xf7,0x3c,0xff,0xfc,0x00,0x3c,
0x00,0x7c,0xf3,0xfe,0x58,0x00,0x00,0x7c,0x00,0x00,0x00,0x31,0x04,0xfe,0xff,0xc7,0xfe,0x00,0x1b,0x39,0x8f,0xff,0xe0,0x00,0x3c,
0x00,0x19,0xc2,0xff,0xfc,0x00,0x00,0x7e,0x00,0x00,0x06,0x00,0x06,0x6a,0x5f,0x1f,0xf8,0x00,0x1b,0x1c,0xe0,0x00,0x00,0x00,0x3c,
0x00,0x01,0x01,0xff,0xff,0x00,0x00,0x7e,0x00,0x00,0x02,0x00,0x02,0x0b,0x4b,0x7f,0x00,0x00,0x13,0x8f,0x38,0x00,0x00,0x00,0x38,
0x00,0x00,0x00,0xff,0xff,0xc0,0x00,0x3e,0x00,0x00,0x00,0x7f,0xf2,0x0b,0x4b,0x7f,0x80,0x00,0x13,0x83,0xcf,0x00,0x00,0x00,0x78,
0x00,0x00,0x00,0xff,0xff,0xe0,0x00,0x3e,0x00,0x00,0x0f,0xff,0x86,0x7e,0x5b,0xff,0x80,0x00,0x31,0xc0,0x79,0xe0,0x00,0x00,0x70,
0x00,0x00,0x07,0xff,0xff,0xf0,0x00,0x1f,0x00,0x03,0xf8,0x00,0x04,0x7e,0xff,0xff,0x80,0x80,0x7c,0xe0,0x03,0x3c,0x00,0x00,0xf0,
0x00,0x00,0x3f,0xff,0xff,0xfc,0x00,0x07,0xff,0xff,0x80,0x00,0x08,0xff,0xff,0xfb,0x80,0xf0,0x7f,0x78,0x00,0x66,0x00,0x01,0xe0,
0x00,0x01,0xfc,0xff,0xcf,0xfe,0x00,0x00,0xff,0xf8,0x01,0x80,0x63,0xff,0xff,0x99,0x80,0x3f,0x8f,0xbc,0x00,0x13,0x00,0x07,0xc0,
0x00,0x00,0x0f,0xfc,0xff,0xff,0x00,0x00,0x00,0x00,0x01,0x87,0x87,0xbf,0xfb,0x99,0xc0,0x0c,0x03,0xce,0x00,0x0b,0x00,0x0f,0x80,
0x00,0x00,0x00,0xff,0xff,0xff,0x80,0x00,0x00,0x00,0x01,0xff,0xe3,0xbb,0xc9,0xb3,0xc0,0x00,0x00,0x26,0x00,0x0e,0x00,0x3e,0x00,
0x00,0x00,0x03,0xff,0x1f,0xff,0xc0,0x00,0x00,0x00,0x07,0xff,0xf3,0xbb,0x9b,0x37,0xc0,0x00,0x00,0x16,0x00,0x0c,0x01,0xf8,0x00,
0x00,0x00,0x0f,0xff,0xdf,0xfd,0xe0,0x00,0x00,0x00,0x07,0xf3,0xe7,0x77,0x37,0x67,0xe0,0x00,0x00,0x0e,0x00,0x00,0x0f,0xe0,0x00,
0x00,0x00,0x1b,0xff,0xff,0xe4,0xf0,0x00,0x00,0x00,0x0f,0xc0,0x1f,0x76,0x6e,0x7d,0xf0,0x00,0x40,0x0c,0x00,0x00,0x7f,0x80,0x00,
0x00,0x00,0x1c,0x0f,0x8f,0xf6,0x58,0x00,0x00,0x00,0x18,0x3f,0xf7,0x66,0x6e,0xfc,0xf8,0x00,0x38,0x38,0x00,0x07,0xfc,0x00,0x00,
0x00,0x00,0x00,0x03,0xff,0xdb,0x2c,0x00,0x00,0x00,0x01,0xf7,0x6e,0x6e,0xff,0xfe,0xfc,0x00,0x00,0x00,0x00,0xff,0xc0,0x00,0x00,
0x00,0x00,0x00,0x0f,0xe3,0xe9,0x92,0x00,0x00,0x00,0x07,0xcc,0xcc,0xef,0xff,0xff,0x3f,0xc0,0x00,0x00,0x3f,0xf8,0x00,0x00,0x00,
0x00,0x00,0x00,0x3f,0xff,0xa4,0xc8,0x00,0x00,0x00,0x7f,0x9d,0x9b,0xff,0xff,0xfb,0x7f,0xf0,0x00,0x07,0xfe,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x63,0xfd,0xd2,0x00,0x00,0x3f,0xff,0xff,0xbf,0xff,0xff,0xff,0x9f,0xff,0x00,0x00,0xff,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x1c,0x7f,0xc0,0x7f,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xfe,0x48,0x00,0x00,0x07,0xc0,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x07,0xff,0xc7,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xff,0xd8,0x5c,0x00,0x00,0x7c,0x00,0x00,0x00,0x3f,0x80,0x00,
0x00,0x00,0x00,0x00,0xff,0xc3,0xff,0x00,0x40,0x1f,0x3f,0xff,0xff,0xfd,0xb8,0xfc,0x00,0x01,0xe0,0x00,0x00,0x03,0xe0,0x00,0x00,
0x00,0x00,0x00,0x00,0x0f,0xf8,0xff,0xff,0xff,0xf9,0xff,0xff,0xff,0xf9,0x33,0xfc,0x00,0x0f,0x80,0x00,0x00,0x1f,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x3f,0x1c,0x3f,0xff,0xff,0xef,0xdb,0xbf,0xdd,0x9b,0xfb,0xf8,0x00,0x3e,0x00,0x00,0x00,0xf8,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x7f,0xdc,0x03,0xff,0xff,0xf9,0x33,0x4d,0xd5,0x93,0xfb,0xf8,0x00,0x78,0x00,0x00,0x0f,0xc0,0x07,0xf8,0x00,
0x00,0x00,0x00,0x00,0x83,0xf3,0xfc,0x1f,0xff,0xe6,0xe6,0x59,0x95,0x83,0xfb,0xf8,0x01,0xe0,0xff,0xff,0xfc,0x00,0x7f,0x00,0x00,
0x00,0x00,0x00,0x00,0x7f,0xfc,0x66,0x1f,0xff,0x3f,0xee,0xdb,0xb4,0xc3,0xfb,0xf0,0x03,0xff,0xff,0xc0,0x00,0x01,0xf0,0x00,0x00,
0x00,0x00,0x00,0x00,0x07,0xfd,0x3c,0x7f,0xf9,0xff,0xfe,0xff,0xfc,0xc1,0xfd,0xf0,0x07,0xff,0x80,0x00,0x00,0x07,0xc0,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x7e,0x48,0xff,0xcf,0xfb,0xfe,0xff,0xfe,0xe0,0xfd,0xf0,0x0f,0xb8,0x00,0x00,0x00,0x1f,0x80,0x00,0x00,
0x00,0x00,0x00,0x00,0x01,0xff,0xb1,0xfe,0x7f,0xf7,0xfe,0xff,0xde,0x60,0x7e,0xf0,0x1f,0xe0,0x00,0x00,0x00,0x7e,0x00,0x78,0x00,
0x00,0x00,0x00,0x00,0x01,0x9f,0xc3,0xfd,0xff,0xef,0xfe,0xff,0xdf,0x30,0x3e,0x70,0x1f,0xc0,0x00,0x00,0x07,0xf8,0x01,0xc0,0x00,
0x00,0x00,0x00,0x00,0x01,0xff,0x23,0xfb,0xff,0xcf,0x7e,0xff,0xdf,0xb8,0x0f,0x30,0x3f,0x80,0xff,0xff,0xff,0xe0,0x07,0x80,0x00,
0x00,0x00,0x00,0x00,0x00,0x0e,0x87,0xe7,0xff,0x9e,0x3e,0xfb,0xdf,0xde,0x03,0xf0,0x3f,0x87,0xff,0xff,0xff,0x80,0x0f,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x03,0x0f,0xcf,0xff,0x3e,0x3e,0xf9,0xde,0xe7,0x00,0x70,0x3f,0x1f,0xff,0xff,0x80,0x00,0x1a,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x01,0x1f,0xbf,0xff,0x3c,0x3f,0x78,0xcc,0x7b,0xc0,0x00,0x3f,0x3b,0x00,0x00,0x00,0x00,0x24,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x7e,0x7c,0x7e,0x7c,0x1f,0x78,0x6c,0x1c,0xe0,0x00,0x3f,0x64,0x00,0x00,0x00,0x00,0x58,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x01,0xff,0xe0,0x7e,0xf8,0x1f,0xbc,0x3c,0x83,0xb0,0x00,0x3f,0x68,0x00,0x00,0x00,0x03,0x30,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x0f,0xfc,0x00,0x7c,0xf1,0xcf,0x9c,0x18,0xc0,0x30,0x00,0x1f,0xd8,0x04,0x1f,0xff,0xf1,0xc0,0x00,0x10,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x7d,0xe3,0xe3,0xde,0x00,0x6c,0x00,0x00,0x0f,0xf0,0x33,0xff,0xff,0xfc,0x00,0x00,0x70,
0x00,0x00,0x00,0x00,0x00,0x02,0x63,0x66,0x39,0xcf,0xf8,0xee,0x79,0x32,0x40,0x00,0x07,0xf0,0x6f,0x00,0x00,0x00,0x00,0x01,0xe0,
0x00,0x00,0x00,0x00,0x00,0x0c,0xcc,0x9c,0x3b,0x9f,0xfe,0x7f,0x3c,0x99,0xb0,0x00,0x03,0xf0,0xcc,0x00,0x00,0x00,0x00,0x03,0xc0,
0x00,0x00,0x00,0x00,0x00,0x19,0x9d,0xf3,0x3e,0x3f,0xff,0x1f,0x3f,0x6e,0x58,0x00,0x01,0xf0,0xd8,0x00,0x00,0x00,0x00,0x0d,0x80,
0x00,0x00,0x00,0x00,0x00,0x37,0x7f,0xfe,0x9c,0xff,0xff,0xc3,0x7f,0xb3,0x26,0x00,0x00,0x78,0xf8,0x00,0x00,0x00,0x00,0x16,0x00,
0x00,0x00,0x00,0x00,0x00,0x7f,0xff,0xff,0xc1,0xff,0x7f,0xf0,0x7f,0xcd,0xdf,0x00,0x00,0x1e,0x7e,0x00,0x00,0x00,0x00,0x2c,0x00,
0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xf7,0xff,0xf6,0x7f,0xfc,0xff,0xf6,0x6f,0x80,0x00,0x07,0xff,0x80,0x00,0x00,0x00,0x18,0x00,
0x00,0x00,0x00,0x00,0x01,0xff,0xfb,0xe7,0xff,0xd8,0xef,0xff,0xff,0xff,0xbb,0xc0,0x00,0x00,0x7f,0xff,0x00,0x00,0x00,0x58,0x00,
0x00,0x00,0x00,0x00,0x03,0xff,0xfa,0xff,0xfb,0x8f,0x9f,0xff,0xff,0xff,0xdf,0xf0,0x00,0x00,0x07,0xff,0xff,0xff,0xf0,0x4c,0x00,
0x00,0x00,0x00,0x00,0x07,0xff,0xff,0xff,0x3e,0x3e,0x37,0xff,0xff,0xff,0xff,0xfc,0x00,0x00,0x00,0x1f,0xff,0xff,0xff,0x6c,0x00,
0x00,0x00,0x00,0x00,0x1f,0xff,0xf7,0xfb,0x00,0x79,0xcd,0xbf,0xff,0xff,0xff,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x7f,0xf6,0x00,
0x00,0x00,0x00,0x00,0x3f,0xff,0xbf,0xfa,0x00,0x7f,0x76,0x6f,0xff,0xff,0xff,0xff,0x80,0x00,0x00,0x00,0x00,0x00,0x01,0xfe,0x00,
0x00,0x00,0x00,0x00,0xff,0xfc,0xbf,0xfa,0x00,0x07,0xfd,0xbb,0x7f,0xff,0xff,0xff,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0x00,
0x00,0x00,0x00,0x01,0xff,0xfd,0xfe,0x3b,0x00,0x00,0x3f,0xff,0xff,0xff,0xff,0xff,0xf8,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x00,
0x00,0x00,0x00,0x01,0xff,0xed,0xde,0x0f,0x80,0x00,0x00,0x3f,0xff,0xff,0xff,0xff,0xfc,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x00,
0x03,0x80,0x00,0x07,0xf6,0xef,0xde,0x00,0x00,0x00,0x00,0x00,0x00,0x7f,0x6f,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x00,
0x00,0xc7,0x00,0x0f,0xf6,0xff,0xde,0x00,0x00,0x00,0x00,0x00,0x87,0x83,0x2f,0xff,0xff,0x80,0x00,0x00,0x00,0x00,0x00,0x1f,0x00,
0x00,0x1d,0x80,0x1f,0xf6,0xfc,0xde,0x00,0x00,0x00,0x00,0x1e,0x01,0xf8,0x2f,0xff,0xff,0xe0,0x00,0x00,0x00,0x00,0x00,0x1f,0x00,
0x00,0x7d,0xc0,0xff,0xb7,0xfc,0x6c,0x00,0x00,0x00,0x03,0xe2,0x00,0x00,0x47,0xff,0xf7,0xf8,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,
0x00,0x1f,0xff,0xdf,0xbf,0xdc,0x18,0x00,0x00,0xff,0xfc,0x71,0x8c,0x43,0xb7,0xff,0xfb,0xfe,0x00,0x00,0x00,0x00,0x00,0x7c,0x00,
0x0f,0xf3,0xff,0xff,0xff,0xdc,0x00,0x00,0x1f,0xff,0xff,0x9c,0x7f,0x1e,0x4f,0xff,0xfd,0x9f,0xc0,0x00,0x00,0x00,0x00,0xf8,0x00,
0x03,0xff,0xff,0xff,0x7f,0xdc,0x00,0x00,0x3f,0xff,0xff,0xe7,0xf0,0xfb,0xb3,0xff,0xfd,0xbf,0xf8,0x00,0x00,0x00,0x03,0xf0,0x00,
0x39,0xff,0xff,0xff,0x73,0xdc,0x00,0x00,0x3f,0xff,0xfe,0x73,0x8f,0xff,0xeb,0xff,0xfd,0x9f,0xff,0x80,0x00,0x00,0x1f,0xc0,0x00,
0x31,0x0f,0xef,0x9f,0x60,0xfc,0x00,0x00,0x3f,0xff,0xff,0xfe,0x3f,0xff,0xff,0xff,0xfe,0xc7,0xff,0xfe,0x00,0x03,0xfe,0x00,0x00,
0x00,0x3b,0x9b,0xdf,0x40,0x38,0x00,0x00,0x3f,0xff,0xff,0xcc,0x3f,0xff,0xff,0xff,0xfe,0x41,0xff,0xff,0xff,0xff,0xff,0x00,0x00,
0x00,0x7b,0x3d,0xc3,0x00,0x00,0x00,0x00,0x3f,0xff,0xff,0xe6,0x3f,0xff,0xff,0xff,0xff,0x60,0x7f,0xff,0xff,0xff,0xff,0x80,0x00,
0x00,0x0e,0x3e,0x40,0x00,0x00,0x00,0x00,0x3f,0xff,0xff,0xfa,0x3f,0xff,0xff,0xff,0xff,0x20,0x0f,0xcf,0xff,0xfe,0x00,0xc0,0x00,
0x00,0xf0,0x20,0x40,0x00,0x00,0x00,0x00,0x1f,0xff,0xff,0xfc,0x1f,0xff,0xff,0xff,0xff,0xb0,0x00,0xf3,0xfe,0xf8,0x00,0x00,0x00,
0x00,0xf0,0x0e,0x00,0x00,0x00,0x00,0x00,0x0f,0xff,0xff,0xff,0x1f,0xff,0xff,0xff,0xff,0xb0,0x00,0x19,0x87,0xb8,0x00,0x00,0x00,
0x00,0x60,0x06,0x00,0x00,0x00,0x00,0x00,0x0f,0xff,0xff,0xf9,0x0f,0xff,0xff,0xff,0xff,0xb0,0x00,0x0d,0x80,0xf8,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0xff,0xff,0xfc,0x0f,0xff,0xff,0xff,0xff,0xf0,0x00,0x07,0x00,0x18,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0xff,0xff,0xff,0x07,0x6f,0xff,0xff,0xff,0xe0,0x00,0x03,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xff,0xff,0xff,0xa3,0x93,0xff,0xff,0xff,0xee,0x00,0x01,0x80,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7f,0xff,0xff,0xc8,0xc9,0xbf,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0xff,0xff,0xf8,0x76,0x4f,0xff,0xff,0xff,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0xff,0xff,0xec,0x1d,0xb3,0xff,0xff,0xff,0xf0,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x7f,0xff,0xec,0x07,0x2c,0xff,0xff,0xff,0xfc,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x7f,0xff,0xf8,0x00,0xc2,0xff,0xff,0xff,0xff,0x80,0xff,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xbf,0xff,0xf0,0x00,0x1c,0x7f,0xff,0xff,0xff,0xff,0xff,0x80,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5f,0xff,0xf8,0x00,0x01,0xff,0xff,0xff,0xff,0xff,0xff,0x80,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x5f,0xfd,0xfe,0x00,0x00,0x3f,0xff,0xff,0xff,0xff,0xff,0xc0,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xcb,0xfe,0x7f,0xe0,0x00,0x03,0xff,0xff,0xff,0xe0,0x1f,0xc0,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xd7,0xff,0xef,0xf0,0x00,0x07,0xff,0xff,0xff,0xff,0xc7,0x70,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x9f,0xff,0xef,0xf0,0x00,0x00,0x7c,0xdb,0x7f,0xff,0xe7,0xf8,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0xff,0xff,0x9f,0xe0,0x00,0x00,0x03,0x8f,0xff,0xff,0xef,0xce,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0xff,0xfe,0x3d,0xc0,0x00,0x00,0x00,0x0f,0xff,0xff,0xdf,0xc0,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7f,0xff,0xb9,0xfb,0x80,0x00,0x00,0x00,0x01,0xff,0xff,0xbe,0xe0,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xff,0xfe,0x3f,0xf6,0x00,0x00,0x00,0x00,0x00,0x3f,0xff,0x3e,0xe0,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x03,0xc6,0x00,0x07,0xfc,0xdc,0xfb,0xb6,0x00,0x00,0x00,0x00,0x00,0x3f,0xfe,0x3f,0x60,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x00,0x7f,0xfd,0x3d,0xfb,0x1c,0x00,0x00,0x00,0x00,0x00,0x1f,0xff,0x7f,0xb0,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x7d,0xff,0xff,0xf9,0xff,0xfb,0x06,0x00,0x00,0x00,0x00,0x00,0x1f,0xf8,0x7f,0xf0,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0xff,0xf6,0x07,0xff,0x3d,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0xfc,0xf7,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0xff,0xe0,0x7f,0xf2,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0xfd,0xf6,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x7f,0xff,0xff,0x9f,0xf9,0xe6,0x07,0x00,0x00,0x00,0x03,0xc0,0x00,0x7f,0xe7,0xf6,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x01,0x9f,0xf9,0xff,0xff,0xfb,0xec,0x06,0x00,0x00,0x00,0x73,0xa0,0x01,0xff,0xa7,0xf6,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x07,0xcf,0x8f,0xbb,0xf9,0xf7,0x2c,0x00,0x00,0x00,0x00,0xe3,0x98,0x07,0xfe,0x3f,0xff,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x0c,0x7f,0x27,0xa0,0xf6,0x10,0x00,0x00,0x00,0x00,0x07,0xff,0xfb,0xfc,0x3f,0x70,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x0f,0x6f,0xc0,0x7c,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xdf,0xfd,0xff,0x60,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x33,0xc4,0x20,0x30,0x00,0x00,0x00,0x00,0x00,0x03,0x9f,0xf9,0xff,0xff,0x40,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x01,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0xff,0xff,0xb9,0xb0,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0x73,0x67,0xa0,0xb0,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1e,0xcf,0x67,0xa0,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xce,0x9f,0xa0,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x03,0x00,0x00,0x00,0xe0,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
};
// -----------------------------------------------------------------------
#include <stdlib.h>
static void draw_lion(void)
{
int x, y, i;
int16_t chr;
uint16_t code;
uint16_t *braile_data;
braile_data = calloc(win->width * win->height, 2);
braille_8(win, braile_data, lion_data, LION_WIDTH);
// you can do further drawing into the braile data here maybe
draw_braille(win, braile_data);
free(braile_data);
}
// -----------------------------------------------------------------------
void lion(void)
{
node_t *n;
scr_close(active_screen);
json_create_ui("dots.json", menu_address_cb);
menu_init();
scr = active_screen;
n = scr->windows.head;
win = n->payload;
while(test_keys() != 0)
{
key();
}
draw_lion();
scr_draw_screen(scr);
do
{
;
} while((test_keys() == 0) && (key() != 0x1b));
scr_close(active_screen);
main_screen();
}
// ======================================================================= | c |
lib/fractoid/include/differential.h | tjira/fractoid | 0 | 1568152 | #pragma once
#include "algorithm.h"
class Fractoid::Algorithm::Complex::Differential : public Fractoid::Backend::Algorithm {
template<class C>
friend class Fractoid::Backend::Painter;
public:
explicit Differential(double angle = 45, double factor = 1.5);
private:
double angle, factor;
complex normal;
}; | c |
SYSTEM/CM_PID.h | four-wei-worm/- | 1 | 2340356 | #ifndef __CM_PID_H
#define __CM_PID_H
#include <main.h>
void CM_PID(void);
#endif | c |
ixd/bkp_data_computing/poly_circle.h | IXDdev/IXD_engine | 0 | 464323 | #include <glut.h>
#include <math.h>
const int n = 40;
const GLfloat R = 0.5f;
const GLfloat Pi = 3.1415926536f;
void myDisplay(void)
{
int i;
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_POLYGON);
for(i=0; i<n; ++i)
glVertex2f(R*cos(i*2*Pi/n), R*sin(i*2*Pi/n));
glEnd();
glFlush();
}
int main(int argc, char ** argv)
{
glutInit(&argc, argv);
glutCreateWindow("Xcode Glut Demo");
glutDisplayFunc(myDisplay);
glutMainLoop();
} | c |
common/source/common/net/message/nodes/GenericDebugMsg.h | TomatoYoung/beegfs | 0 | 1787417 | #ifndef GENERICDEBUGMSG_H_
#define GENERICDEBUGMSG_H_
#include <common/net/message/SimpleStringMsg.h>
#include <common/Common.h>
/**
* This message is generic in the way that it simply takes a space-separated command string as input
* and the response is also just a string (which will just be printed to the console by fhgfs-ctl).
* That makes this msg very useful to quickly add new fuctionality for testing or query information
* for debugging purposes without the overhead of adding a completely new message.
*/
class GenericDebugMsg : public SimpleStringMsg
{
public:
GenericDebugMsg(const char* commandStr) : SimpleStringMsg(NETMSGTYPE_GenericDebug, commandStr)
{
}
GenericDebugMsg() : SimpleStringMsg(NETMSGTYPE_GenericDebug)
{
}
private:
public:
// getters & setters
const char* getCommandStr()
{
return getValue();
}
};
#endif /* GENERICDEBUGMSG_H_ */ | c |
drivers/thermal/intel/int340x_thermal/int340x_thermal_zone.c | fergy/aplit_linux-5 | 3 | 2775950 | /*
* int340x_thermal_zone.c
* Copyright (c) 2015, Intel Corporation.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*/
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/acpi.h>
#include <linux/thermal.h>
#include "int340x_thermal_zone.h"
static int int340x_thermal_get_zone_temp(struct thermal_zone_device *zone,
int *temp)
{
struct int34x_thermal_zone *d = zone->devdata;
unsigned long long tmp;
acpi_status status;
if (d->override_ops && d->override_ops->get_temp)
return d->override_ops->get_temp(zone, temp);
status = acpi_evaluate_integer(d->adev->handle, "_TMP", NULL, &tmp);
if (ACPI_FAILURE(status))
return -EIO;
if (d->lpat_table) {
int conv_temp;
conv_temp = acpi_lpat_raw_to_temp(d->lpat_table, (int)tmp);
if (conv_temp < 0)
return conv_temp;
*temp = (unsigned long)conv_temp * 10;
} else
/* _TMP returns the temperature in tenths of degrees Kelvin */
*temp = DECI_KELVIN_TO_MILLICELSIUS(tmp);
return 0;
}
static int int340x_thermal_get_trip_temp(struct thermal_zone_device *zone,
int trip, int *temp)
{
struct int34x_thermal_zone *d = zone->devdata;
int i;
if (d->override_ops && d->override_ops->get_trip_temp)
return d->override_ops->get_trip_temp(zone, trip, temp);
if (trip < d->aux_trip_nr)
*temp = d->aux_trips[trip];
else if (trip == d->crt_trip_id)
*temp = d->crt_temp;
else if (trip == d->psv_trip_id)
*temp = d->psv_temp;
else if (trip == d->hot_trip_id)
*temp = d->hot_temp;
else {
for (i = 0; i < INT340X_THERMAL_MAX_ACT_TRIP_COUNT; i++) {
if (d->act_trips[i].valid &&
d->act_trips[i].id == trip) {
*temp = d->act_trips[i].temp;
break;
}
}
if (i == INT340X_THERMAL_MAX_ACT_TRIP_COUNT)
return -EINVAL;
}
return 0;
}
static int int340x_thermal_get_trip_type(struct thermal_zone_device *zone,
int trip,
enum thermal_trip_type *type)
{
struct int34x_thermal_zone *d = zone->devdata;
int i;
if (d->override_ops && d->override_ops->get_trip_type)
return d->override_ops->get_trip_type(zone, trip, type);
if (trip < d->aux_trip_nr)
*type = THERMAL_TRIP_PASSIVE;
else if (trip == d->crt_trip_id)
*type = THERMAL_TRIP_CRITICAL;
else if (trip == d->hot_trip_id)
*type = THERMAL_TRIP_HOT;
else if (trip == d->psv_trip_id)
*type = THERMAL_TRIP_PASSIVE;
else {
for (i = 0; i < INT340X_THERMAL_MAX_ACT_TRIP_COUNT; i++) {
if (d->act_trips[i].valid &&
d->act_trips[i].id == trip) {
*type = THERMAL_TRIP_ACTIVE;
break;
}
}
if (i == INT340X_THERMAL_MAX_ACT_TRIP_COUNT)
return -EINVAL;
}
return 0;
}
static int int340x_thermal_set_trip_temp(struct thermal_zone_device *zone,
int trip, int temp)
{
struct int34x_thermal_zone *d = zone->devdata;
acpi_status status;
char name[10];
if (d->override_ops && d->override_ops->set_trip_temp)
return d->override_ops->set_trip_temp(zone, trip, temp);
snprintf(name, sizeof(name), "PAT%d", trip);
status = acpi_execute_simple_method(d->adev->handle, name,
MILLICELSIUS_TO_DECI_KELVIN(temp));
if (ACPI_FAILURE(status))
return -EIO;
d->aux_trips[trip] = temp;
return 0;
}
static int int340x_thermal_get_trip_hyst(struct thermal_zone_device *zone,
int trip, int *temp)
{
struct int34x_thermal_zone *d = zone->devdata;
acpi_status status;
unsigned long long hyst;
if (d->override_ops && d->override_ops->get_trip_hyst)
return d->override_ops->get_trip_hyst(zone, trip, temp);
status = acpi_evaluate_integer(d->adev->handle, "GTSH", NULL, &hyst);
if (ACPI_FAILURE(status))
*temp = 0;
else
*temp = hyst * 100;
return 0;
}
static struct thermal_zone_device_ops int340x_thermal_zone_ops = {
.get_temp = int340x_thermal_get_zone_temp,
.get_trip_temp = int340x_thermal_get_trip_temp,
.get_trip_type = int340x_thermal_get_trip_type,
.set_trip_temp = int340x_thermal_set_trip_temp,
.get_trip_hyst = int340x_thermal_get_trip_hyst,
};
static int int340x_thermal_get_trip_config(acpi_handle handle, char *name,
int *temp)
{
unsigned long long r;
acpi_status status;
status = acpi_evaluate_integer(handle, name, NULL, &r);
if (ACPI_FAILURE(status))
return -EIO;
*temp = DECI_KELVIN_TO_MILLICELSIUS(r);
return 0;
}
int int340x_thermal_read_trips(struct int34x_thermal_zone *int34x_zone)
{
int trip_cnt = int34x_zone->aux_trip_nr;
int i;
int34x_zone->crt_trip_id = -1;
if (!int340x_thermal_get_trip_config(int34x_zone->adev->handle, "_CRT",
&int34x_zone->crt_temp))
int34x_zone->crt_trip_id = trip_cnt++;
int34x_zone->hot_trip_id = -1;
if (!int340x_thermal_get_trip_config(int34x_zone->adev->handle, "_HOT",
&int34x_zone->hot_temp))
int34x_zone->hot_trip_id = trip_cnt++;
int34x_zone->psv_trip_id = -1;
if (!int340x_thermal_get_trip_config(int34x_zone->adev->handle, "_PSV",
&int34x_zone->psv_temp))
int34x_zone->psv_trip_id = trip_cnt++;
for (i = 0; i < INT340X_THERMAL_MAX_ACT_TRIP_COUNT; i++) {
char name[5] = { '_', 'A', 'C', '0' + i, '\0' };
if (int340x_thermal_get_trip_config(int34x_zone->adev->handle,
name,
&int34x_zone->act_trips[i].temp))
break;
int34x_zone->act_trips[i].id = trip_cnt++;
int34x_zone->act_trips[i].valid = true;
}
return trip_cnt;
}
EXPORT_SYMBOL_GPL(int340x_thermal_read_trips);
static struct thermal_zone_params int340x_thermal_params = {
.governor_name = "user_space",
.no_hwmon = true,
};
struct int34x_thermal_zone *int340x_thermal_zone_add(struct acpi_device *adev,
struct thermal_zone_device_ops *override_ops)
{
struct int34x_thermal_zone *int34x_thermal_zone;
acpi_status status;
unsigned long long trip_cnt;
int trip_mask = 0;
int ret;
int34x_thermal_zone = kzalloc(sizeof(*int34x_thermal_zone),
GFP_KERNEL);
if (!int34x_thermal_zone)
return ERR_PTR(-ENOMEM);
int34x_thermal_zone->adev = adev;
int34x_thermal_zone->override_ops = override_ops;
status = acpi_evaluate_integer(adev->handle, "PATC", NULL, &trip_cnt);
if (ACPI_FAILURE(status))
trip_cnt = 0;
else {
int34x_thermal_zone->aux_trips =
kcalloc(trip_cnt,
sizeof(*int34x_thermal_zone->aux_trips),
GFP_KERNEL);
if (!int34x_thermal_zone->aux_trips) {
ret = -ENOMEM;
goto err_trip_alloc;
}
trip_mask = BIT(trip_cnt) - 1;
int34x_thermal_zone->aux_trip_nr = trip_cnt;
}
trip_cnt = int340x_thermal_read_trips(int34x_thermal_zone);
int34x_thermal_zone->lpat_table = acpi_lpat_get_conversion_table(
adev->handle);
int34x_thermal_zone->zone = thermal_zone_device_register(
acpi_device_bid(adev),
trip_cnt,
trip_mask, int34x_thermal_zone,
&int340x_thermal_zone_ops,
&int340x_thermal_params,
0, 0);
if (IS_ERR(int34x_thermal_zone->zone)) {
ret = PTR_ERR(int34x_thermal_zone->zone);
goto err_thermal_zone;
}
return int34x_thermal_zone;
err_thermal_zone:
acpi_lpat_free_conversion_table(int34x_thermal_zone->lpat_table);
kfree(int34x_thermal_zone->aux_trips);
err_trip_alloc:
kfree(int34x_thermal_zone);
return ERR_PTR(ret);
}
EXPORT_SYMBOL_GPL(int340x_thermal_zone_add);
void int340x_thermal_zone_remove(struct int34x_thermal_zone
*int34x_thermal_zone)
{
thermal_zone_device_unregister(int34x_thermal_zone->zone);
acpi_lpat_free_conversion_table(int34x_thermal_zone->lpat_table);
kfree(int34x_thermal_zone->aux_trips);
kfree(int34x_thermal_zone);
}
EXPORT_SYMBOL_GPL(int340x_thermal_zone_remove);
MODULE_AUTHOR("<NAME> <<EMAIL>>");
MODULE_AUTHOR("<NAME> <<EMAIL>>");
MODULE_DESCRIPTION("Intel INT340x common thermal zone handler");
MODULE_LICENSE("GPL v2"); | c |
MingLiMoShi/MingLiMoShi/CommandLightOn.h | dengchaojie/sheJiMoShi | 1 | 4266829 | //
// CommandLightOn.h
// MingLiMoShi
//
// Created by hrt03 on 2019/8/26.
// Copyright © 2019 dengchaojie. All rights reserved.
//
#import "Command.h"
NS_ASSUME_NONNULL_BEGIN
@interface CommandLightOn : Command
@end
NS_ASSUME_NONNULL_END | c |
System/Library/PrivateFrameworks/MPUFoundation.framework/MPUDataSourceConfiguration.h | lechium/tvOS124Headers | 4 | 3122448 | /*
* This header is generated by classdump-dyld 1.0
* on Saturday, August 24, 2019 at 9:46:56 PM Mountain Standard Time
* Operating System: Version 12.4 (Build 16M568)
* Image Source: /System/Library/PrivateFrameworks/MPUFoundation.framework/MPUFoundation
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by <NAME>.
*/
@class NSString;
@interface MPUDataSourceConfiguration : NSObject {
Class _dataSourceClass;
NSString* _dataSourceCachingKey;
/*^block*/id _defaultQueryCreationBlock;
long long _entityType;
}
@property (nonatomic,readonly) Class dataSourceClass; //@synthesize dataSourceClass=_dataSourceClass - In the implementation block
@property (nonatomic,copy) NSString * dataSourceCachingKey; //@synthesize dataSourceCachingKey=_dataSourceCachingKey - In the implementation block
@property (nonatomic,copy) id defaultQueryCreationBlock; //@synthesize defaultQueryCreationBlock=_defaultQueryCreationBlock - In the implementation block
@property (assign,nonatomic) long long entityType; //@synthesize entityType=_entityType - In the implementation block
+(id)configurationWithDataSourceClass:(Class)arg1 ;
-(Class)dataSourceClass;
-(id)initWithDataSourceClass:(Class)arg1 ;
-(NSString *)dataSourceCachingKey;
-(void)setDataSourceCachingKey:(NSString *)arg1 ;
-(id)defaultQueryCreationBlock;
-(void)setDefaultQueryCreationBlock:(id)arg1 ;
-(void)setEntityType:(long long)arg1 ;
-(long long)entityType;
@end | c |
gnuradio-3.7.13.4/gr-blocks/include/gnuradio/blocks/nlog10_ff.h | v1259397/cosmic-gnuradio | 1 | 4303501 | /* -*- c++ -*- */
/*
* Copyright 2012 Free Software Foundation, Inc.
*
* This file is part of GNU Radio
*
* GNU Radio is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3, or (at your option)
* any later version.
*
* GNU Radio is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GNU Radio; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street,
* Boston, MA 02110-1301, USA.
*/
#ifndef INCLUDED_BLOCKS_NLOG10_FF_H
#define INCLUDED_BLOCKS_NLOG10_FF_H
#include <gnuradio/blocks/api.h>
#include <gnuradio/sync_block.h>
namespace gr {
namespace blocks {
/*!
* \brief output = n*log10(input) + k
* \ingroup math_operators_blk
*/
class BLOCKS_API nlog10_ff : virtual public sync_block
{
public:
// gr::blocks::nlog10_ff::sptr
typedef boost::shared_ptr<nlog10_ff> sptr;
/*!
* \brief Make an instance of an nlog10_ff block.
* \param n Scalar multiplicative constant
* \param vlen Input vector length
* \param k Scalar additive constant
*/
static sptr make(float n=1.0, size_t vlen=1, float k=0.0);
};
} /* namespace blocks */
} /* namespace gr */
#endif /* INCLUDED_BLOCKS_NLOG10_FF_H */ | c |
lib/include/internal/command_line_parser.h | jandom/hawktracer | 116 | 8332064 | #ifndef HAWKTRACER_INTERNAL_COMMAND_LINE_PARSER_H
#define HAWKTRACER_INTERNAL_COMMAND_LINE_PARSER_H
#include <hawktracer/macros.h>
#include <hawktracer/base_types.h>
HT_DECLS_BEGIN
void ht_command_line_parse_args(int argc, char** argv);
HT_DECLS_END
#endif /* HAWKTRACER_INTERNAL_COMMAND_LINE_PARSER_H */ | c |
External/geohash.c | alfwatt/FourCorners | 1 | 4731456 | /* This is a public domain geohash implementation written by <NAME>. */
#include <math.h>
#include <float.h>
#include <string.h>
#include "geohash.h"
/* BASE 32 encode table */
static char base32en[] = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'b', 'c', 'd', 'e', 'f', 'g',
'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
};
#define BASE32DE_FIRST '0'
#define BASE32DE_LAST 'z'
/* ASCII order for BASE 32 decode,from '0' to 'z', -1 in unused character */
static signed char base32de[] = {
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
10, 11, 12, 13, 14, 15, 16, -1, 17, 18,
-1, 19, 20, -1, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31
};
#define PRECISION .00000000001 /* XXX not validated */
static int
max(int x, int y)
{
if (x < y)
return y;
return x;
}
static double
pround(double x, int precision)
{
double div = pow(10, precision);
return round(x * div) / div;
}
/* Quick and Dirty Floating-Point to Fractional Precision */
static double
fprec(double x)
{
int i;
double int_part, frac_part;
frac_part = modf(x, &int_part);
/* check fractional is really close 0.0 or 1.0 */
for (i = 0; fabs(frac_part - 0.0) > FLT_EPSILON &&
fabs(frac_part - 1.0) > FLT_EPSILON; i++) {
frac_part *= 10;
frac_part = modf(frac_part, &int_part);
}
return pow(10, -i);
}
int
geohash_encode(double latitude, double longitude, char *hash, size_t len)
{
double lat[] = {-90.0, 90.0};
double lon[] = {-180.0, 180.0};
double mid;
double precision;
char mask[] = {16, 8, 4, 2, 1};
int i, n;
int idx;
int even = 0;
int right;
/* check input latitude/longitude is ok or invalid */
if (latitude < lat[0] || latitude > lat[1] ||
longitude < lon[0] || longitude > lon[1])
return GEOHASH_INVALID;
precision = fmin(fprec(latitude), fprec(longitude));
precision = fmax(PRECISION, precision);
/* save the last space for '\0' when len is not enough */
len -= 1;
for (i = 0; i < len; i++) {
/* break when precision is enough for input latitude/longitude */
if ((lat[1] - lat[0]) / 2.0 < precision &&
(lon[1] - lon[0]) / 2.0 < precision)
break;
for (n = idx = 0; n <= 4; n++) {
if ((even = !even)) {
mid = (lon[0] + lon[1]) / 2.0;
right = (longitude > mid);
if (right)
idx |= mask[n];
lon[!right] = mid;
} else {
mid = (lat[0] + lat[1]) / 2.0;
right = (latitude > mid);
if (right)
idx |= mask[n];
lat[!right] = mid;
}
}
hash[i] = base32en[idx];
}
hash[i] = 0;
return GEOHASH_OK;
}
int
geohash_decode(char *hash, double *latitude, double *longitude)
{
size_t len = strlen(hash);
double lat[] = {-90.0, 90.0};
double lon[] = {-180.0, 180.0};
double mid;
double lat_err, lon_err;
char mask[] = {16, 8, 4, 2, 1};
int i, n;
int idx = 0;
int even = 0;
int right;
for (i = 0; i < len; i++) {
if (hash[i] < BASE32DE_FIRST || hash[i] > BASE32DE_LAST ||
(idx = base32de[hash[i] - BASE32DE_FIRST]) == -1)
return GEOHASH_INVALID;
for (n = 0; n <= 4; n++) {
if ((even = !even)) {
mid = (lon[0] + lon[1]) / 2.0;
right = (idx & mask[n]);
lon[!right] = mid;
} else {
mid = (lat[0] + lat[1]) / 2.0;
right = (idx & mask[n]);
lat[!right] = mid;
}
}
}
lat_err = (lat[1] - lat[0]) / 2.0;
*latitude = pround((lat[0] + lat[1]) / 2.0,
max(1, (int)round(-log10(lat_err))) - 1);
lon_err = (lon[1] - lon[0]) / 2.0;
*longitude = pround((lon[0] + lon[1]) / 2.0,
max(1, (int)round(-log10(lon_err))) - 1);
return GEOHASH_OK;
} | c |
service/resource-container/include/RCSResourceContainer.h | jonghenhan/iotivity | 301 | 5049350 | //******************************************************************
//
// Copyright 2015 Samsung Electronics All Rights Reserved.
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
/**
* @file
*
* This file contains the resource container APIs provided to the developers.
*/
#ifndef RCSRESOURCECONTAINER_H_
#define RCSRESOURCECONTAINER_H_
#include <string>
#include <vector>
#include <map>
#include <list>
#include <memory>
#include "RCSBundleInfo.h"
namespace OIC
{
namespace Service
{
/**
* @class RCSResourceContainer
* @brief This class provides APIs for managing the container and bundles in the container.
*
*/
class RCSResourceContainer
{
public:
/**
* API for starting the Container
*
* @details This API start the container with the provided Configuration file.
*
* @param configFile configuration File that contains the Bundle/Bundles information.
*
*/
virtual void startContainer(const std::string &configFile) = 0;
/**
* API for stopping the Container
*/
virtual void stopContainer() = 0;
// list of bundle ids
/**
* API for getting the list of all bundles in the container.
* The returned list and the contained bundle information are a copy
* and will not be updated by the resource container.
*
* @return List of BundleInfo pointer each associated with a bundle
*
*/
virtual std::list<std::unique_ptr<RCSBundleInfo>> listBundles() = 0;
/**
* API for starting the bundle.
*
* @param bundleId Id of the Bundle
*
*/
virtual void startBundle(const std::string &bundleId) = 0;
/**
* API for Stopping the bundle
*
* @param bundleId Id of the Bundle
*
*/
virtual void stopBundle(const std::string &bundleId) = 0;
// dynamic configuration
/**
* API for adding the bundle to the Container
*
* @param bundleId Id of the Bundle
* @param bundleUri URI of the bundle
* @param bundlePath Path of the bundle
* @param activator Activation prefix for .so bundles, or activator class name for .jar bundles
* @param params key-value pairs in string form for other Bundle parameters
*
*/
virtual void addBundle(const std::string &bundleId, const std::string &bundleUri,
const std::string &bundlePath, const std::string &activator,
std::map<std::string, std::string> params) = 0;
/**
* API for removing the bundle from the container
*
* @param bundleId Id of the Bundle
*
*/
virtual void removeBundle(const std::string &bundleId) = 0;
/**
* API for adding the Resource configuration information to the bundle
*
* @param bundleId Id of the Bundle
* @param resourceUri URI of the resource
* @param params key-value pairs in string form for other Bundle parameters
*
*/
virtual void addResourceConfig(const std::string &bundleId, const std::string &resourceUri,
std::map<std::string, std::string> params) = 0;
/**
* API for removing the Resource configuration information from the bundle
*
* @param bundleId Id of the Bundle
* @param resourceUri URI of the resource
*
*/
virtual void removeResourceConfig(const std::string &bundleId, const std::string &resourceUri) = 0;
/**
* API for getting the list of Bundle Resources
*
* @param bundleId Id of the Bundle
*
*/
virtual std::list<std::string> listBundleResources(const std::string &bundleId) = 0;
/**
* API for getting the Instance of ResourceContainer class
*
* @return Instance of the "RCSResourceContainer" class
*
*/
static RCSResourceContainer *getInstance();
protected:
RCSResourceContainer();
virtual ~RCSResourceContainer();
RCSResourceContainer(const RCSResourceContainer &) = delete;
RCSResourceContainer(RCSResourceContainer &&) = delete;
RCSResourceContainer &operator=(const RCSResourceContainer &) const = delete;
RCSResourceContainer &operator=(RCSResourceContainer &&) const = delete;
};
}
}
#endif /* RCSRESOURCECONTAINER_H_ */ | c |
include/options/appl_options_handle.h | fboucher9/appl | 0 | 8157476 | /* See LICENSE for license details */
/*
Module: appl_options_handle.h
Description:
Command-line options.
*/
/* Reverse include guard */
enum guard_appl_options_handle_h
{
inc_appl_options_handle_h =
/* Header file dependencies */
inc_appl_status_h
};
#include <misc/appl_extern_c_begin.h>
enum appl_status
appl_options_create(
struct appl_context * const
p_context,
struct appl_options * * const
r_instance);
enum appl_status
appl_options_destroy(
struct appl_options * const
p_instance);
struct appl_object *
appl_options_parent(
struct appl_options * const
p_options);
struct appl_object const *
appl_options_const_parent(
struct appl_options const * const
p_options);
enum appl_status
appl_options_count(
struct appl_options const * const
p_options,
unsigned long int * const
r_count);
enum appl_status
appl_options_get(
struct appl_options const * const
p_options,
unsigned long int const
i_index,
unsigned char const * * const
r_buf_min,
unsigned char const * * const
r_buf_max);
enum appl_status
appl_options_write(
struct appl_options * const
p_options,
unsigned char const * const
p_buf_min,
unsigned char const * const
p_buf_max,
unsigned long int * const
p_count,
char * const
p_ready);
enum appl_status
appl_options_append_argument(
struct appl_options * const
p_options,
unsigned char const * const
p_buf_min,
unsigned char const * const
p_buf_max);
enum appl_status
appl_options_reset(
struct appl_options * const
p_options);
#include <misc/appl_extern_c_end.h>
/* end-of-file: appl_options_handle.h */ | c |
C/Tester.h | mskec/WaveletTree | 0 | 2594979 | // Basic unit test functions for Wavelet tree building and querying.
// Created by dsisejkovic on 10.01.16..
//
#ifndef C_TESTER_H
#define C_TESTER_H
#include "Basic.h"
#include "WaveletTree.h"
void testBitVector();
void testTreeBuilding();
void testRanking();
void testAccessing();
void testSelecting();
void testAll();
#endif //C_TESTER_H | c |
headers/glib-2.0/gio/gdbusobject.h | mwichmann/lsb-buildenv | 0 | 5489990 | #if (__LSB_VERSION__ >= 50 )
#ifndef _GLIB_2_0_GIO_GDBUSOBJECT_H_
#define _GLIB_2_0_GIO_GDBUSOBJECT_H_
#include <glib-2.0/glib.h>
#include <glib-2.0/glib-object.h>
#include <glib-2.0/gio/giotypes.h>
#ifdef __cplusplus
extern "C" {
#endif
#define G_TYPE_DBUS_OBJECT (g_dbus_object_get_type())
#define G_DBUS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), G_TYPE_DBUS_OBJECT, GDBusObject))
#define G_IS_DBUS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), G_TYPE_DBUS_OBJECT))
#define G_DBUS_OBJECT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE((o), G_TYPE_DBUS_OBJECT, GDBusObjectIface))
typedef struct _GDBusObjectIface GDBusObjectIface;
struct _GDBusObjectIface {
GTypeInterface parent_iface;
const gchar *(*get_object_path) (GDBusObject * object);
GList *(*get_interfaces) (GDBusObject * object);
GDBusInterface *(*get_interface) (GDBusObject * object,
const gchar * interface_name);
void (*interface_added) (GDBusObject * object,
GDBusInterface * interface_);
void (*interface_removed) (GDBusObject * object,
GDBusInterface * interface_);
};
/* Function prototypes */
extern GDBusInterface *g_dbus_object_get_interface(GDBusObject *
object,
const gchar *
interface_name);
extern GList *g_dbus_object_get_interfaces(GDBusObject * object);
extern const char *g_dbus_object_get_object_path(GDBusObject * object);
extern GType g_dbus_object_get_type(void);
#ifdef __cplusplus
}
#endif
#endif /* protection */
#endif /* LSB version */ | c |
Tests/GhsMulti/GhsMultiSrcGroups/sub/testOBJ.c | eWert-Online/esy-cmake | 107 | 2166494 | #include "testOBJ.h"
int funcOBJsub(void)
{
return func2a() + func3a() + func4a() + func5a() + func6a() + func7a();
} | c |
towr/include/towr/variables/euler_converter.h | eeoozz/towr | 592 | 707347 | /******************************************************************************
Copyright (c) 2018, <NAME>. All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
* Neither the name of the copyright holder nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
******************************************************************************/
#ifndef TOWR_VARIABLES_ANGULAR_STATE_CONVERTER_H_
#define TOWR_VARIABLES_ANGULAR_STATE_CONVERTER_H_
#include <array>
#include <Eigen/Dense>
#include <Eigen/Sparse>
#include "cartesian_dimensions.h"
#include "node_spline.h"
namespace towr {
/**
* @brief Converts Euler angles and derivatives to angular quantities.
*
* Euler angles, their first derivatives (Euler rates) and their second
* derivatives fully define the angular state of an rigid body in space. This
* class provides equivalent formulation of these values, specifically:
* @li Orientation as Rotation matrix or Quaternion.
* @li Angular velocity (x,y,z)
* @li Angular acceleration (x,y,z)
*
* Furthermore, the Euler angle spline is fully defined by a set of node values.
* This class also gives the derivative of the above quantities with respect
* to the values of these nodes.
*
* Formulas taken from kindr:
* http://docs.leggedrobotics.com/kindr/cheatsheet_latest.pdf
*
* See matlab script "matlab/euler_converter.m" for derivation.
*/
class EulerConverter {
public:
using Vector3d = Eigen::Vector3d;
using EulerAngles = Vector3d; ///< roll, pitch, yaw.
using EulerRates = Vector3d; ///< derivative of the above
using JacobianRow = Eigen::SparseVector<double, Eigen::RowMajor>;
using MatrixSXd = Eigen::SparseMatrix<double, Eigen::RowMajor>;
using Jacobian = MatrixSXd;
using JacRowMatrix = std::array<std::array<JacobianRow, k3D>, k3D>;
EulerConverter () = default;
/**
* @brief Constructs and links this object to the Euler angle values
* @param euler_angles_spline The Euler angle spline defined by node values.
*
* The order of application that is assumed here is (Z,Y',X'').
* So in order to get the orientation of an object in space from the Euler
* angles, we first rotate around yaw(z) axis, then around new pitch(y)
* axis and finally around new roll(x) axis.
*
* However, the 3-dimensional Euler angles must store the euler angles, rates, and
* rate derivatives in the order (roll, pitch, yaw):
* double roll = euler_angles->GetPoint(t).x();
* double pitch = euler_angles->GetPoint(t).y();
* double yaw = euler_angles->GetPoint(t).z();
*/
EulerConverter (const NodeSpline::Ptr& euler_angles);
virtual ~EulerConverter () = default;
/**
* @brief Converts the Euler angles at time t to a Quaternion.
* @param t The current time in the euler angles spline.
* @return A Quaternion the maps a vector from base to world frame.
*/
Eigen::Quaterniond GetQuaternionBaseToWorld (double t) const;
/**
* @brief Converts the Euler angles at time t to a rotation matrix.
* @param t The current time in the euler angles spline.
* @return A 3x3 rotation matrix that maps a vector from base to world frame.
*/
MatrixSXd GetRotationMatrixBaseToWorld(double t) const;
/** @see GetRotationMatrixBaseToWorld(t) */
static MatrixSXd GetRotationMatrixBaseToWorld(const EulerAngles& xyz);
/**
* @brief Converts Euler angles and Euler rates to angular velocities.
* @param t The current time in the euler angles spline.
* @return A 3-dim vector (x,y,z) of the angular velocities in world frame.
*/
Vector3d GetAngularVelocityInWorld(double t) const;
/**
* @brief Converts Euler angles, rates and rate derivatives o angular accelerations.
* @param t The current time in the euler angles spline.
* @return A 3-dim vector (x,y,z) of the angular accelerations in world frame.
*/
Vector3d GetAngularAccelerationInWorld(double t) const;
/**
* @brief Jacobian of the angular velocity with respect to the Euler nodes.
* @param t The current time in the Euler angles spline.
* @return The 3xn Jacobian Matrix of derivatives.
* 3: because angular velocity has an x,y,z component.
* n: the number of optimized nodes values defining the Euler spline.
*/
Jacobian GetDerivOfAngVelWrtEulerNodes(double t) const;
/**
* @brief Jacobian of the angular acceleration with respect to the Euler nodes.
* @param t The current time in the Euler angles spline.
* @return The 3xn Jacobian Matrix of derivatives.
* 3: because angular acceleration has an x,y,z component
* n: the number of optimized nodes values defining the Euler spline.
*/
Jacobian GetDerivOfAngAccWrtEulerNodes(double t) const;
/** @brief Returns the derivative of result of the linear equation M*v.
*
* M is the rotation matrix from base to world, defined by the Euler nodes.
* v is any vector independent of the Euler nodes. The sensitivity
* of the 3-dimensional vector w.r.t the Euler node values is given.
*
* @param t time at which the Euler angles are evaluated.
* @param v vector (e.g. relative position, velocity, acceleration).
* @param inverse if true, the derivative for M^(-1)*v is evaluated.
* @returns 3 x n dimensional matrix (n = number of Euler node values).
*/
Jacobian DerivOfRotVecMult(double t, const Vector3d& v, bool inverse) const;
/** @see GetQuaternionBaseToWorld(t) */
static Eigen::Quaterniond GetQuaternionBaseToWorld(const EulerAngles& pos);
private:
NodeSpline::Ptr euler_;
// Internal calculations for the conversion from euler rates to angular
// velocities and accelerations. These are done using the matrix M defined
// here: http://docs.leggedrobotics.com/kindr/cheatsheet_latest.pdf
/**
* @brief Matrix that maps euler rates to angular velocities in world.
*
* Make sure euler rates are ordered roll-pitch-yaw. They are however applied
* in the order yaw-pitch-role to determine the angular velocities.
*/
static MatrixSXd GetM(const EulerAngles& xyz);
/**
* @brief time derivative of GetM()
*/
static MatrixSXd GetMdot(const EulerAngles& xyz, const EulerRates& xyz_d);
/**
* @brief Derivative of the @a dim row of matrix M with respect to
* the node values.
*
* @param dim Which dimension of the angular acceleration is desired.
* @returns the Jacobian w.r.t the coefficients for each of the 3 rows
* of the matrix stacked on top of each other.
*/
Jacobian GetDerivMwrtNodes(double t, Dim3D dim) const;
/** @brief Derivative of the @a dim row of the time derivative of M with
* respect to the node values.
*
* @param dim Which dimension of the angular acceleration is desired.
*/
Jacobian GetDerivMdotwrtNodes(double t, Dim3D dim) const;
/** @brief matrix of derivatives of each cell w.r.t node values.
*
* This 2d-array has the same dimensions as the rotation matrix M_IB, but
* each cell if filled with a row vector.
*/
JacRowMatrix GetDerivativeOfRotationMatrixWrtNodes(double t) const;
/** @see GetAngularAccelerationInWorld(t) */
static Vector3d GetAngularAccelerationInWorld(State euler);
/** @see GetAngularVelocityInWorld(t) */
static Vector3d GetAngularVelocityInWorld(const EulerAngles& pos,
const EulerRates& vel);
JacobianRow GetJac(double t, Dx deriv, Dim3D dim) const;
Jacobian jac_wrt_nodes_structure_;
};
} /* namespace towr */
#endif /* TOWR_VARIABLES_ANGULAR_STATE_CONVERTER_H_ */ | c |
src/drivers/io.c | davidjxu21/pongOS | 0 | 1187970 | #include "io.h"
/*
* Read a byte from the specified port
*/
u_8t io_byte_read(u_16t port) {
u_8t result;
__asm__ volatile("in %%dx, %%al" : "=a"(result) : "d"(port));
return result;
}
/*
* Write a byte to the specified port
*/
void io_byte_write(u_16t port, u_8t data) {
__asm__ volatile("out %%al, %%dx" : : "a"(data), "d"(port));
}
/*
* Read a word from the specified port
*/
u_16t io_word_read(u_16t port) {
u_16t result;
__asm__ volatile("in %%dx, %%ax" : "=a"(result) : "d"(port));
return result;
}
/*
* Write a word to the specified port
*/
void io_word_write(u_16t port, u_8t data) {
__asm__ volatile("out %%ax, %%dx" : : "a"(data), "d"(port));
} | c |
core_blas-qwrapper/qwrapper_dsyr2k.c | zhuangsc/Plasma-ompss1 | 0 | 5243057 | /**
*
* @file qwrapper_dsyr2k.c
*
* PLASMA core_blas quark wrapper
* PLASMA is a software package provided by Univ. of Tennessee,
* Univ. of California Berkeley and Univ. of Colorado Denver
*
* @version 2.6.0
* @author <NAME>
* @author <NAME>
* @author <NAME>
* @date 2010-11-15
* @generated d Tue Jan 7 11:44:56 2014
*
**/
#include "common.h"
/***************************************************************************//**
*
**/
void QUARK_CORE_dsyr2k(Quark *quark, Quark_Task_Flags *task_flags,
PLASMA_enum uplo, PLASMA_enum trans,
int n, int k, int nb,
double alpha, const double *A, int lda,
const double *B, int ldb,
double beta, double *C, int ldc)
{
DAG_CORE_SYR2K;
QUARK_Insert_Task(quark, CORE_dsyr2k_quark, task_flags,
sizeof(PLASMA_enum), &uplo, VALUE,
sizeof(PLASMA_enum), &trans, VALUE,
sizeof(int), &n, VALUE,
sizeof(int), &k, VALUE,
sizeof(double), &alpha, VALUE,
sizeof(double)*nb*nb, A, INPUT,
sizeof(int), &lda, VALUE,
sizeof(double)*nb*nb, B, INPUT,
sizeof(int), &ldb, VALUE,
sizeof(double), &beta, VALUE,
sizeof(double)*nb*nb, C, INOUT,
sizeof(int), &ldc, VALUE,
0);
}
/***************************************************************************//**
*
**/
#if defined(PLASMA_HAVE_WEAK)
#pragma weak CORE_dsyr2k_quark = PCORE_dsyr2k_quark
#define CORE_dsyr2k_quark PCORE_dsyr2k_quark
#endif
void CORE_dsyr2k_quark(Quark *quark)
{
PLASMA_enum uplo;
PLASMA_enum trans;
int n;
int k;
double alpha;
double *A;
int lda;
double *B;
int ldb;
double beta;
double *C;
int ldc;
quark_unpack_args_12(quark, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
cblas_dsyr2k(CblasColMajor, (CBLAS_UPLO)uplo, (CBLAS_TRANSPOSE)trans,
n, k, (alpha), A, lda, B, ldb, (beta), C, ldc);
} | c |
src/tinyhtm/htm.h | Caltech-IPAC/libtinyhtm | 1 | 3024909 | // $Id: htm.h,v 20130613.99132738 2013/06/13 20:27:38 modell ipac $
/** \file
\brief Minimalistic functions and types for HTM indexing.
This software is based on work by <NAME>, <NAME>,
<NAME> at The Johns Hopkins University, and <NAME>,
Microsoft Research. See the following links for more information:
http://voservices.net/spherical/
http://adsabs.harvard.edu/abs/2010PASP..122.1375B
\authors <NAME>
\copyright IPAC/Caltech
*/
#ifndef HTM_HTM_H
#define HTM_HTM_H
#include <string.h>
#include <inttypes.h>
#include "geometry.h"
#ifdef __cplusplus
extern "C" {
#endif
#define IDSIZE 64
// cf. alternate in alt_htm_level()
#define IDHIGHBIT 0x8000000000000000LL
#define IDHIGHBIT2 0x4000000000000000LL
#define HTM_INVALID_ID -1
#ifdef USE_128
#define NB 128
#define ULG U128_TYPE
#define HTM_DEC_MAX_LEVEL 36
#define HTM_MAX_LEVEL 48
#define LIM_BIG_INT LIM_UINT128
#define SHIFT_BY 112
#else
#define NB 64
#define ULG U64_TYPE
#define HTM_DEC_MAX_LEVEL 18
#define HTM_MAX_LEVEL 24
#define LIM_BIG_INT LIM_UINT64
#define SHIFT_BY 56
#endif
#define SYS_SIZ_LIM 64
#define ULL ULG
#define LLI long long int
#define ULLI unsigned long long int
#define UINT64_MAX_VAL 18446744073709551615ULL
#define STRINGIFY(x) #x
#define TO_STRING(x) STRINGIFY (x)
#define HTM_OLD_LEV 7
#define HTM_NEW_LEV 20
#define EOSC 0
#define NS (NB / 2)
#define BC (NB / 4)
#define NC (NB + BC)
#define SB0 8
#define SB1 32
#define SB2 64
//#define A_UINT128_C(value) value##uLLL
#define A_UINT64_C(value) value##uLL
#define A_UINT_LG_C(value) (ULL)##value
// #define U128_TYPE uint128_t
// #define U64_TYPE uint64_t
#define U128_TYPE I128_TYPE
#define U64_TYPE I64_TYPE
#define I128_TYPE int128_t
#define I64_TYPE int64_t
#define LIM_UINT64 1000000000000000000ULL
// #define LIM_UINT128 1000000000000000000000000000000000000ULLL
// #define LIM_UINT128 ( 0x1000000000000000ULL << SYS_SIZ_LIM )
#define LIM_UINT128 ((uint128_t)(1.0e39))
#define P10_UINT64 10000000000000000000ULL
#define E10_UINT64 19 // # zeros
#ifndef FALSE
#define FALSE (0)
#define TRUE (!FALSE)
#endif
/** \defgroup htm HTM Indexing
@{
*/
/** Maximum HTM tree subdivision level */
#define HTM_MAX_LEVEL 24
/** Maximum level of a decimal index stored in a 64 bit signed integer. */
#define HTM_DEC_MAX_LEVEL 18
/** Root triangle numbers. The HTM ID of a root triangle is its number plus 8.
*/
enum htm_root
{
HTM_S0 = 0,
HTM_S1 = 1,
HTM_S2 = 2,
HTM_S3 = 3,
HTM_N0 = 4,
HTM_N1 = 5,
HTM_N2 = 6,
HTM_N3 = 7,
HTM_NROOTS = 8
};
/** A sorted list of 64 bit integer ranges.
*/
struct htm_ids
{
size_t n; /**< Number of ranges in list */
size_t cap; /**< Capacity of the range list */
struct htm_range range[]; /**< Ranges <tt>[min_i, max_i]</tt>, with
<tt>min_i <= max_i</tt> and
<tt>min_j > max_i</tt> for all
<tt>j > i</tt>. */
};
/** A position and a payload.
*/
struct htm_v3p
{
struct htm_v3 v; /**< Position. */
void *payload; /**< Pointer to payload. */
} HTM_ALIGNED (16);
/** A structure describing the geometry of an HTM triangle (aka a trixel).
*/
struct htm_tri
{
struct htm_v3 verts[3]; /**< Triangle vertices. */
struct htm_v3 center; /**< Triangle center. */
double radius; /**< Bounding circle radius (degrees). */
int64_t id; /**< HTM id. */
int level; /**< HTM level. */
};
/* Computes the normalized average of two input vertices.
*/
HTM_INLINE void _htm_vertex (struct htm_v3 *out, const struct htm_v3 *v1,
const struct htm_v3 *v2)
{
htm_v3_add (out, v1, v2);
htm_v3_normalize (out, out);
}
/** Computes an HTM ID for a position.
\return The HTM ID for \p point, or 0 if \p point is \c NULL or
\p level is not in the range <tt>[0, HTM_MAX_LEVEL]</tt>.
*/
int64_t htm_v3_id (const struct htm_v3 *point, int level);
/** Computes HTM IDs for a list of positions with payloads. Positions
and payloads are sorted by HTM ID during the id generation process.
\return
- HTM_ENULLPTR if \p points or \p ids is NULL.
- HTM_ELEN if \p n is 0.
- HTM_ELEVEL if level is not in <tt>[0, HTM_MAX_LEVEL]</tt>.
- HTM_OK on success.
*/
enum htm_errcode htm_v3p_idsort (struct htm_v3p *points, int64_t *ids,
size_t n, int level);
/** Returns the HTM subdivision level of the given ID,
or -1 if the ID is invalid.
*/
int htm_level (int64_t id);
/** Returns the HTM subdivision level of the given ID,
or -1 if the ID is invalid.
*/
int alt_htm_level (int64_t htmid);
/** Returns the HTM subdivision level of the given ID,
trying first Binary then Decimal encoding,
or -1 if the ID is invalid.
*/
int full_alt_htm_level (int64_t htmid);
/** Computes and stores the attributes of the HTM triangle with the given id.
\return
- HTM_ENULLPTR if \p tri is NULL.
- HTM_EID if \p id is invalid.
- HTM_OK on success.
*/
enum htm_errcode htm_tri_init (struct htm_tri *tri, int64_t id);
/** Computes and stores the attributes of the HTM triangle with the given id.
Uses alternate level detection, including encoding correction.
\return
- HTM_ENULLPTR if \p tri is NULL.
- HTM_EID if \p id is invalid.
- HTM_OK on success.
*/
enum htm_errcode alt_htm_tri_init (struct htm_tri *tri, int64_t id);
/** Returns a list of HTM ID ranges corresponding to the HTM triangles
overlapping the given circle.
A range list can be de-allocated by passing its pointer
to free().
\param[in] ids Existing range list or NULL. If \p ids is NULL,
a fresh range list is allocated and returned.
If it is non-NULL, its entries are removed but
its memory is reused. This can be used to avoid
\c malloc/realloc costs when this function is
being called inside of a loop.
\param[in] center Spherical circle center.
\param[in] radius Spherical circle radius (degrees).
\param[in] level Subdivision level, in range
<tt>[0, HTM_MAX_LEVEL]</tt>.
\param[in] maxranges Maximum number of ranges to return. When too many
ranges are generated, the effective subdivision
level of HTM ids is reduced. Since two consecutive
ranges that cannot be merged at level L may become
mergable at level L-n, this "coarsening" cuts down
on the number of ranges, but makes the range list
a poorer approximation to the input geometry. Note
that for arbitrary input geometry, up to 4 ranges
may be generated no matter what the subdivision
level is. So for maxranges < 4, the requested
bound may not be achieved.
\param[out] err If an error occurs, \p *err is set to indicate
the reason for the failure.
\return A list of HTM ID ranges for the HTM triangles overlapping the
given circle. A NULL pointer is returned in case of error, and
\p *err is set to indicate the reason for the failure.
Note that the input range list may be reallocated (to grow its
capacity), and so the input range list pointer may no longer
point to valid memory. Always replace the input pointer with
the return value of this function!
If a failure occurs, this function will free the memory
associated with the range list (even it came from a
non-NULL input pointer).
*/
struct htm_ids *htm_s2circle_ids (struct htm_ids *ids,
const struct htm_v3 *center, double radius,
int level, size_t maxranges,
enum htm_errcode *err);
/** Returns a list of HTM ID ranges corresponding to the HTM triangles
overlapping the given ellipse.
A range list can be de-allocated by passing its pointer
to free().
\param[in] ids Existing range list or NULL. If \p ids is NULL,
a fresh range list is allocated and returned.
If it is non-NULL, its entries are removed but
its memory is reused. This can be used to avoid
\c malloc/realloc costs when this function is
being called inside of a loop.
\param[in] ellipse Spherical ellipse.
\param[in] level Subdivision level, in range
<tt>[0, HTM_MAX_LEVEL]</tt>.
\param[in] maxranges Maximum number of ranges to return. When too many
ranges are generated, the effective subdivision
level of HTM ids is reduced. Since two consecutive
ranges that cannot be merged at level L may become
mergable at level L-n, this "coarsening" cuts down
on the number of ranges, but makes the range list
a poorer approximation to the input geometry. Note
that for arbitrary input geometry, up to 4 ranges
may be generated no matter what the subdivision
level is. So for maxranges < 4, the requested
bound may not be achieved.
\param[out] err If an error occurs, \p *err is set to indicate
the reason for the failure.
\return A list of HTM ID ranges for the HTM triangles overlapping the
given ellipse. A NULL pointer is returned in case of error,
and \p *err is set to indicate the reason for the failure.
Note that the input range list may be reallocated (to grow its
capacity), and so the input range list pointer may no longer
point to valid memory. Always replace the input pointer with
the return value of this function!
If a failure occurs, this function will free the memory
associated with the range list (even it came from a
non-NULL input pointer).
*/
struct htm_ids *htm_s2ellipse_ids (struct htm_ids *ids,
const struct htm_s2ellipse *ellipse,
int level, size_t maxranges,
enum htm_errcode *err);
/* HTM encoding */
// probably decimal
int prob_decimal (ULL in);
// definitely biinary
int def_binary (ULL in);
/** Returns a list of HTM ID ranges corresponding to the HTM triangles
overlapping the given spherical convex polygon.
A range list can be de-allocated by passing its pointer
to free().
\param[in] ids Existing range list or NULL. If \p ids is NULL,
a fresh range list is allocated and returned.
If it is non-NULL, its entries are removed but
its memory is reused. This can be used to avoid
\c malloc/realloc costs when this function is
being called inside of a loop.
\param[in] poly Spherical convex polygon.
\param[in] level Subdivision level, in range
<tt>[0, HTM_MAX_LEVEL]</tt>.
\param[in] maxranges Maximum number of ranges to return. When too many
ranges are generated, the effective subdivision
level of HTM ids is reduced. Since two consecutive
ranges that cannot be merged at level L may become
mergable at level L-n, this "coarsening" cuts down
on the number of ranges, but makes the range list
a poorer approximation to the input geometry. Note
that for arbitrary input geometry, up to 4 ranges
may be generated no matter what the subdivision
level is. So for maxranges < 4, the requested
bound may not be achieved.
\param[out] err If an error occurs, \p *err is set to indicate
the reason for the failure.
\return A list of HTM ID ranges for the HTM triangles overlapping the
given polygon. A NULL pointer is returned in case of error,
and \p *err is set to indicate the reason for the failure.
Note that the input range list may be reallocated (to grow its
capacity), and so the input range list pointer may no longer
point to valid memory. Always replace the input pointer with
the return value of this function!
If a failure occurs, this function will free the memory
associated with the range list (even it came from a
non-NULL input pointer).
*/
struct htm_ids *htm_s2cpoly_ids (struct htm_ids *ids,
const struct htm_s2cpoly *poly, int level,
size_t maxranges, enum htm_errcode *err);
/** Converts an HTM ID as returned by the various indexing functions to
decimal form. Returns 0 if the input ID is invalid.
This function maps IDs produced by this library to IDs that are compatible
with those currently stored in IRSA database tables.
*/
int64_t htm_idtodec (int64_t id);
int64_t alt_htm_idtodec (int64_t id);
/** Converts an HTM ID, taken to be in decimal representation,
to binary form. Returns 0 if the input ID is invalid.
This function maps IDs currently stored in IRSA database tables
(Decimal encoded) to a Binary representation.
*/
int64_t htm_idfrdec (int64_t id);
int64_t alt_htm_idfrdec (int64_t id);
int dec_dig (int64_t num, int pow);
int n_dec_digs (int64_t num);
char *bin_txt (int64_t rx);
char *str_big_num (int64_t big_num);
void sho_bin (int64_t number);
/** @}
*/
#ifdef __cplusplus
}
#endif
#endif /* HTM_HTM_H */
// vi: set tabstop=4 shiftwidth=4 expandtab : | c |
gf2p127-inl.h | srijs/hwsl2-core | 5 | 2594628 | #pragma once
#include <stdio.h>
#include <stdint.h>
#include <immintrin.h>
#include <smmintrin.h>
#include <wmmintrin.h>
typedef __m128i gf2p127_t;
#ifdef __AVX2__
typedef __m256i gf2p127x2_t;
#endif
static const inline
_Bool gf2p127_valid(const gf2p127_t a) {
return (_mm_extract_epi64(a, 1) & (UINT64_C(1) << 63)) == 0;
}
static const inline
_Bool gf2p127_eq(const gf2p127_t a, const gf2p127_t b) {
_Bool lo = _mm_extract_epi64(a, 0) == _mm_extract_epi64(b, 0);
_Bool hi = _mm_extract_epi64(a, 1) == _mm_extract_epi64(b, 1);
return lo && hi;
}
static const inline
gf2p127_t gf2p127_zero() {
return _mm_setzero_si128();
}
static const inline
gf2p127_t gf2p127_from_int(int a) {
return _mm_cvtsi32_si128(a);
}
static const inline
gf2p127_t gf2p127_mul_bit(const gf2p127_t a, const _Bool bit) {
return _mm_slli_epi64(a, !bit * 64);
}
static const inline
gf2p127_t gf2p127_add(const gf2p127_t a, const gf2p127_t b) {
return _mm_xor_si128(a, b);
}
static const inline
gf2p127_t gf2p127_mul_00(const gf2p127_t a) {
return _mm_setzero_si128();
}
static const inline
gf2p127_t gf2p127_mul_01(const gf2p127_t a) {
return a;
}
static const gf2p127_t *minmax __attribute__((__aligned__(16))) =
(gf2p127_t *)(uint64_t [4]){0, 0, UINT64_MAX, UINT64_MAX};
static const gf2p127_t *x127 __attribute__((__aligned__(16))) =
(gf2p127_t *)(uint32_t [4]){0, 0, 0, 1 << 31};
static const inline
gf2p127_t gf2p127_mul_10(const gf2p127_t a) {
// Shift lower and upper halves left by one bit,
// resembling a multiplication by two.
gf2p127_t sl = _mm_slli_epi64(a, 1);
// Check for a x^127 overflow, and add the polynom and carry bit.
gf2p127_t one = _mm_srli_epi64(_mm_alignr_epi8(a, sl, 8), 63);
gf2p127_t over = _mm_and_si128(sl, _mm_load_si128(x127));
gf2p127_t x127x63 = _mm_unpackhi_epi64(over, over);
return _mm_xor_si128(_mm_xor_si128(sl, one), x127x63);
}
#ifdef __AVX2__
static const inline
gf2p127x2_t gf2p127x2_mul_10(const gf2p127x2_t ab) {
// Shift lower and upper halves left by one bit,
// resembling a multiplication by two.
gf2p127x2_t sl = _mm256_slli_epi64(ab, 1);
// Check for the x^63 carry bit, and the x^127 overflow, and construct x^64 + 1 polynomial.
gf2p127x2_t carry = _mm256_srli_epi64(_mm256_alignr_epi8(ab, sl, 8), 63);
gf2p127x2_t carried = _mm256_xor_si256(sl, carry);
// Check for the x^127 overflow, and construct the x^127 + x^63 polymomial.
gf2p127x2_t over1 = _mm256_srli_epi64(sl, 63);
gf2p127x2_t over2 = _mm256_slli_epi64(over1, 63);
gf2p127x2_t overhi = _mm256_unpackhi_epi64(over2, over2);
return _mm256_xor_si256(overhi, carried);
}
#endif
static const inline
gf2p127_t gf2p127_mul_11(const gf2p127_t a) {
gf2p127_t mul01 = gf2p127_mul_01(a);
gf2p127_t mul10 = gf2p127_mul_10(a);
return _mm_xor_si128(mul01, mul10);
};
static const inline
gf2p127_t gf2p127_mul(const gf2p127_t a, const gf2p127_t b) {
gf2p127_t tmp, lo, hi;
// Multiplication (Karatsuba):
// tmp <- (a0 + a1) * (b0 + b1)
tmp = _mm_xor_si128(_mm_unpacklo_epi64(a, b), _mm_unpackhi_epi64(a, b));
tmp = _mm_clmulepi64_si128(tmp, tmp, 0x10);
// lo <- a0 * b0
lo = _mm_clmulepi64_si128(a, b, 0x00);
// hi <- a1 * b1
hi = _mm_clmulepi64_si128(a, b, 0x11);
// tmp <- (a0 + a1) * (b0 + b1) + a0 * b0 + a1 * b1
tmp = _mm_xor_si128(tmp, _mm_xor_si128(lo, hi));
// lo <- a0 * b0 + low64[(a0 + a1) * (b0 + b1) + a0 * b0 + a1 * b1] * x^64
lo = _mm_xor_si128(lo, _mm_slli_si128(tmp, 8));
// hi <- a1 * b1 + high64[(a0 + a1) * (b0 + b1) + a0 * b0 + a1 * b1]
hi = _mm_xor_si128(hi, _mm_srli_si128(tmp, 8));
// Reduction (modulo f(x) = x^127 + x^63 + 1)
// tmp <- low64[hi] * x^64 + high64[lo]
tmp = _mm_alignr_epi8(hi, lo, 8);
tmp = _mm_xor_si128(tmp, hi);
hi = _mm_slli_epi64(hi, 1);
lo = _mm_xor_si128(lo, hi);
hi = _mm_unpackhi_epi64(hi, tmp);
lo = _mm_xor_si128(lo, hi);
tmp = _mm_srli_epi64(tmp, 63);
lo = _mm_xor_si128(lo, tmp);
hi = _mm_unpacklo_epi64(tmp, tmp);
lo = _mm_xor_si128(lo, _mm_slli_epi64(hi, 63));
return lo;
}
static inline
char *gf2p127_hex(char *str, const gf2p127_t m) {
sprintf(str, "%.16llx%.16llx", _mm_extract_epi64(m, 1),
_mm_extract_epi64(m, 0));
return str;
} | c |
iree/vm/shims_emitc.h | axmat/iree | 0 | 5699930 | // Copyright 2021 The IREE Authors
//
// Licensed under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#ifndef IREE_VM_SHIMS_EMITC_H_
#define IREE_VM_SHIMS_EMITC_H_
#include "iree/base/attributes.h"
#include "iree/vm/module.h"
#include "iree/vm/shims.h"
#include "iree/vm/stack.h"
// see calling convention in module.h
#define CONCAT(a, b) CONCAT_IMPL(a, b)
#define CONCAT_IMPL(a, b) a##b
#define TUPLE_UNPACK(...) TUPLE_UNPACK_IMPL __VA_ARGS__
#define TUPLE_UNPACK_IMPL(...) __VA_ARGS__
#define NTH_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, N, ...) N
#define NARGS(...) NTH_ARG(__VA_ARGS__, 9, 8, 7, 6, 5, 4, 3, 2, 1)
#define INC(n) INC_##n
#define INC_0 1
#define INC_1 2
#define INC_2 3
#define INC_3 4
#define INC_4 5
#define INC_5 6
#define INC_6 7
#define INC_7 8
#define INC_8 9
#define INC_9 10
#define INC_10 11
#define JOIN(...) JOIN_IMPL(__VA_ARGS__)
#define JOIN_IMPL(...) CONCAT(JOIN_, NARGS(__VA_ARGS__))(__VA_ARGS__)
#define JOIN_0(...)
#define JOIN_1(a, ...) CONCAT(a, JOIN_0(__VA_ARGS__))
#define JOIN_2(a, ...) CONCAT(a, JOIN_1(__VA_ARGS__))
#define JOIN_3(a, ...) CONCAT(a, JOIN_2(__VA_ARGS__))
#define JOIN_4(a, ...) CONCAT(a, JOIN_3(__VA_ARGS__))
#define JOIN_5(a, ...) CONCAT(a, JOIN_4(__VA_ARGS__))
#define JOIN_6(a, ...) CONCAT(a, JOIN_5(__VA_ARGS__))
#define JOIN_7(a, ...) CONCAT(a, JOIN_6(__VA_ARGS__))
#define JOIN_8(a, ...) CONCAT(a, JOIN_7(__VA_ARGS__))
#define JOIN_9(a, ...) CONCAT(a, JOIN_8(__VA_ARGS__))
#define JOIN_10(a, ...) CONCAT(a, JOIN_9(__VA_ARGS__))
// call f(idx, arg) for each argument
#define FOR_EACH(f, ...) FOR_EACH_IMPL(f, NARGS(__VA_ARGS__), __VA_ARGS__)
#define FOR_EACH_IMPL(f, n, ...) CONCAT(FOR_EACH_, n)(f, 0, __VA_ARGS__)
#define FOR_EACH_0(f, ...)
#define FOR_EACH_1(f, i, a, ...) f(i, a) FOR_EACH_0(f, INC(i), __VA_ARGS__)
#define FOR_EACH_2(f, i, a, ...) f(i, a) FOR_EACH_1(f, INC(i), __VA_ARGS__)
#define FOR_EACH_3(f, i, a, ...) f(i, a) FOR_EACH_2(f, INC(i), __VA_ARGS__)
#define FOR_EACH_4(f, i, a, ...) f(i, a) FOR_EACH_3(f, INC(i), __VA_ARGS__)
#define FOR_EACH_5(f, i, a, ...) f(i, a) FOR_EACH_4(f, INC(i), __VA_ARGS__)
#define FOR_EACH_6(f, i, a, ...) f(i, a) FOR_EACH_5(f, INC(i), __VA_ARGS__)
#define FOR_EACH_7(f, i, a, ...) f(i, a) FOR_EACH_6(f, INC(i), __VA_ARGS__)
#define FOR_EACH_8(f, i, a, ...) f(i, a) FOR_EACH_7(f, INC(i), __VA_ARGS__)
#define FOR_EACH_9(f, i, a, ...) f(i, a) FOR_EACH_8(f, INC(i), __VA_ARGS__)
#define FOR_EACH_10(f, i, a, ...) f(i, a) FOR_EACH_9(f, INC(i), __VA_ARGS__)
#define TYPE_JOIN(types) JOIN(TUPLE_UNPACK(types))
#define EMITC_DEFINE_SHIMS(arg_types, ret_types) \
EMITC_FIXED_TYPEDEF(arg_types, TYPE_JOIN(arg_types), ret_types, \
TYPE_JOIN(ret_types)) \
EMITC_FIXED_SHIM(arg_types, TYPE_JOIN(arg_types), ret_types, \
TYPE_JOIN(ret_types)) \
EMITC_FIXED_IMPORT(arg_types, TYPE_JOIN(arg_types), ret_types, \
TYPE_JOIN(ret_types))
#define EMITC_FIXED_TYPEDEF(arg_types, arg_types_string, ret_types, \
ret_types_string) \
EMITC_FIXED_TYPEDEF_IMPL(arg_types_string, ret_types_string, \
INPUT_PARAMETERS(arg_types), \
OUTPUT_PARAMETERS(ret_types))
#define EMITC_FIXED_SHIM(arg_types, arg_types_string, ret_types, \
ret_types_string) \
EMITC_FIXED_SHIM_IMPL(arg_types_string, ret_types_string, \
INPUT_ARGUMENTS(arg_types), \
OUTPUT_ARGUMENTS(ret_types))
#define EMITC_FIXED_IMPORT(arg_types, arg_types_string, ret_types, \
ret_types_string) \
EMITC_FIXED_IMPORT_IMPL( \
arg_types_string, ret_types_string, INPUT_PARAMETERS(arg_types), \
OUTPUT_PARAMETERS(ret_types), PACK_ARGUMENTS(arg_types), \
UNPACK_RESULTS(ret_types))
#define EMITC_VLA_IMPORT(non_var_arg_types, var_arg_types, ret_types) \
EMITC_VLA_IMPORT_INDIRECT(non_var_arg_types, TYPE_JOIN(non_var_arg_types), \
var_arg_types, TYPE_JOIN(var_arg_types), \
ret_types, TYPE_JOIN(ret_types))
#define EMITC_VLA_IMPORT_INDIRECT(non_var_arg_types, non_var_arg_types_string, \
var_arg_types, var_arg_types_string, \
ret_types, ret_types_string) \
EMITC_VLA_IMPORT_IMPL( \
non_var_arg_types_string, var_arg_types_string, ret_types_string, \
ARGUMENTS_SIZE(non_var_arg_types), ARGUMENTS_SIZE(var_arg_types), \
PACK_VARARG_ARGUMENTS(non_var_arg_types), \
PACK_VARARG_ARGUMENTS(var_arg_types), UNPACK_VARARG_RESULTS(ret_types), \
UNPACK_RESULTS(ret_types))
#define EMITC_FIXED_TYPEDEF_IMPL(arg_types, ret_types, input_parameters, \
output_parameters) \
typedef iree_status_t (*call_0##arg_types##_##ret_types##_t)( \
iree_vm_stack_t * IREE_RESTRICT stack, void* IREE_RESTRICT module, \
void* IREE_RESTRICT module_state input_parameters output_parameters);
// TODO(simon-camp): We should check the args and rets pointers for NULL, but
// need to special case type 'v'
#define EMITC_FIXED_SHIM_IMPL(arg_types, ret_types, input_arguments, \
output_arguments) \
static iree_status_t call_0##arg_types##_##ret_types##_shim( \
iree_vm_stack_t* IREE_RESTRICT stack, \
const iree_vm_function_call_t* IREE_RESTRICT call, \
call_0##arg_types##_##ret_types##_t target_fn, \
void* IREE_RESTRICT module, void* IREE_RESTRICT module_state, \
iree_vm_execution_result_t* IREE_RESTRICT out_result) { \
/*const*/ IREE_VM_ABI_TYPE_NAME(arg_types)* args = \
iree_vm_abi_##arg_types##_checked_deref(call->arguments); \
IREE_VM_ABI_TYPE_NAME(ret_types)* rets = \
iree_vm_abi_##ret_types##_checked_deref(call->results); \
\
iree_vm_abi_##ret_types##_reset(rets); \
return target_fn(stack, module, \
module_state input_arguments output_arguments); \
}
#define EMITC_FIXED_IMPORT_IMPL(arg_types, ret_types, input_parameters, \
output_parameters, pack_arguments, \
unpack_results) \
static iree_status_t call_0##arg_types##_##ret_types##_import( \
iree_vm_stack_t* IREE_RESTRICT stack, \
const iree_vm_function_t* IREE_RESTRICT import input_parameters \
output_parameters) { \
IREE_VM_ABI_TYPE_NAME(arg_types) arguments; \
iree_vm_abi_##arg_types##_reset(&arguments); \
pack_arguments; \
\
IREE_VM_ABI_TYPE_NAME(ret_types) results; \
iree_vm_abi_##ret_types##_reset(&results); \
\
iree_vm_function_call_t call; \
call.function = *import; \
call.arguments = iree_make_byte_span(&arguments, sizeof(arguments)); \
call.results = iree_make_byte_span(&results, sizeof(results)); \
\
iree_vm_execution_result_t result; \
memset(&result, 0, sizeof(result)); \
\
iree_status_t status = \
import->module->begin_call(import->module, stack, &call, &result); \
\
if (!iree_status_is_ok(status)) { \
return status; \
} \
\
unpack_results; \
\
return status; \
}
#define EMITC_VA_LIST_NAME varargs
#define EMITC_CALL_ARG_PTR_NAME ptr
#define EMITC_VLA_IMPORT_IMPL(non_var_arg_types, var_arg_types, ret_types, \
non_var_arg_size, var_arg_size, pack_args, \
pack_var_args, define_results, unpack_results) \
static iree_status_t \
call_0##non_var_arg_types##C##var_arg_types##D_##ret_types##_import( \
iree_vm_stack_t* IREE_RESTRICT stack, \
const iree_vm_function_t* IREE_RESTRICT import, int32_t span_count, \
...) { \
iree_host_size_t total_size = \
non_var_arg_size + sizeof(int32_t) + span_count * var_arg_size; \
\
IREE_VM_ABI_TYPE_NAME(ret_types) results; \
iree_vm_abi_##ret_types##_reset(&results); \
\
iree_vm_function_call_t call; \
call.function = *import; \
call.arguments.data_length = total_size; \
call.arguments.data = (uint8_t*)iree_alloca(call.arguments.data_length); \
call.results = iree_make_byte_span(&results, sizeof(results)); \
\
memset(call.arguments.data, 0, call.arguments.data_length); \
\
uint8_t* EMITC_CALL_ARG_PTR_NAME = call.arguments.data; \
va_list EMITC_VA_LIST_NAME; \
va_start(EMITC_VA_LIST_NAME, span_count); \
\
pack_args; \
memcpy(EMITC_CALL_ARG_PTR_NAME, &span_count, sizeof(int32_t)); \
EMITC_CALL_ARG_PTR_NAME += sizeof(int32_t); \
for (int32_t i = 0; i < span_count; i++) { \
pack_var_args \
} \
define_results; \
\
va_end(EMITC_VA_LIST_NAME); \
\
iree_vm_execution_result_t result; \
memset(&result, 0, sizeof(result)); \
\
iree_status_t status = \
import->module->begin_call(import->module, stack, &call, &result); \
\
if (!iree_status_is_ok(status)) { \
return status; \
} \
\
unpack_results; \
\
return status; \
}
#define ARGUMENTS_SIZE(types) (0 FOR_EACH(ARGUMENT_SIZE, TUPLE_UNPACK(types)))
#define ARGUMENT_SIZE(idx, arg) +ARGUMENT_SIZE_##arg
#define ARGUMENT_SIZE_i sizeof(int32_t)
#define ARGUMENT_SIZE_r sizeof(iree_vm_ref_t)
#define ARGUMENT_SIZE_v 0
#define INPUT_ARGUMENTS(types) FOR_EACH(INPUT_ARGUMENT, TUPLE_UNPACK(types))
#define INPUT_ARGUMENT(idx, arg) INPUT_ARGUMENT_##arg(idx)
#define INPUT_ARGUMENT_i(idx) , args->i##idx
#define INPUT_ARGUMENT_r(idx) , &args->r##idx
#define INPUT_ARGUMENT_v(idx)
#define OUTPUT_ARGUMENTS(types) FOR_EACH(OUTPUT_ARGUMENT, TUPLE_UNPACK(types))
#define OUTPUT_ARGUMENT(idx, arg) OUTPUT_ARGUMENT_##arg(idx)
#define OUTPUT_ARGUMENT_i(idx) , &rets->i##idx
#define OUTPUT_ARGUMENT_r(idx) , &rets->r##idx
#define OUTPUT_ARGUMENT_v(idx)
#define INPUT_PARAMETERS(types) FOR_EACH(INPUT_PARAMETER, TUPLE_UNPACK(types))
#define INPUT_PARAMETER(idx, arg) INPUT_PARAMETER_##arg(idx)
#define INPUT_PARAMETER_i(idx) , int32_t arg##idx
#define INPUT_PARAMETER_r(idx) , iree_vm_ref_t* arg##idx
#define INPUT_PARAMETER_v(idx)
#define OUTPUT_PARAMETERS(types) FOR_EACH(OUTPUT_PARAMETER, TUPLE_UNPACK(types))
#define OUTPUT_PARAMETER(idx, arg) OUTPUT_PARAMETER_##arg(idx)
#define OUTPUT_PARAMETER_i(idx) , int32_t* ret##idx
#define OUTPUT_PARAMETER_r(idx) , iree_vm_ref_t* ret##idx
#define OUTPUT_PARAMETER_v(idx)
#define PACK_ARGUMENTS(types) FOR_EACH(PACK_ARGUMENT, TUPLE_UNPACK(types))
#define PACK_ARGUMENT(idx, arg) PACK_ARGUMENT_##arg(idx)
#define PACK_ARGUMENT_i(idx) arguments.i##idx = arg##idx;
#define PACK_ARGUMENT_r(idx) iree_vm_ref_assign(arg##idx, &arguments.r##idx);
#define PACK_ARGUMENT_v(idx)
#define UNPACK_RESULTS(types) FOR_EACH(UNPACK_RESULT, TUPLE_UNPACK(types))
#define UNPACK_RESULT(idx, arg) UNPACK_RESULT_##arg(idx)
#define UNPACK_RESULT_i(idx) *ret##idx = results.i##idx;
#define UNPACK_RESULT_r(idx) iree_vm_ref_move(&results.r##idx, ret##idx);
#define UNPACK_RESULT_v(idx)
#define PACK_VARARG_ARGUMENTS(types) FOR_EACH(PACK_VARARG, TUPLE_UNPACK(types))
#define PACK_VARARG(idx, arg) PACK_VARARG_##arg(idx)
#define PACK_VARARG_i(idx) \
PACK_VARARG_i_IMPL(EMITC_CALL_ARG_PTR_NAME, EMITC_VA_LIST_NAME, \
CONCAT(_temp, __COUNTER__))
#define PACK_VARARG_i_IMPL(dest, varargs, temp) \
int32_t temp = va_arg(varargs, int32_t); \
memcpy(dest, &temp, sizeof(int32_t)); \
dest += sizeof(int32_t);
#define PACK_VARARG_r(idx) \
PACK_VARARG_r_IMPL(EMITC_CALL_ARG_PTR_NAME, EMITC_VA_LIST_NAME, \
CONCAT(_temp, __COUNTER__))
#define PACK_VARARG_r_IMPL(dest, varargs, temp) \
iree_vm_ref_t* temp = va_arg(varargs, iree_vm_ref_t*); \
iree_vm_ref_assign(temp, (iree_vm_ref_t*)(dest)); \
dest += sizeof(iree_vm_ref_t);
#define PACK_VARARG_v(idx)
#define UNPACK_VARARG_RESULTS(types) \
FOR_EACH(UNPACK_VARARG, TUPLE_UNPACK(types))
#define UNPACK_VARARG(idx, arg) UNPACK_VARARG_##arg(idx)
#define UNPACK_VARARG_i(idx) \
int32_t* ret##idx = va_arg(EMITC_VA_LIST_NAME, int32_t*);
#define UNPACK_VARARG_r(idx) \
iree_vm_ref_t* ret##idx = va_arg(EMITC_VA_LIST_NAME, iree_vm_ref_t*);
#define UNPACK_VARARG_v(idx)
EMITC_DEFINE_SHIMS((i), (i))
EMITC_DEFINE_SHIMS((i, i), (i))
EMITC_DEFINE_SHIMS((r), (r))
EMITC_DEFINE_SHIMS((r), (v))
EMITC_DEFINE_SHIMS((r, i, i), (r))
EMITC_DEFINE_SHIMS((r, i, i, i), (r))
EMITC_DEFINE_SHIMS((r, i, i, i), (v))
EMITC_DEFINE_SHIMS((r, r, i, i, i, i), (v))
EMITC_DEFINE_SHIMS((r, r, r, i, i, i), (v))
EMITC_DEFINE_SHIMS((r, r), (r))
EMITC_DEFINE_SHIMS((r, r), (v))
EMITC_DEFINE_SHIMS((r, r, r), (i, i))
EMITC_DEFINE_SHIMS((v), (i))
EMITC_DEFINE_SHIMS((v), (r))
EMITC_DEFINE_SHIMS((v), (v))
EMITC_VLA_IMPORT((r, i), (i, i, i), (r))
EMITC_VLA_IMPORT((r, i), (r), (r))
EMITC_VLA_IMPORT((r, i, i), (i), (r))
EMITC_VLA_IMPORT((r, r, i), (i, r, i, i), (v))
EMITC_VLA_IMPORT((r, r, r), (r), (r))
EMITC_VLA_IMPORT((r, r, i, i), (i), (v))
#endif // IREE_VM_SHIMS_EMITC_H_ | c |
HaiDeHui/HaiDeHui/Common/PhotoBrowser/HDPhotoBrowserContentView.h | andyysea/HDH | 0 | 3220648 | //
// HDPhotoBrowserContentView.h
// HaiDeHui
//
// Created by junde on 2017/6/6.
// Copyright © 2017年 junde. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface HDPhotoBrowserContentView : UIView
/** 滚动视图 */
@property (nonatomic, weak) UIScrollView *scrollView;
/** 加载的需要缩放的图片 */
@property (nonatomic, weak) UIImageView *imageView;
/** 讲单点手势传递给上一级视图做处理 -> 退出浏览器 */
@property (nonatomic, copy) void (^singleTapBlock)(UITapGestureRecognizer *tapGesture);
/** 是否开始加载当前单个图片视图的图片 */
@property (nonatomic, assign) BOOL IsBeginLoading;
/** 图片是否加载完成,并加载成功 -> 没有加载完成不能缩放和保存 */
@property (nonatomic, assign) BOOL IsHaveLoaded;
/** 设置图片的URL,以及占位图片 */
- (void)setImageWithURL:(NSURL *)url placeholderImage:(UIImage *)placeholder;
@end | c |
usr/libexec/PineBoard/PBBulletinService.h | lechium/tvOS145Headers | 5 | 4639818 | //
// Generated by classdumpios 1.0.1 (64 bit) (iOS port by DreamDevLost)(Debug version compiled Sep 26 2020 13:48:20).
//
// Copyright (C) 1997-2019 <NAME>.
//
#import <objc/NSObject.h>
#import "PBBulletinManagerObserver-Protocol.h"
#import "PBRemoteBulletinViewControllerDelegate-Protocol.h"
#import "PBSBulletinServiceInterface-Protocol.h"
@class NSMapTable, NSMutableDictionary, NSString, PBSystemOverlayController, PBSystemServiceConnection;
@protocol PBSBulletinServiceDelegate, PBSBulletinServiceInteractionDelegate;
@interface PBBulletinService : NSObject <PBBulletinManagerObserver, PBRemoteBulletinViewControllerDelegate, PBSBulletinServiceInterface>
{
PBSystemServiceConnection *_remoteConnection; // 8 = 0x8
NSMapTable *_viewControllersByBulletin; // 16 = 0x10
NSMutableDictionary *_pendingBulletinsByRequestID; // 24 = 0x18
id <PBSBulletinServiceDelegate> _delegateProxy; // 32 = 0x20
id <PBSBulletinServiceInteractionDelegate> _interactionDelegateProxy; // 40 = 0x28
PBSystemOverlayController *_overlayController; // 48 = 0x30
}
+ (void)_setBulletinService:(id)arg1 forViewController:(id)arg2; // IMP=0x00000001000e7ec8
+ (id)_bulletinServiceForViewController:(id)arg1; // IMP=0x00000001000e7da4
+ (_Bool)areInteractiveBulletinsSupported; // IMP=0x00000001000e3be0
+ (void)applicationTerminateBulletinViewController:(id)arg1; // IMP=0x00000001000e3a88
+ (void)applicationRetireBulletinViewController:(id)arg1; // IMP=0x00000001000e3930
+ (_Bool)applicationDismissBulletinViewController:(id)arg1; // IMP=0x00000001000e37b0
+ (void)applicationDeactivateBulletinViewController:(id)arg1; // IMP=0x00000001000e3654
+ (void)applicationToggleBulletinViewControllerSize:(id)arg1; // IMP=0x00000001000e35c0
+ (unsigned long long)applicationActivateBulletinViewController:(id)arg1; // IMP=0x00000001000e3424
+ (_Bool)applicationShouldActivateBulletinViewController:(id)arg1 forAction:(unsigned long long)arg2; // IMP=0x00000001000e337c
+ (unsigned long long)applicationActivationActionsForBulletinViewController:(id)arg1; // IMP=0x00000001000e30e0
+ (id)_bulletinServicesByViewController; // IMP=0x00000001000e24cc
- (void).cxx_destruct; // IMP=0x00000001000e82dc
@property(readonly, nonatomic) PBSystemOverlayController *overlayController; // @synthesize overlayController=_overlayController;
@property(retain) id <PBSBulletinServiceInteractionDelegate> interactionDelegateProxy; // @synthesize interactionDelegateProxy=_interactionDelegateProxy;
@property(retain) id <PBSBulletinServiceDelegate> delegateProxy; // @synthesize delegateProxy=_delegateProxy;
@property(readonly, nonatomic) NSMutableDictionary *pendingBulletinsByRequestID; // @synthesize pendingBulletinsByRequestID=_pendingBulletinsByRequestID;
@property(readonly, nonatomic) NSMapTable *viewControllersByBulletin; // @synthesize viewControllersByBulletin=_viewControllersByBulletin;
@property(readonly, nonatomic) __weak PBSystemServiceConnection *remoteConnection; // @synthesize remoteConnection=_remoteConnection;
- (void)_setViewController:(id)arg1 forBulletin:(id)arg2; // IMP=0x00000001000e7a34
- (id)_viewControllerForBulletin:(id)arg1; // IMP=0x00000001000e7910
- (id)_bulletinForViewController:(id)arg1; // IMP=0x00000001000e7650
- (_Bool)_shouldBeginUserInteractionOnActivationForViewController:(id)arg1; // IMP=0x00000001000e7554
- (_Bool)_bulletinIsPending:(id)arg1; // IMP=0x00000001000e742c
- (void)_updateRequestForBulletin:(id)arg1 withBulletin:(id)arg2; // IMP=0x00000001000e7160
- (id)_bulletinForRequestID:(unsigned long long)arg1; // IMP=0x00000001000e7014
- (void)_setBulletin:(id)arg1 forRequestID:(unsigned long long)arg2; // IMP=0x00000001000e6e50
- (void)_updateVideoBulletinViewController:(id)arg1 withBulletin:(id)arg2 completion:(CDUnknownBlockType)arg3; // IMP=0x00000001000e6a7c
- (void)toggleBulletinSizeForViewController:(id)arg1; // IMP=0x00000001000e6978
- (void)_setUserInteractionEnabled:(_Bool)arg1 forViewController:(id)arg2; // IMP=0x00000001000e6864
- (void)_prepareToPresentViewController:(id)arg1; // IMP=0x00000001000e6720
- (void)_handleApplicationDismissalForViewController:(id)arg1 withReason:(unsigned long long)arg2; // IMP=0x00000001000e6138
- (void)_completeWithBulletin:(id)arg1 success:(_Bool)arg2 error:(id)arg3 completion:(CDUnknownBlockType)arg4; // IMP=0x00000001000e5e80
- (id)_reserveTableSpaceForBulletin:(id)arg1 error:(id *)arg2; // IMP=0x00000001000e5c50
- (void)remoteBulletinViewController:(id)arg1 didReceiveBulletinResponse:(id)arg2; // IMP=0x00000001000e5ac0
- (void)setInteractionDelegate:(id)arg1; // IMP=0x00000001000e5a60
- (void)setDelegate:(id)arg1; // IMP=0x00000001000e5a00
- (void)dismissBulletin:(id)arg1; // IMP=0x00000001000e566c
- (id)updateBulletin:(id)arg1 withMessage:(id)arg2 withCompletion:(CDUnknownBlockType)arg3; // IMP=0x00000001000e5170
- (void)xpcUpdateBulletin:(id)arg1 withMessage:(id)arg2 withCompletion:(CDUnknownBlockType)arg3; // IMP=0x00000001000e4be0
- (void)presentBulletin:(id)arg1 withCompletion:(CDUnknownBlockType)arg2; // IMP=0x00000001000e3c18
- (void)bulletinManager:(id)arg1 willPresentBulletinViewController:(id)arg2 withActivationActions:(unsigned long long)arg3; // IMP=0x00000001000e2f5c
- (void)invalidate; // IMP=0x00000001000e27d4
- (void)dealloc; // IMP=0x00000001000e2754
- (id)initWithRemoteConnection:(id)arg1; // IMP=0x00000001000e25e8
- (id)init; // IMP=0x00000001000e25b0
// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly, copy) NSString *description;
@property(readonly) unsigned long long hash;
@property(readonly) Class superclass;
@end | c |
drivers/tapdisk-metrics.h | GaryKirkpatrick/blktap | 30 | 5627174 | /*
* Copyright (c) 2016, Citrix Systems, Inc.
*
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef TAPDISK_METRICS_H
#define TAPDISK_METRICS_H
#define TAPDISK_METRICS_PATHF "/dev/shm/td3-%d"
#define TAPDISK_METRICS_VDI_PATHF "%s/vdi-%hu"
#define TAPDISK_METRICS_VBD_PATHF "%s/vbd-%d-%d"
#define TAPDISK_METRICS_BLKTAP_PATHF "%s/blktap-%d"
#define TAPDISK_METRICS_NBD_PATHF "%s/nbd-%d"
#include <libaio.h>
#include "tapdisk-metrics-stats.h"
#include "tapdisk-utils.h"
#include "tapdisk.h"
typedef struct {
struct shm shm;
struct stats *stats;
} stats_t;
typedef struct {
char *path;
} td_metrics_t;
/* Creates a folder in which to store tapdisk3 statistics: /dev/shm/td3-<pid> */
int td_metrics_start();
/* Destroys the folder /dev/shm/td3-<pid> and its contents */
void td_metrics_stop();
/* Creates the shm for the file that stores metrics from tapdisk to the vdi */
int td_metrics_vdi_start(int minor, stats_t *vdi_stats);
/* Destroys the files created to store the metrics from tapdisk to the vdi */
int td_metrics_vdi_stop(stats_t *vdi_stats);
/* Creates the metrics file to store the stats from blkfront to tapdisk */
int td_metrics_vbd_start(int domain, int id, stats_t *vbd_stats);
/* Destroys the files created to store metrics from blkfront to tapdisk */
int td_metrics_vbd_stop(stats_t *vbd_stats);
/* Creates the metrics file between tapdisk and blktap */
int td_metrics_blktap_start(int minor, stats_t *blktap_stats);
/* Destroys the metrics file between tapdisk and blktap */
int td_metrics_blktap_stop(stats_t *blktap_stats);
int td_metrics_nbd_start(stats_t *nbd_server, int minor);
int td_metrics_nbd_stop(stats_t *nbd_server);
#endif /* TAPDISK_METRICS_H */ | c |
Example/Pods/Headers/Public/CLKitHelp/NSString+Formatter.h | TmacCL0523/test | 0 | 5620830 | /***
当前的文件名
NSString+Formatter.h
不带后缀的文件名
NSString+Formatter
┏┓ ┏┓+ +
┏┛┻━━━━━━━┛┻┓ + +
┃ ┃
┃ ━ ┃ ++ + + +
█████━█████ ┃+
┃ ┃ +
┃ ┻ ┃
┃ ┃ + +
┗━━┓ ┏━┛
┃ ┃
┃ ┃ + + + +
┃ ┃ Code is far away from bug with the animal protecting
┃ ┃ + 神兽保佑,代码无bug
┃ ┃
┃ ┃ +
┃ ┗━━━┓ + +
┃ ┣┓
┃ ┏┛
┗┓┓┏━━━┳┓┏┛ + + + +
┃┫┫ ┃┫┫
┗┻┛ ┗┻┛+ + + +
**/
#import <Foundation/Foundation.h>
@interface NSString (Formatter)
/// 手机号码格式化样式：344【中间空格】，示例：13855556666 --> 138 5555 6666
/// @param phoneNumber 138 5555 6666
+ (NSString *)clKitFormatterPhoneNumberSpace:(NSString *)phoneNumber;
/// 手机号码格式化样式：3*4【中间4位为*】，示例：13855556666 --> 138****6666
/// @param phoneNumber 138****6666
+ (NSString *)clKitFormatterPhoneNumberCenterStar:(NSString *)phoneNumber;
/// 数字格式化样式，示例：12345678.89 --> 12,345,678.89
/// @param numberStyle 样式
/// @param numberString 12,345,678.89
+ (NSString *)clKitFormatterWithStyle:(NSNumberFormatterStyle)numberStyle
numberString:(NSString *)numberString;
/// 格式化为带小数点的数字，示例：12345678.89 --> 12,345,678.89
/// @param numberString 12,345,678.89
+ (NSString *)clKitFormatterWithDecimalStyleWithNumberString:(NSString *)numberString;
/// 格式化为货币样式，示例：12345678.89 --> 12,345,678.89
/// @param numberString 12,345,678.89
+ (NSString *)clKitFormatterWithCurrencyStyleWithNumberString:(NSString *)numberString;
/// 格式化为百分比样式，示例：12345678.89 --> 1,234,567,889%
/// @param numberString 1,234,567,889%
+ (NSString *)clKitFormatterWithPercentStyleWithNumberString:(NSString *)numberString;
/// 格式化为科学计数样式，示例：12345678.89 --> 1.234567889E7
/// @param numberString 1.234567889E7
+ (NSString *)clKitFormatterWithScientificStyleWithNumberString:(NSString *)numberString;
/// 格式化为英文输出样式（注：此处根据系统语言输出），示例：12345678.89 --> 一千二百三十四万五千六百七十八点八九
/// @param numberString 一千二百三十四万五千六百七十八点八九
+ (NSString *)clKitFormatterWithSpellOutStyleWithNumberString:(NSString *)numberString;
/// 格式化为序数样式，示例：12345678.89 --> 第1234,5679
/// @param numberString 第1234,5679
+ (NSString *)clKitFormatterWithOrdinalStyleWithNumberString:(NSString *)numberString;
+ (BOOL)checkDecimalDotPlaces:(NSRange)range
dotPlaces:(NSNumber *)dotPlaces
decimal:(NSString *)decimal;
/// 点赞数处理：2.1千，3.4万
/// @param string 传入的 string 类型的 数字
+ (NSString *)clKitFormatterLikeNumber:(NSString *)string;
/// 清除HTML标签
- (NSString *)clKitFormatterByStrippingHTML;
/// 清除JS脚本
- (NSString *)clKitFormatterByRemovingScriptsAndStrippingHTML;
/// 清除空格
- (NSString *)clKitFormatterRemoveSpace;
/// 取出空格空行
- (NSString *)clKitFormatterRemoveSpaceAndBankLine;
/// 随机字符串
+ (NSString *)clkitRandomString;
/// 根据key取不同语言字符串 （国际化操作）
/// @param key 关键字
/// @param table 表名
+ (NSString *)clKitGetStrForLanguageWithKey:(NSString *)key
withTable:(NSString *)table;
@end | c |
tests/test-xml.c | stevedonovan/llib | 28 | 2831364 | #include <stdio.h>
#include <llib/json.h>
#include <llib/xml.h>
const char *file = "test.xml";
int main(int argc, char**argv)
{
if (argv[1])
file = argv[1];
PValue v = xml_parse_file(file,true);
if (value_is_error(v)) {
fprintf(stderr,"error reading xml: %s\n",(char*)v);
return 1;
}
//char *s = json_tostring(v); // try this for kicks...
char *s = xml_tostring(v,0);
printf("%s\n",s);
obj_unref_v(v, s);
// the same notation used for building up JSON data works fine for XML docs
v = VAS("root",
VAS("item",VMS("name","age","type","int"),"10"),
VAS("item",VMS("name","name","type","string"),"Bonzo")
);
s = xml_tostring(v,0);
printf("%s\n",s);
char *s2 = json_tostring(v);
printf("json %s\n",s2);
obj_unref_v(v, s, s2);
printf("kount %d\n",obj_kount());
return 0;
} | c |
AppDelegate+DSAppDelegate.h | SincereD/DSCommon | 1 | 8184555 | //
// AppDelegate+DSAppDelegate.h
// DSCommon
//
// Created by Sincere on 16/8/25.
// Copyright © 2016年 QiujunTech. All rights reserved.
//
#import "AppDelegate.h"
@interface AppDelegate (DSAppDelegate)
@end | c |
src/xf-session.c | vanlink/xf-traffic-generator | 0 | 7201997 | #include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <getopt.h>
#include <rte_common.h>
#include <rte_launch.h>
#include <rte_memory.h>
#include <rte_cycles.h>
#include <rte_eal.h>
#include <rte_lcore.h>
#include <rte_ethdev.h>
#include <rte_ring.h>
#include <rte_bitmap.h>
#include <rte_malloc.h>
#include <rte_ether.h>
#include <rte_arp.h>
#include <rte_ip.h>
#include <rte_tcp.h>
#include <rte_udp.h>
#include <rte_icmp.h>
#include <rte_net.h>
#include "cjson/cJSON.h"
#include "lwip/init.h"
#include "dkfw_intf.h"
#include "dkfw_core.h"
#include "dkfw_profile.h"
#include "dkfw_ipc.h"
#include "dkfw_timer.h"
#include "dkfw_memory.h"
#include "dkfw_mempool.h"
#include "dpdkframework.h"
#include "xf-sharedmem.h"
#include "xf-session.h"
#include "xf-generator.h"
#if 1
static struct rte_mempool *sessions[MAX_CORES_PER_ROLE] = {NULL};
int init_sessions(uint64_t cnt)
{
int i;
uint64_t cnt_core = cnt / g_pkt_process_core_num;
char buff[64];
printf("Creating session pool %lu * %lu = [%lu] MB ... ", sizeof(SESSION), cnt, sizeof(SESSION) * cnt / 1000 / 1000);
for(i=0;i<g_pkt_process_core_num;i++){
sprintf(buff, "sessioncore%d", i);
sessions[i] = rte_mempool_create(buff, cnt_core, sizeof(SESSION),
cnt_core >= 2048 ? 512 : 64,
0, NULL, NULL, NULL, NULL,
SOCKET_ID_ANY, MEMPOOL_F_SP_PUT | MEMPOOL_F_SC_GET | MEMPOOL_F_NO_IOVA_CONTIG);
if(!sessions[i]){
printf("error.\n");
return -1;
}
}
printf("OK.\n");
return 0;
}
SESSION *session_get(void)
{
SESSION *sess = NULL;
if(rte_mempool_get(sessions[LWIP_MY_CPUID], (void **)&sess) < 0) {
GENERATOR_STATS_RESPOOL_ALLOC_FAIL(GENERATOR_STATS_SESSION);
return NULL;
}
GENERATOR_STATS_RESPOOL_ALLOC_SUCC(GENERATOR_STATS_SESSION);
bzero(sess, sizeof(SESSION));
return sess;
}
void session_free(SESSION *sess)
{
GENERATOR_STATS_RESPOOL_FREE(GENERATOR_STATS_SESSION);
rte_mempool_put(sessions[LWIP_MY_CPUID], sess);
}
#else
static DKFW_MEMPOOL *sessions[MAX_CORES_PER_ROLE] = {NULL};
int init_sessions(uint64_t cnt)
{
int i;
uint64_t cnt_core = cnt / g_pkt_process_core_num;
char buff[64];
printf("Creating session pool %lu * %lu = [%lu] MB ... ", sizeof(SESSION), cnt, sizeof(SESSION) * cnt / 1000 / 1000);
for(i=0;i<g_pkt_process_core_num;i++){
sprintf(buff, "sessioncore%d", i);
sessions[i] = dkfw_mempool_create(sizeof(SESSION), cnt_core);
if(!sessions[i]){
printf("error.\n");
return -1;
}
}
printf("OK.\n");
return 0;
}
SESSION *session_get(void)
{
SESSION *sess;
#if 0
DKFW_PROFILE_SINGLE_START(PROFILER_CORE, rte_rdtsc(), PROFILE_SINGLE_B);
#endif
sess = (SESSION *)dkfw_mempool_alloc(sessions[LWIP_MY_CPUID]);
#if 0
DKFW_PROFILE_SINGLE_END(PROFILER_CORE, rte_rdtsc(), PROFILE_SINGLE_B);
#endif
if(!sess) {
GENERATOR_STATS_RESPOOL_ALLOC_FAIL(GENERATOR_STATS_SESSION);
return NULL;
}
GENERATOR_STATS_RESPOOL_ALLOC_SUCC(GENERATOR_STATS_SESSION);
#if 0
DKFW_PROFILE_SINGLE_START(PROFILER_CORE, rte_rdtsc(), PROFILE_SINGLE_C);
#endif
bzero(sess, sizeof(SESSION));
#if 0
DKFW_PROFILE_SINGLE_END(PROFILER_CORE, rte_rdtsc(), PROFILE_SINGLE_C);
#endif
return sess;
}
void session_free(SESSION *sess)
{
GENERATOR_STATS_RESPOOL_FREE(GENERATOR_STATS_SESSION);
#if 0
DKFW_PROFILE_SINGLE_START(PROFILER_CORE, rte_rdtsc(), PROFILE_SINGLE_D);
#endif
dkfw_mempool_free((void *)sess);
#if 0
DKFW_PROFILE_SINGLE_END(PROFILER_CORE, rte_rdtsc(), PROFILE_SINGLE_D);
#endif
}
#endif | c |
srcs/block/sl_block_check_same_dim.c | JonathanDUFOUR/so_long | 0 | 8100219 | /* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sl_block_check_same_dim.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jodufour <<EMAIL>> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/08/29 20:32:57 by jodufour #+# #+# */
/* Updated: 2021/08/31 22:29:58 by jodufour ### ########.fr */
/* */
/* ************************************************************************** */
#include "type/t_block.h"
#include "enum/e_ret.h"
/*
** check if all images have the same dimensions
** return an error if at least one has not
*/
int sl_block_check_same_dim(void)
{
t_block *const block = sl_block();
if (block->collect.width != block->exit.width
|| block->collect.width != block->floor.width
|| block->collect.width != block->player_down.width
|| block->collect.width != block->player_left.width
|| block->collect.width != block->player_right.width
|| block->collect.width != block->player_up.width
|| block->collect.width != block->wall.width
|| block->collect.height != block->exit.height
|| block->collect.height != block->floor.height
|| block->collect.height != block->player_down.height
|| block->collect.height != block->player_left.height
|| block->collect.height != block->player_right.height
|| block->collect.height != block->player_up.height
|| block->collect.height != block->wall.height)
return (IMG_DIM_ERR);
return (SUCCESS);
} | c |
include/CGLFace3D.h | colinw7/CGL | 0 | 7858967 | #ifndef CGL_FACE_3D_H
#define CGL_FACE_3D_H
#include <CGeomFace3D.h>
class CGLFace3D : public CGeomFace3D {
private:
CImagePtr stipple_;
public:
CGLFace3D() { }
void setStipple(const CImagePtr &stipple) {
stipple_ = stipple;
}
const CImagePtr &getStipple() const {
return stipple_;
}
};
#endif | c |
content/public/common/speech_recognition_error_list.h | nagineni/chromium-crosswalk | 4 | 2450606 | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This file intentionally does not have header guards, it's included
// inside a macro to generate enum values.
#ifndef DEFINE_SPEECH_RECOGNITION_ERROR
#error "DEFINE_SPEECH_RECOGNITION_ERROR must be defined before including this."
#endif
// There was no error.
DEFINE_SPEECH_RECOGNITION_ERROR(NONE, 0)
// The user or a script aborted speech input.
DEFINE_SPEECH_RECOGNITION_ERROR(ABORTED, 1)
// There was an error with recording audio.
DEFINE_SPEECH_RECOGNITION_ERROR(AUDIO, 2)
// There was a network error.
DEFINE_SPEECH_RECOGNITION_ERROR(NETWORK, 3)
// Not allowed for privacy or security reasons.
DEFINE_SPEECH_RECOGNITION_ERROR(NOT_ALLOWED, 4)
// No speech heard before timeout.
DEFINE_SPEECH_RECOGNITION_ERROR(NO_SPEECH, 5)
// Speech was heard, but could not be interpreted.
DEFINE_SPEECH_RECOGNITION_ERROR(NO_MATCH, 6)
// There was an error in the speech recognition grammar.
DEFINE_SPEECH_RECOGNITION_ERROR(BAD_GRAMMAR, 7) | c |
z2/part1/jm/random/775638605.c | kozakusek/ipp-2020-testy | 1 | 4928488 | #include <stdint.h>
#include <stdlib.h>
#include <assert.h>
#include <stdio.h>
#include "gamma.h"
#include <stdbool.h>
#include <string.h>
int main() {
/*
scenario: test_random_actions
uuid: 775638605
*/
/*
random actions, total chaos
*/
gamma_t* board = gamma_new(7, 5, 4, 1);
assert( board != NULL );
assert( gamma_move(board, 1, 2, 4) == 1 );
assert( gamma_busy_fields(board, 1) == 1 );
assert( gamma_move(board, 2, 3, 3) == 1 );
assert( gamma_move(board, 3, 3, 1) == 1 );
assert( gamma_golden_possible(board, 3) == 1 );
assert( gamma_golden_move(board, 3, 4, 2) == 0 );
assert( gamma_move(board, 4, 3, 2) == 1 );
assert( gamma_move(board, 4, 1, 1) == 0 );
assert( gamma_move(board, 1, 0, 0) == 0 );
assert( gamma_move(board, 2, 2, 2) == 0 );
assert( gamma_move(board, 3, 3, 4) == 0 );
assert( gamma_free_fields(board, 3) == 3 );
assert( gamma_move(board, 4, 2, 6) == 0 );
assert( gamma_move(board, 4, 5, 1) == 0 );
char* board887634865 = gamma_board(board);
assert( board887634865 != NULL );
assert( strcmp(board887634865,
"..1....\n"
"...2...\n"
"...4...\n"
"...3...\n"
".......\n") == 0);
free(board887634865);
board887634865 = NULL;
assert( gamma_move(board, 1, 1, 1) == 0 );
assert( gamma_move(board, 1, 2, 3) == 1 );
assert( gamma_move(board, 2, 4, 0) == 0 );
assert( gamma_move(board, 3, 2, 4) == 0 );
assert( gamma_move(board, 3, 3, 3) == 0 );
assert( gamma_busy_fields(board, 3) == 1 );
assert( gamma_move(board, 4, 2, 5) == 0 );
assert( gamma_move(board, 1, 0, 3) == 0 );
assert( gamma_move(board, 1, 0, 3) == 0 );
assert( gamma_golden_move(board, 1, 1, 3) == 0 );
assert( gamma_move(board, 2, 0, 1) == 0 );
assert( gamma_move(board, 3, 0, 3) == 0 );
assert( gamma_golden_possible(board, 3) == 1 );
assert( gamma_move(board, 4, 6, 0) == 0 );
assert( gamma_move(board, 4, 6, 0) == 0 );
assert( gamma_move(board, 1, 0, 3) == 0 );
assert( gamma_move(board, 2, 1, 5) == 0 );
assert( gamma_move(board, 3, 4, 3) == 0 );
assert( gamma_move(board, 3, 1, 4) == 0 );
assert( gamma_move(board, 4, 3, 4) == 0 );
assert( gamma_golden_possible(board, 4) == 1 );
assert( gamma_move(board, 1, 0, 1) == 0 );
assert( gamma_move(board, 2, 3, 6) == 0 );
assert( gamma_move(board, 2, 5, 2) == 0 );
assert( gamma_move(board, 4, 3, 1) == 0 );
assert( gamma_move(board, 1, 2, 4) == 0 );
assert( gamma_move(board, 1, 1, 4) == 1 );
assert( gamma_move(board, 2, 2, 5) == 0 );
assert( gamma_move(board, 3, 2, 2) == 0 );
char* board931944541 = gamma_board(board);
assert( board931944541 != NULL );
assert( strcmp(board931944541,
".11....\n"
"..12...\n"
"...4...\n"
"...3...\n"
".......\n") == 0);
free(board931944541);
board931944541 = NULL;
assert( gamma_golden_possible(board, 4) == 1 );
assert( gamma_move(board, 1, 2, 6) == 0 );
assert( gamma_golden_possible(board, 1) == 1 );
assert( gamma_move(board, 2, 1, 6) == 0 );
assert( gamma_move(board, 2, 0, 2) == 0 );
assert( gamma_golden_move(board, 2, 1, 3) == 0 );
assert( gamma_move(board, 3, 3, 6) == 0 );
assert( gamma_busy_fields(board, 3) == 1 );
assert( gamma_move(board, 4, 2, 5) == 0 );
assert( gamma_free_fields(board, 4) == 2 );
assert( gamma_golden_move(board, 4, 3, 3) == 1 );
assert( gamma_move(board, 1, 0, 2) == 0 );
assert( gamma_move(board, 2, 5, 4) == 1 );
assert( gamma_move(board, 3, 6, 0) == 0 );
assert( gamma_golden_possible(board, 3) == 1 );
assert( gamma_move(board, 4, 0, 1) == 0 );
assert( gamma_move(board, 2, 1, 4) == 0 );
assert( gamma_move(board, 3, 6, 2) == 0 );
assert( gamma_move(board, 3, 0, 1) == 0 );
assert( gamma_move(board, 4, 3, 6) == 0 );
assert( gamma_move(board, 1, 0, 4) == 1 );
assert( gamma_move(board, 2, 2, 5) == 0 );
assert( gamma_move(board, 3, 5, 0) == 0 );
assert( gamma_move(board, 3, 4, 1) == 1 );
assert( gamma_move(board, 4, 1, 6) == 0 );
assert( gamma_move(board, 4, 5, 0) == 0 );
char* board469168435 = gamma_board(board);
assert( board469168435 != NULL );
assert( strcmp(board469168435,
"111..2.\n"
"..14...\n"
"...4...\n"
"...33..\n"
".......\n") == 0);
free(board469168435);
board469168435 = NULL;
assert( gamma_move(board, 1, 3, 2) == 0 );
assert( gamma_move(board, 1, 6, 2) == 0 );
assert( gamma_move(board, 2, 5, 1) == 0 );
assert( gamma_golden_possible(board, 2) == 1 );
assert( gamma_move(board, 3, 4, 6) == 0 );
assert( gamma_move(board, 3, 6, 3) == 0 );
assert( gamma_busy_fields(board, 3) == 2 );
assert( gamma_move(board, 1, 3, 4) == 1 );
assert( gamma_move(board, 1, 4, 4) == 1 );
assert( gamma_free_fields(board, 1) == 4 );
assert( gamma_golden_move(board, 1, 3, 3) == 1 );
char* board363981021 = gamma_board(board);
assert( board363981021 != NULL );
assert( strcmp(board363981021,
"111112.\n"
"..11...\n"
"...4...\n"
"...33..\n"
".......\n") == 0);
free(board363981021);
board363981021 = NULL;
assert( gamma_move(board, 2, 3, 4) == 0 );
assert( gamma_busy_fields(board, 2) == 1 );
assert( gamma_move(board, 3, 1, 0) == 0 );
assert( gamma_golden_possible(board, 3) == 1 );
assert( gamma_move(board, 4, 3, 1) == 0 );
assert( gamma_busy_fields(board, 4) == 1 );
assert( gamma_move(board, 1, 0, 0) == 0 );
assert( gamma_move(board, 1, 1, 2) == 0 );
assert( gamma_move(board, 2, 4, 2) == 0 );
assert( gamma_move(board, 1, 0, 0) == 0 );
assert( gamma_move(board, 1, 2, 4) == 0 );
assert( gamma_move(board, 2, 2, 6) == 0 );
assert( gamma_move(board, 3, 1, 2) == 0 );
assert( gamma_move(board, 3, 6, 2) == 0 );
assert( gamma_move(board, 4, 2, 2) == 1 );
assert( gamma_move(board, 1, 1, 2) == 0 );
assert( gamma_move(board, 1, 6, 2) == 0 );
assert( gamma_move(board, 2, 1, 5) == 0 );
assert( gamma_golden_move(board, 2, 1, 4) == 0 );
assert( gamma_move(board, 3, 0, 0) == 0 );
assert( gamma_move(board, 3, 0, 2) == 0 );
assert( gamma_move(board, 4, 1, 5) == 0 );
assert( gamma_move(board, 4, 3, 4) == 0 );
assert( gamma_move(board, 1, 3, 6) == 0 );
assert( gamma_move(board, 2, 4, 0) == 0 );
assert( gamma_move(board, 3, 3, 0) == 1 );
assert( gamma_move(board, 3, 0, 2) == 0 );
assert( gamma_move(board, 4, 3, 6) == 0 );
assert( gamma_move(board, 1, 2, 1) == 0 );
assert( gamma_move(board, 1, 0, 3) == 1 );
assert( gamma_free_fields(board, 1) == 3 );
assert( gamma_move(board, 2, 1, 2) == 0 );
assert( gamma_move(board, 2, 6, 0) == 0 );
gamma_delete(board);
return 0;
} | c |
thirdparty/ccan/ccan/aga/test/compile_ok.c | liftchampion/nativejson-benchmark | 0 | 452347 | #include "config.h"
#include <ccan/aga/aga.h>
#include <ccan/aga/aga.c>
typedef struct edge edge_t;
#ifndef EDGE1
#define EDGE1 edge_t
#endif
#ifndef EDGE2
#define EDGE2 edge_t
#endif
#ifndef EDGE3
#define EDGE3 edge_t
#endif
#ifndef EDGE4
#define EDGE4 edge_t
#endif
int main(void)
{
struct aga_graph g;
EDGE1 *(*first_edge)(const struct aga_graph *g,
const struct aga_node *n) = NULL;
EDGE2 *(*next_edge)(const struct aga_graph *g,
const struct aga_node *n,
EDGE3 *e) = NULL;
int (*edge_info)(const struct aga_graph *g, const struct aga_node *n,
EDGE4 *e, struct aga_edge_info *ei) = NULL;
aga_init_graph(&g, first_edge, next_edge, edge_info);
return 0;
} | c |
WBBlades/Tools/WBBladesCMD.h | zengql512/WBBlades | 1 | 3854726 | //
// WBBladesCMD.h
// WBBlades
//
// Created by 邓竹立 on 2019/12/25.
// Copyright © 2019 邓竹立. All rights reserved.
//
#import <Foundation/Foundation.h>
#ifdef __cplusplus
extern "C" {
#endif
/**
* Input file path, strip the symbol table.
*/
void stripFile(NSString *filePath);
/**
* Input file path, copy the file.
*/
void copyFile(NSString *filePath);
/**
* Input file path, strip multiple architectures and keep the arm64 architecture.
*/
void thinFile(NSString *filePath);
/**
* Remove the file.
*/
void removeFile(NSString *filePath);
/**
* Remove the copied file.
*/
void removeCopyFile(NSString *filePath);
/**
* Compile xcassert resources.
*/
void compileXcassets(NSString *path);
/**
* Color printing to console.
* @param info Information to be printed.
*/
void colorPrint(NSString *info);
NSString* getAppPathIfIpa(NSString *filePath);
void rmAppIfIpa(NSString *filePath);
#ifdef __cplusplus
}
#endif | c |
micwooftest/Libraries/libil2cpp/include/mono-runtime/il2cpp-mapping.h | woofie/woof-mic-recognition | 0 | 5947527 | #pragma once
#include "il2cpp-metadata.h"
struct MonoMethodInfo
{
int64_t hash;
int32_t invoker_index;
int32_t method_pointer_index;
};
struct MonoRGCTXDefinition
{
Il2CppRGCTXDataType type;
AssemblyIndex assemblyIndex;
int32_t token;
int32_t generic_parameter_index;
};
struct RuntimeGenericContextInfo
{
uint64_t hash;
int32_t rgctxStart;
int32_t rgctxCount;
};
struct MonoMetadataToken
{
AssemblyIndex assemblyIndex;
int32_t token;
};
#pragma pack(push, p1,4)
struct MonoMethodMetadata
{
MonoMetadataToken metadataToken;
MethodIndex reversePInvokeWrapperIndex;
uint64_t hash;
};
#pragma pack(pop, p1)
#pragma pack(push, p1,4)
struct MonoClassMetadata
{
MonoMetadataToken metadataToken;
int32_t genericParametersOffset;
int32_t genericParametersCount;
int32_t isPointer;
int32_t rank; //if rank == 0, the token is for a non-array type, otherwise the rank is valid and the token represents the element type of the array
int32_t elementTypeIndex;
};
#pragma pack(pop, p1)
struct MonoFieldMetadata
{
TypeIndex parentTypeIndex;
int32_t token;
};
struct MonoGenericInstMetadata
{
uint32_t type_argc;
const TypeIndex *type_argv_indices;
}; | c |
musl-1.1.18/src/unistd/sync.c | h7ga40/azure_iot_hub | 0 | 7129440 | #include <unistd.h>
#include "syscall.h"
void sync(void)
{
__syscall(SYS_sync);
} | c |
SNModuleKit/ModulePublic/Vender/PublicVenderHeader.h | snlo/SNModuleKit | 2 | 5435736 | //
// PublicVenderHeader.h
// SNMediatorKit
//
// Created by snlo on 2018/5/1.
// Copyright © 2018年 snlo. All rights reserved.
//
#ifndef PublicVenderHeader_h
#define PublicVenderHeader_h
#endif /* PublicVenderHeader_h */ | c |
packages/util/open-jtalk/soft/open_jtalk-1.11/njd_set_digit/njd_set_digit.c | tignear/bot | 16 | 4327419 | /* ----------------------------------------------------------------- */
/* The Japanese TTS System "Open JTalk" */
/* developed by HTS Working Group */
/* http://open-jtalk.sourceforge.net/ */
/* ----------------------------------------------------------------- */
/* */
/* Copyright (c) 2008-2016 Nagoya Institute of Technology */
/* Department of Computer Science */
/* */
/* All rights reserved. */
/* */
/* Redistribution and use in source and binary forms, with or */
/* without modification, are permitted provided that the following */
/* conditions are met: */
/* */
/* - Redistributions of source code must retain the above copyright */
/* notice, this list of conditions and the following disclaimer. */
/* - Redistributions in binary form must reproduce the above */
/* copyright notice, this list of conditions and the following */
/* disclaimer in the documentation and/or other materials provided */
/* with the distribution. */
/* - Neither the name of the HTS working group nor the names of its */
/* contributors may be used to endorse or promote products derived */
/* from this software without specific prior written permission. */
/* */
/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND */
/* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, */
/* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF */
/* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE */
/* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS */
/* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, */
/* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED */
/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, */
/* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON */
/* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, */
/* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY */
/* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE */
/* POSSIBILITY OF SUCH DAMAGE. */
/* ----------------------------------------------------------------- */
#ifndef NJD_SET_DIGIT_C
#define NJD_SET_DIGIT_C
#ifdef __cplusplus
#define NJD_SET_DIGIT_C_START extern "C" {
#define NJD_SET_DIGIT_C_END }
#else
#define NJD_SET_DIGIT_C_START
#define NJD_SET_DIGIT_C_END
#endif /* __CPLUSPLUS */
NJD_SET_DIGIT_C_START;
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "njd.h"
#include "njd_set_digit.h"
#ifdef ASCII_HEADER
#if defined(CHARSET_EUC_JP)
#include "njd_set_digit_rule_ascii_for_euc_jp.h"
#elif defined(CHARSET_SHIFT_JIS)
#include "njd_set_digit_rule_ascii_for_shift_jis.h"
#elif defined(CHARSET_UTF_8)
#include "njd_set_digit_rule_ascii_for_utf_8.h"
#else
#error CHARSET is not specified
#endif
#else
#if defined(CHARSET_EUC_JP)
#include "njd_set_digit_rule_euc_jp.h"
#elif defined(CHARSET_SHIFT_JIS)
#include "njd_set_digit_rule_shift_jis.h"
#elif defined(CHARSET_UTF_8)
#include "njd_set_digit_rule_utf_8.h"
#else
#error CHARSET is not specified
#endif
#endif
#define MAXBUFLEN 1024
static int strtopcmp(const char *str, const char *pattern)
{
int i;
for (i = 0;; i++) {
if (pattern[i] == '\0')
return i;
if (str[i] == '\0')
return -1;
if (str[i] != pattern[i])
return -1;
}
}
static int get_digit(NJDNode * node, int convert_flag)
{
int i;
if (strcmp(NJDNode_get_string(node), "*") == 0)
return -1;
if (strcmp(NJDNode_get_pos_group1(node), NJD_SET_DIGIT_KAZU) == 0)
for (i = 0; njd_set_digit_rule_numeral_list1[i] != NULL; i += 3)
if (strcmp(njd_set_digit_rule_numeral_list1[i], NJDNode_get_string(node)) == 0) {
if (convert_flag == 1) {
NJDNode_set_string(node, (char *) njd_set_digit_rule_numeral_list1[i + 2]);
NJDNode_set_orig(node, (char *) njd_set_digit_rule_numeral_list1[i + 2]);
}
return atoi(njd_set_digit_rule_numeral_list1[i + 1]);
}
return -1;
}
static int is_period(const char *str)
{
if (str != NULL &&
(strcmp(str, NJD_SET_DIGIT_TEN1) == 0 || strcmp(str, NJD_SET_DIGIT_TEN2) == 0)) {
return 1;
} else {
return 0;
}
}
static int is_comma(const char *str)
{
if (str != NULL && strcmp(str, NJD_SET_DIGIT_COMMA) == 0) {
return 1;
} else {
return 0;
}
}
static int get_digit_sequence_score(NJDNode * start, NJDNode * end)
{
const char *buff_pos_group1 = NULL;
const char *buff_pos_group2 = NULL;
const char *buff_string = NULL;
int score = 0;
if (start->prev) {
buff_pos_group1 = NJDNode_get_pos_group1(start->prev);
buff_pos_group2 = NJDNode_get_pos_group2(start->prev);
buff_string = NJDNode_get_string(start->prev);
if (strcmp(buff_pos_group1, NJD_SET_DIGIT_SUUSETSUZOKU) == 0) /* prev pos_group1 */
score += 2;
if (strcmp(buff_pos_group2, NJD_SET_DIGIT_JOSUUSHI) == 0 || strcmp(buff_pos_group1, NJD_SET_DIGIT_FUKUSHIKANOU) == 0) /* prev pos_group1 and pos_group2 */
score += 1;
if (buff_string != NULL) {
if (is_period(buff_string) == 1) {
if (!start->prev->prev
|| strcmp(NJDNode_get_pos_group1(start->prev->prev), NJD_SET_DIGIT_KAZU) != 0)
score += 0;
else
score -= 5;
} else if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN1) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN2) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN3) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN4) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN5) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_KAKKO1) == 0) {
if (!start->prev->prev
|| strcmp(NJDNode_get_pos_group1(start->prev->prev), NJD_SET_DIGIT_KAZU) != 0)
score += 0;
else
score -= 2;
} else if (strcmp(buff_string, NJD_SET_DIGIT_KAKKO2) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_BANGOU) == 0)
score -= 2;
}
if (start->prev->prev) {
buff_string = NJDNode_get_string(start->prev->prev); /* prev prev string */
if (strcmp(buff_string, NJD_SET_DIGIT_BANGOU) == 0)
score -= 2;
}
}
if (end->next) {
buff_pos_group1 = NJDNode_get_pos_group1(end->next);
buff_pos_group2 = NJDNode_get_pos_group2(end->next); /* next pos_group2 */
buff_string = NJDNode_get_string(end->next); /* next string */
if (strcmp(buff_pos_group2, NJD_SET_DIGIT_JOSUUSHI) == 0
|| strcmp(buff_pos_group1, NJD_SET_DIGIT_FUKUSHIKANOU) == 0)
score += 2;
if (buff_string != NULL) {
if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN1) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN2) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN3) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN4) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_HAIHUN5) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_KAKKO1) == 0)
score -= 2;
else if (strcmp(buff_string, NJD_SET_DIGIT_KAKKO2) == 0) {
if (!end->next->next
|| strcmp(NJDNode_get_pos_group1(end->next->next), NJD_SET_DIGIT_KAZU) != 0)
score += 0;
else
score -= 2;
} else if (strcmp(buff_string, NJD_SET_DIGIT_BANGOU) == 0)
score -= 2;
else if (is_period(buff_string) == 1)
score += 4;
}
}
return score;
}
static void convert_digit_sequence_for_non_numerical_reading(NJDNode * start, NJDNode * end)
{
NJDNode *node;
int size = 0;
for (node = start; node != end->next; node = node->next)
size++;
if (size <= 1)
return;
for (node = start, size = 0; node != end->next; node = node->next) {
if (strcmp(NJDNode_get_string(node), NJD_SET_DIGIT_ZERO1) == 0
|| strcmp(NJDNode_get_string(node), NJD_SET_DIGIT_ZERO2) == 0) {
NJDNode_set_pron(node, NJD_SET_DIGIT_ZERO_AFTER_DP);
NJDNode_set_mora_size(node, 2);
} else if (strcmp(NJDNode_get_string(node), NJD_SET_DIGIT_TWO) == 0) {
NJDNode_set_pron(node, NJD_SET_DIGIT_TWO_AFTER_DP);
NJDNode_set_mora_size(node, 2);
} else if (strcmp(NJDNode_get_string(node), NJD_SET_DIGIT_FIVE) == 0) {
NJDNode_set_pron(node, NJD_SET_DIGIT_FIVE_AFTER_DP);
NJDNode_set_mora_size(node, 2);
}
NJDNode_set_chain_rule(node, NULL);
if (size % 2 == 0) {
NJDNode_set_chain_flag(node, 0);
} else {
NJDNode_set_chain_flag(node, 1);
NJDNode_set_acc(node->prev, 3);
}
size++;
}
}
static void convert_digit_sequence_for_numerical_reading(NJDNode * start, NJDNode * end)
{
NJDNode *node;
NJDNode *newnode;
int digit;
int place = 0;
int index;
int size = 0;
int have = 0;
for (node = start; node != end->next; node = node->next)
size++;
if (size <= 1)
return;
index = size % 4;
if (index == 0)
index = 4;
if (size > index)
place = (size - index) / 4;
index--;
if (place > 17)
return;
for (node = start; node != end->next; node = node->next) {
digit = get_digit(node, 0);
if (index == 0) {
if (digit == 0) {
NJDNode_set_pron(node, NULL);
NJDNode_set_acc(node, 0);
NJDNode_set_mora_size(node, 0);
} else {
have = 1;
}
if (have == 1) {
if (place > 0) {
newnode = (NJDNode *) calloc(1, sizeof(NJDNode));
NJDNode_initialize(newnode);
NJDNode_load(newnode, (char *) njd_set_digit_rule_numeral_list3[place]);
node = NJDNode_insert(node, node->next, newnode);
}
have = 0;
}
place--;
} else {
if (digit <= 0) {
NJDNode_set_pron(node, NULL);
NJDNode_set_acc(node, 0);
NJDNode_set_mora_size(node, 0);
} else if (digit == 1) {
NJDNode_load(node, (char *) njd_set_digit_rule_numeral_list2[index]);
have = 1;
} else {
newnode = (NJDNode *) calloc(1, sizeof(NJDNode));
NJDNode_initialize(newnode);
NJDNode_load(newnode, (char *) njd_set_digit_rule_numeral_list2[index]);
node = NJDNode_insert(node, node->next, newnode);
have = 1;
}
}
index--;
if (index < 0)
index = 4 - 1;
}
}
static int search_numerative_class(const char *list[], NJDNode * node)
{
int i;
const char *str = NJDNode_get_string(node);
if (strcmp(str, "*") == 0)
return 0;
for (i = 0; list[i] != NULL; i++) {
if (strcmp(list[i], str) == 0)
return 1;
}
return 0;
}
static void convert_digit_pron(const char *list[], NJDNode * node)
{
int i;
const char *str = NJDNode_get_string(node);
if (strcmp(str, "*") == 0)
return;
for (i = 0; list[i] != NULL; i += 4) {
if (strcmp(list[i], str) == 0) {
NJDNode_set_pron(node, (char *) list[i + 1]);
NJDNode_set_acc(node, atoi(list[i + 2]));
NJDNode_set_mora_size(node, atoi(list[i + 3]));
return;
}
}
}
static void convert_numerative_pron(const char *list[], NJDNode * node1, NJDNode * node2)
{
int i, j;
int type = 0;
const char *str = NJDNode_get_string(node1);
char buff[MAXBUFLEN];
if (strcmp(str, "*") == 0)
return;
for (i = 0; list[i] != NULL; i += 2) {
if (strcmp(list[i], str) == 0) {
type = atoi(list[i + 1]);
break;
}
}
if (type == 1) {
for (i = 0; njd_set_digit_rule_voiced_sound_symbol_list[i] != NULL; i += 2) {
str = NJDNode_get_pron(node2);
j = strtopcmp(str, njd_set_digit_rule_voiced_sound_symbol_list[i]);
if (j >= 0) {
strcpy(buff, njd_set_digit_rule_voiced_sound_symbol_list[i + 1]);
strcat(buff, &str[j]);
NJDNode_set_pron(node2, buff);
break;
}
}
} else if (type == 2) {
for (i = 0; njd_set_digit_rule_semivoiced_sound_symbol_list[i] != NULL; i += 2) {
str = NJDNode_get_pron(node2);
j = strtopcmp(str, njd_set_digit_rule_semivoiced_sound_symbol_list[i]);
if (j >= 0) {
strcpy(buff, njd_set_digit_rule_semivoiced_sound_symbol_list[i + 1]);
strcat(buff, &str[j]);
NJDNode_set_pron(node2, buff);
break;
}
}
}
}
static void convert_digit_sequence(NJD * njd, NJDNode * s, NJDNode * e)
{
NJDNode *node;
NJDNode *final_digit_before_period = s;
int numerical_reading = 1; /* 1: numerical 0: unknown -1: non-numerical */
int num_comma = 0;
NJDNode *first_comma_before_period = NULL;
/* skip head marks */
if (s == NULL || e == NULL) {
return;
}
if (is_comma(NJDNode_get_string(s)) == 1 || is_period(NJDNode_get_string(s)) == 1) {
if (s != e)
convert_digit_sequence(njd, s->next, e);
return;
}
/* find final digit before period */
while (final_digit_before_period->next != NULL && final_digit_before_period != e &&
is_period(NJDNode_get_string(final_digit_before_period->next)) != 1) {
final_digit_before_period = final_digit_before_period->next; /* forward search */
}
while (final_digit_before_period->prev != NULL && final_digit_before_period != s &&
is_comma(NJDNode_get_string(final_digit_before_period)) == 1) {
final_digit_before_period = final_digit_before_period->prev; /* backward search */
}
/* check commas */
{
int rindex = 0;
for (rindex = 0, node = final_digit_before_period;; node = node->prev, rindex++) {
if (is_comma(NJDNode_get_string(node)) == 1) {
first_comma_before_period = node;
num_comma++;
if (numerical_reading == 1 && rindex % 4 != 3) {
numerical_reading = 0;
}
} else if (numerical_reading == 1 && rindex % 4 == 3) {
numerical_reading = 0;
}
if (node == s) {
break;
}
}
}
/* check zero-start */
if (s != final_digit_before_period && get_digit(s, 0) == 0)
numerical_reading = -1;
/* if no info, set unknown flag */
if (numerical_reading == 1 && num_comma == 0)
numerical_reading = 0;
if (numerical_reading == 1) {
/* numerical reading until period */
if (num_comma > 0) {
/* remove all commas before period */
for (node = s; node != final_digit_before_period;) {
if (is_comma(NJDNode_get_string(node)) == 1)
node = NJD_remove_node(njd, node);
else
node = node->next;
}
}
convert_digit_sequence_for_numerical_reading(s, final_digit_before_period);
if (final_digit_before_period != e)
convert_digit_sequence(njd, final_digit_before_period->next, e);
} else {
NJDNode *final_digit;
if (first_comma_before_period == NULL)
final_digit = final_digit_before_period;
else
final_digit = first_comma_before_period->prev;
if (numerical_reading == 0) {
if (get_digit_sequence_score(s, final_digit) >= 0)
numerical_reading = 1;
else
numerical_reading = -1;
}
if (numerical_reading == 1) {
/* numerical reading until comma */
convert_digit_sequence_for_numerical_reading(s, final_digit);
} else {
/* non-numerical reading */
convert_digit_sequence_for_non_numerical_reading(s, final_digit);
}
if (final_digit != e)
convert_digit_sequence(njd, final_digit->next, e);
}
}
void njd_set_digit(NJD * njd)
{
int i, j;
NJDNode *s = NULL;
NJDNode *e = NULL;
NJDNode *node;
int find = 0;
/* convert digit sequence */
for (node = njd->head; node != NULL; node = node->next) {
if (find == 0 && strcmp(NJDNode_get_pos_group1(node), NJD_SET_DIGIT_KAZU) == 0)
find = 1;
if (get_digit(node, 1) >= 0 ||
(strcmp(NJDNode_get_pos_group1(node), NJD_SET_DIGIT_KAZU) == 0 &&
(is_period(NJDNode_get_string(node)) == 1 || is_comma(NJDNode_get_string(node)) == 1)
)) {
if (s == NULL)
s = node;
if (node == njd->tail)
e = node;
} else {
if (s != NULL)
e = node->prev;
}
if (s != NULL && e != NULL) {
convert_digit_sequence(njd, s, e);
s = e = NULL;
}
}
if (find == 0)
return;
NJD_remove_silent_node(njd);
if (njd->head == NULL)
return;
for (node = njd->head->next; node != NULL && node->next != NULL;) {
if (strcmp(NJDNode_get_string(node), "*") != 0
&& strcmp(NJDNode_get_string(node->prev), "*") != 0
&& is_period(NJDNode_get_string(node)) == 1
&& strcmp(NJDNode_get_pos_group1(node->prev), NJD_SET_DIGIT_KAZU) == 0
&& strcmp(NJDNode_get_pos_group1(node->next), NJD_SET_DIGIT_KAZU) == 0) {
NJDNode_load(node, NJD_SET_DIGIT_TEN_FEATURE);
NJDNode_set_chain_flag(node, 1);
if (strcmp(NJDNode_get_string(node->prev), NJD_SET_DIGIT_ZERO1) == 0
|| strcmp(NJDNode_get_string(node->prev), NJD_SET_DIGIT_ZERO2) == 0) {
NJDNode_set_pron(node->prev, NJD_SET_DIGIT_ZERO_BEFORE_DP);
NJDNode_set_mora_size(node->prev, 2);
} else if (strcmp(NJDNode_get_string(node->prev), NJD_SET_DIGIT_TWO) == 0) {
NJDNode_set_pron(node->prev, NJD_SET_DIGIT_TWO_BEFORE_DP);
NJDNode_set_mora_size(node->prev, 2);
} else if (strcmp(NJDNode_get_string(node->prev), NJD_SET_DIGIT_FIVE) == 0) {
NJDNode_set_pron(node->prev, NJD_SET_DIGIT_FIVE_BEFORE_DP);
NJDNode_set_mora_size(node->prev, 2);
} else if (strcmp(NJDNode_get_string(node->prev), NJD_SET_DIGIT_SIX) == 0) {
NJDNode_set_acc(node->prev, 1);
}
/* skip digit sequence */
node = node->next;
while (node && strcmp(NJDNode_get_pos(node), NJD_SET_DIGIT_MEISHI) == 0)
node = node->next;
if (node)
node = node->next;
} else {
node = node->next;
}
}
for (node = njd->head->next; node != NULL; node = node->next) {
if (strcmp(NJDNode_get_pos_group1(node->prev), NJD_SET_DIGIT_KAZU) == 0) {
if (strcmp(NJDNode_get_pos_group2(node), NJD_SET_DIGIT_JOSUUSHI) == 0
|| strcmp(NJDNode_get_pos_group1(node), NJD_SET_DIGIT_FUKUSHIKANOU) == 0) {
/* convert digit pron */
if (search_numerative_class(njd_set_digit_rule_numerative_class1b, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1b, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1c1, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1c1, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1c2, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1c2, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1d, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1d, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1e, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1e, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1f, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1f, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1g, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1g, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1h, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1h, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1i, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1i, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1j, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1j, node->prev);
else if (search_numerative_class(njd_set_digit_rule_numerative_class1k, node) == 1)
convert_digit_pron(njd_set_digit_rule_conv_table1k, node->prev);
/* convert numerative pron */
if (search_numerative_class(njd_set_digit_rule_numerative_class2b, node) == 1)
convert_numerative_pron(njd_set_digit_rule_conv_table2b, node->prev, node);
else if (search_numerative_class(njd_set_digit_rule_numerative_class2c, node) == 1)
convert_numerative_pron(njd_set_digit_rule_conv_table2c, node->prev, node);
else if (search_numerative_class(njd_set_digit_rule_numerative_class2d, node) == 1)
convert_numerative_pron(njd_set_digit_rule_conv_table2d, node->prev, node);
else if (search_numerative_class(njd_set_digit_rule_numerative_class2e, node) == 1)
convert_numerative_pron(njd_set_digit_rule_conv_table2e, node->prev, node);
else if (search_numerative_class(njd_set_digit_rule_numerative_class2f, node) == 1)
convert_numerative_pron(njd_set_digit_rule_conv_table2f, node->prev, node);
/* modify accent phrase */
NJDNode_set_chain_flag(node->prev, 0);
NJDNode_set_chain_flag(node, 1);
}
}
}
for (node = njd->head->next; node != NULL; node = node->next) {
if (strcmp(NJDNode_get_pos_group1(node->prev), NJD_SET_DIGIT_KAZU) == 0) {
if (strcmp(NJDNode_get_pos_group1(node), NJD_SET_DIGIT_KAZU) == 0
&& NJDNode_get_string(node->prev) != NULL && NJDNode_get_string(node) != NULL) {
/* modify accent phrase */
find = 0;
for (i = 0; njd_set_digit_rule_numeral_list4[i] != NULL; i++) {
if (strcmp(NJDNode_get_string(node->prev), njd_set_digit_rule_numeral_list4[i]) == 0) {
for (j = 0; njd_set_digit_rule_numeral_list5[j] != NULL; j++) {
if (strcmp(NJDNode_get_string(node), njd_set_digit_rule_numeral_list5[j]) == 0) {
NJDNode_set_chain_flag(node->prev, 0);
NJDNode_set_chain_flag(node, 1);
find = 1;
break;
}
}
break;
}
}
if (find == 0) {
for (i = 0; njd_set_digit_rule_numeral_list5[i] != NULL; i++) {
if (strcmp(NJDNode_get_string(node->prev), njd_set_digit_rule_numeral_list5[i]) ==
0) {
for (j = 0; njd_set_digit_rule_numeral_list4[j] != NULL; j++) {
if (strcmp(NJDNode_get_string(node), njd_set_digit_rule_numeral_list4[j]) ==
0) {
NJDNode_set_chain_flag(node, 0);
break;
}
}
break;
}
}
}
}
if (search_numerative_class(njd_set_digit_rule_numeral_list8, node) == 1)
convert_digit_pron(njd_set_digit_rule_numeral_list9, node->prev);
if (search_numerative_class(njd_set_digit_rule_numeral_list10, node) == 1)
convert_digit_pron(njd_set_digit_rule_numeral_list11, node->prev);
if (search_numerative_class(njd_set_digit_rule_numeral_list6, node) == 1)
convert_numerative_pron(njd_set_digit_rule_numeral_list7, node->prev, node);
}
}
for (node = njd->head; node != NULL; node = node->next) {
if (node->next != NULL &&
strcmp(NJDNode_get_string(node->next), "*") != 0 &&
strcmp(NJDNode_get_pos_group1(node), NJD_SET_DIGIT_KAZU) == 0 &&
(node->prev == NULL
|| strcmp(NJDNode_get_pos(node->prev), NJD_SET_DIGIT_KIGOU) == 0
|| strcmp(NJDNode_get_pos_group1(node->prev), NJD_SET_DIGIT_KAZU) != 0)
&& (strcmp(NJDNode_get_pos_group2(node->next), NJD_SET_DIGIT_JOSUUSHI) == 0
|| strcmp(NJDNode_get_pos_group1(node->next), NJD_SET_DIGIT_FUKUSHIKANOU) == 0)) {
/* convert class3 */
for (i = 0; njd_set_digit_rule_numerative_class3[i] != NULL; i += 2) {
if (strcmp(NJDNode_get_string(node->next), njd_set_digit_rule_numerative_class3[i]) == 0
&& strcmp(NJDNode_get_read(node->next),
njd_set_digit_rule_numerative_class3[i + 1]) == 0) {
for (j = 0; njd_set_digit_rule_conv_table3[j] != NULL; j += 4) {
if (strcmp(NJDNode_get_string(node), njd_set_digit_rule_conv_table3[j]) == 0) {
NJDNode_set_read(node, (char *) njd_set_digit_rule_conv_table3[j + 1]);
NJDNode_set_pron(node, (char *) njd_set_digit_rule_conv_table3[j + 1]);
NJDNode_set_acc(node, atoi(njd_set_digit_rule_conv_table3[j + 2]));
NJDNode_set_mora_size(node, atoi(njd_set_digit_rule_conv_table3[j + 3]));
break;
}
}
break;
}
}
/* person */
if (strcmp(NJDNode_get_string(node->next), NJD_SET_DIGIT_NIN) == 0) {
for (i = 0; njd_set_digit_rule_conv_table4[i] != NULL; i += 2) {
if (strcmp(NJDNode_get_string(node), njd_set_digit_rule_conv_table4[i]) == 0) {
NJDNode_load(node, (char *) njd_set_digit_rule_conv_table4[i + 1]);
NJDNode_set_pron(node->next, NULL);
break;
}
}
}
/* the day of month */
if (strcmp(NJDNode_get_string(node->next), NJD_SET_DIGIT_NICHI) == 0
&& strcmp(NJDNode_get_string(node), "*") != 0) {
if (node->prev != NULL
&& strstr(NJDNode_get_string(node->prev), NJD_SET_DIGIT_GATSU) != NULL
&& strcmp(NJDNode_get_string(node), NJD_SET_DIGIT_ONE) == 0) {
NJDNode_load(node, NJD_SET_DIGIT_TSUITACHI);
NJDNode_set_pron(node->next, NULL);
} else {
for (i = 0; njd_set_digit_rule_conv_table5[i] != NULL; i += 2) {
if (strcmp(NJDNode_get_string(node), njd_set_digit_rule_conv_table5[i]) == 0) {
NJDNode_load(node, (char *) njd_set_digit_rule_conv_table5[i + 1]);
NJDNode_set_pron(node->next, NULL);
break;
}
}
}
} else if (strcmp(NJDNode_get_string(node->next), NJD_SET_DIGIT_NICHIKAN) == 0) {
for (i = 0; njd_set_digit_rule_conv_table6[i] != NULL; i += 2) {
if (strcmp(NJDNode_get_string(node), njd_set_digit_rule_conv_table6[i]) == 0) {
NJDNode_load(node, (char *) njd_set_digit_rule_conv_table6[i + 1]);
NJDNode_set_pron(node->next, NULL);
break;
}
}
}
}
}
for (node = njd->head; node != NULL; node = node->next) {
if ((node->prev == NULL
|| strcmp(NJDNode_get_pos_group1(node->prev), NJD_SET_DIGIT_KAZU) != 0)
&& node->next != NULL && node->next->next != NULL) {
if (strcmp(NJDNode_get_string(node), NJD_SET_DIGIT_TEN) == 0
&& strcmp(NJDNode_get_string(node->next), NJD_SET_DIGIT_FOUR) == 0) {
if (strcmp(NJDNode_get_string(node->next->next), NJD_SET_DIGIT_NICHI) == 0) {
NJDNode_load(node, NJD_SET_DIGIT_JUYOKKA);
NJDNode_set_pron(node->next, NULL);
NJDNode_set_pron(node->next->next, NULL);
} else if (strcmp(NJDNode_get_string(node->next->next), NJD_SET_DIGIT_NICHIKAN) == 0) {
NJDNode_load(node, NJD_SET_DIGIT_JUYOKKAKAN);
NJDNode_set_pron(node->next, NULL);
NJDNode_set_pron(node->next->next, NULL);
}
} else if (strcmp(NJDNode_get_string(node), NJD_SET_DIGIT_TWO) == 0
&& strcmp(NJDNode_get_string(node->next), NJD_SET_DIGIT_TEN) == 0) {
if (strcmp(NJDNode_get_string(node->next->next), NJD_SET_DIGIT_NICHI) == 0) {
NJDNode_load(node, NJD_SET_DITIT_HATSUKA);
NJDNode_set_pron(node->next, NULL);
NJDNode_set_pron(node->next->next, NULL);
} else if (strcmp(NJDNode_get_string(node->next->next), NJD_SET_DIGIT_NICHIKAN) == 0) {
NJDNode_load(node, NJD_SET_DIGIT_HATSUKAKAN);
NJDNode_set_pron(node->next, NULL);
NJDNode_set_pron(node->next->next, NULL);
} else if (strcmp(NJDNode_get_string(node->next->next), NJD_SET_DIGIT_FOUR) == 0
&& node->next->next->next != NULL) {
if (strcmp(NJDNode_get_string(node->next->next->next), NJD_SET_DIGIT_NICHI) == 0) {
NJDNode_load(node, NJD_SET_DIGIT_NIJU);
NJDNode_load(node->next, NJD_SET_DITIT_YOKKA);
NJDNode_set_pron(node->next->next, NULL);
NJDNode_set_pron(node->next->next->next, NULL);
} else if (strcmp(NJDNode_get_string(node->next->next->next), NJD_SET_DIGIT_NICHIKAN)
== 0) {
NJDNode_load(node, NJD_SET_DIGIT_NIJU);
NJDNode_load(node->next, NJD_SET_DIGIT_YOKKAKAN);
NJDNode_set_pron(node->next->next, NULL);
NJDNode_set_pron(node->next->next->next, NULL);
}
}
}
}
}
NJD_remove_silent_node(njd);
if (njd->head == NULL)
return;
}
NJD_SET_DIGIT_C_END;
#endif /* !NJD_SET_DIGIT_C */ | c |
src/lib/support/state/@hold/EclipseStateMachine.h | eirTony/EIRC2 | 0 | 6913903 | #ifndef ECLIPSESTATEMACHINE_H
#define ECLIPSESTATEMACHINE_H
#include "StateLib.h"
#include "AbstraceStateMachine.h"
#include <base/BasicId.h>
#include <base/BasicName.h>
//#include "MachineBuilder.h"
#include "StateMachineConfiguration.h"
#define ECLIPSE_MACHINESTATES(NPF) /* name, parent, flags */ \
NPF(Extant, this, Initial) \
NPF(Active, this, Parent) \
NPF(Initialized, Active, Initial) \
NPF(Ready, Active, 0) \
NPF(Running, Active, 0) \
NPF(Working, Active, 0) \
NPF(Inactive, Active, Final) \
NPF(Final, this, Final) \
class STATESHARED_EXPORT EclipseStateMachine : public AbstractStateMachine
{
Q_OBJECT
// STATEMACHINE_DECLARESTATES(ECLIPSE_MACHINESTATES)
// STATEMACHINE_DECLAREKEYS(ECLIPSE_MACHINESTATES)
public:
explicit EclipseStateMachine(QObject * parent=0);
virtual bool initialize(const BasicName::VariantMap init
=BasicName::VariantMap());
virtual bool configure(const StateMachineConfiguration & config
=StateMachineConfiguration());
void setExitCode(const int code);
signals:
void active(void);
void terminating(void);
void terminated(void);
public slots:
void start(void);
void terminate(void);
void terminate(const int exitCode);
private slots:
void enterFinal(void);
private:
int mExitCode = 0;
};
#endif // ECLIPSESTATEMACHINE_H | c |
src/type_num.c | chkoreff/Fexl | 32 | 3941367 | #include <stdint.h>
#include <str.h>
#include <value.h>
#include <basic.h>
#include <convert.h>
#include <format.h>
#include <memory.h>
#include <type_num.h>
#include <type_str.h>
static void num_free(double *p)
{
free_memory(p,sizeof(double));
}
value type_num(value f)
{
return type_atom(f);
}
value Qnum(double x)
{
static struct value atom = {0, (type)num_free};
double *p = new_memory(sizeof(double));
*p = x;
return V(type_num,&atom,(value)p);
}
value Qnum_str0(const char *name)
{
double x;
if (str0_double(name,&x))
return Qnum(x);
else
return 0;
}
double get_double(value x)
{
return *((double *)x->R);
}
unsigned long get_ulong(value x)
{
double n = get_double(x);
return n >= 0 ? n : 0;
}
value type_num_str(value f)
{
if (!f->L) return 0;
{
value x = arg(f->R);
if (x->T == type_num)
f = Qstr(str_new_data0(format_double(get_double(x))));
else
f = hold(Qvoid);
drop(x);
return f;
}
}
value type_is_num(value f)
{
return op_is_type(f,type_num);
} | c |
include/alieninvadersretro/MainWindowHeader.h | MatthewAlgo/AlienInvadersRetroBuild | 2 | 4946895 | #pragma once
#ifndef MAIN_WINDOW_HEADER_H
# define MAIN_WINDOW_HEADER_H
# pragma region INCLUDES
# include <SFML/Audio.hpp>
# include <SFML/Graphics.hpp>
# include <SFML/System.hpp>
# include <SFML/Window.hpp>
# include <functional>
# include <iostream>
# include <string>
# include <thread>
# include "VirtualWindow.h"
# pragma endregion INCLUDES
# define U_P std::unique_ptr
# pragma region CLASS_REGION
namespace MatthewsNamespace {
class MainWindowClass : public virtual MatthewsNamespace::VirtualWindowClass {
private:
sf::Font GlobalWindowFont;
sf::Text GreetingText, TextBTN1, TextBTN2;
ImageToBeDrawn MenuBox1, MenuBox2, MenuBox3;
std::unique_ptr<ImageToBeDrawn> WindowTitleTextbox;
// Variables related to the textures and design elements
public:
MainWindowClass(const std::string TITLE, int W, int H) : VirtualWindowClass(TITLE, W, H){};
~MainWindowClass() = default; // Auto deallocate smart pointers
void MainWindowThreadExecution(
TripleItemHolder<sf::RenderWindow, sf::Thread, VirtualWindowClass>& ITEM_HOLDER) override;
void DrawInsideMainWindow(sf::RenderWindow* WINDOW, sf::Thread* WINTHREAD,
VirtualWindowClass* C) override;
void RenderTextures(
DoubleItemHolder<sf::RenderWindow, VirtualWindowClass> ITEM_HOLDER) override;
};
}; // namespace MatthewsNamespace
# pragma endregion CLASS_REGION
#endif | c |
components/viz/common/resources/release_callback.h | zealoussnow/chromium | 14,668 | 3944538 | // Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_VIZ_COMMON_RESOURCES_RELEASE_CALLBACK_H_
#define COMPONENTS_VIZ_COMMON_RESOURCES_RELEASE_CALLBACK_H_
#include "base/callback.h"
namespace gpu {
struct SyncToken;
} // namespace gpu
namespace viz {
// The callback type used to return ownership of a resource.
// The |sync_token| is a synchronization point that should be waited for before
// using the resource. Failing to do so may cause corruption as the resource may
// still be being acted on by the system releasing ownership until that point.
// When |is_lost| is true, the resource is declared as unable to be returned,
// and the receiver of this callback may not reliably reuse the resource and
// guarantee any correctness. The receiver of this callback may only delete the
// resource when |is_lost| is set.
using ReleaseCallback =
base::OnceCallback<void(const gpu::SyncToken& sync_token, bool is_lost)>;
} // namespace viz
#endif // COMPONENTS_VIZ_COMMON_RESOURCES_RELEASE_CALLBACK_H_ | c |
System/Library/PrivateFrameworks/Silex.framework/SXComponentController.h | lechium/iOS1351Headers | 2 | 8293435 | /*
* This header is generated by classdump-dyld 1.5
* on Wednesday, October 27, 2021 at 3:16:45 PM Mountain Standard Time
* Operating System: Version 13.5.1 (Build 17F80)
* Image Source: /System/Library/PrivateFrameworks/Silex.framework/Silex
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by <NAME>. Updated by <NAME>.
*/
#import <Silex/Silex-Structs.h>
#import <libobjc.A.dylib/SXViewportChangeListener.h>
#import <libobjc.A.dylib/SXComponentController.h>
@class SXLayoutBlueprint, NSArray;
@protocol SXComponentController <SXAXAssistiveTechStatusChangeListener>
@property (nonatomic,readonly) SXLayoutBlueprint * presentedBlueprint;
@property (nonatomic,readonly) NSArray * flattenedComponentViews;
@property (nonatomic,readonly) BOOL isPresented;
@required
-(void)addObserver:(id)arg1;
-(void)removeObserver:(id)arg1;
-(BOOL)isPresented;
-(id)componentsInRect:(CGRect)arg1;
-(id)componentViewForPoint:(CGPoint)arg1;
-(id)componentViewsForRole:(int)arg1;
-(id)componentViewForIdentifier:(id)arg1;
-(SXLayoutBlueprint *)presentedBlueprint;
-(NSArray *)flattenedComponentViews;
@end
#import <libobjc.A.dylib/SXLayoutIntegrator.h>
@protocol SXComponentHosting, SXComponentViewEngine, SXDOMObjectProviding;
@class SXLayoutBlueprint, NSArray, SXViewport, NSHashTable, NSMutableDictionary, NSMutableArray, SXPresentationAttributes, NSString;
@interface SXComponentController : NSObject <SXViewportChangeListener, SXComponentController, SXLayoutIntegrator> {
BOOL _isPresented;
BOOL _isPresenting;
SXLayoutBlueprint* _presentedBlueprint;
NSArray* _flattenedComponentViews;
id<SXComponentHosting> _host;
SXViewport* _viewport;
id<SXComponentViewEngine> _componentViewEngine;
id<SXDOMObjectProviding> _DOMObjectProvider;
NSHashTable* _observers;
NSMutableDictionary* _mappedComponentViews;
NSMutableArray* _sortedComponentViews;
NSMutableArray* _nestedComponentViews;
SXPresentationAttributes* _presentationAttributes;
}
@property (nonatomic,readonly) SXViewport * viewport; //@synthesize viewport=_viewport - In the implementation block
@property (nonatomic,readonly) id<SXComponentViewEngine> componentViewEngine; //@synthesize componentViewEngine=_componentViewEngine - In the implementation block
@property (nonatomic,readonly) id<SXDOMObjectProviding> DOMObjectProvider; //@synthesize DOMObjectProvider=_DOMObjectProvider - In the implementation block
@property (nonatomic,readonly) NSHashTable * observers; //@synthesize observers=_observers - In the implementation block
@property (nonatomic,retain) NSMutableDictionary * mappedComponentViews; //@synthesize mappedComponentViews=_mappedComponentViews - In the implementation block
@property (nonatomic,retain) NSMutableArray * sortedComponentViews; //@synthesize sortedComponentViews=_sortedComponentViews - In the implementation block
@property (nonatomic,retain) NSMutableArray * nestedComponentViews; //@synthesize nestedComponentViews=_nestedComponentViews - In the implementation block
@property (assign,nonatomic) BOOL isPresenting; //@synthesize isPresenting=_isPresenting - In the implementation block
@property (nonatomic,readonly) SXPresentationAttributes * presentationAttributes; //@synthesize presentationAttributes=_presentationAttributes - In the implementation block
@property (assign,nonatomic,__weak) id<SXComponentHosting> host; //@synthesize host=_host - In the implementation block
@property (readonly) unsigned long long hash;
@property (readonly) Class superclass;
@property (copy,readonly) NSString * description;
@property (copy,readonly) NSString * debugDescription;
@property (nonatomic,readonly) SXLayoutBlueprint * presentedBlueprint; //@synthesize presentedBlueprint=_presentedBlueprint - In the implementation block
@property (nonatomic,readonly) NSArray * flattenedComponentViews; //@synthesize flattenedComponentViews=_flattenedComponentViews - In the implementation block
@property (nonatomic,readonly) BOOL isPresented; //@synthesize isPresented=_isPresented - In the implementation block
-(id<SXComponentHosting>)host;
-(void)addObserver:(id)arg1 ;
-(void)removeObserver:(id)arg1 ;
-(void)setHost:(id<SXComponentHosting>)arg1 ;
-(SXViewport *)viewport;
-(NSHashTable *)observers;
-(BOOL)isPresenting;
-(BOOL)isPresented;
-(SXPresentationAttributes *)presentationAttributes;
-(void)assistiveTechnologyStatusDidChange;
-(id)componentsInRect:(CGRect)arg1 ;
-(id)componentViewForPoint:(CGPoint)arg1 ;
-(id)componentViewsForRole:(int)arg1 ;
-(id)componentViewForIdentifier:(id)arg1 ;
-(SXLayoutBlueprint *)presentedBlueprint;
-(NSArray *)flattenedComponentViews;
-(id<SXDOMObjectProviding>)DOMObjectProvider;
-(void)viewport:(id)arg1 dynamicBoundsDidChangeFromBounds:(CGRect)arg2 ;
-(void)viewport:(id)arg1 boundsDidChangeFromBounds:(CGRect)arg2 ;
-(void)viewport:(id)arg1 appearStateChangedFromState:(unsigned long long)arg2 ;
-(id)initWithViewport:(id)arg1 componentViewEngine:(id)arg2 DOMObjectProvider:(id)arg3 ;
-(void)integrateBlueprint:(id)arg1 withCompletion:(/*^block*/id)arg2 ;
-(void)provideInfosLayoutTo:(id)arg1 ;
-(id)componentViews;
-(void)setIsPresenting:(BOOL)arg1 ;
-(NSMutableArray *)nestedComponentViews;
-(void)removeComponentsInLayoutBlueprint:(id)arg1 removedFromLayoutBlueprint:(id)arg2 ;
-(void)presentBlueprint:(id)arg1 forParentComponentView:(id)arg2 inHost:(id)arg3 ;
-(void)presentComponentsInBlueprint:(id)arg1 ;
-(void)updateVisibilityStatesForComponentViews:(id)arg1 ;
-(void)updatePresentationStateForNestedComponentViews:(id)arg1 presentationState:(long long)arg2 ;
-(void)fadeComponent:(id)arg1 completion:(/*^block*/id)arg2 ;
-(void)updatePresentationStateForNestedComponentView:(id)arg1 presentationState:(long long)arg2 ;
-(void)renderContentsIfNeededForComponents:(id)arg1 ;
-(id)presentComponentBlueprint:(id)arg1 inHost:(id)arg2 columnLayout:(id)arg3 ;
-(void)setNestedComponentViews:(NSMutableArray *)arg1 ;
-(NSMutableDictionary *)mappedComponentViews;
-(id<SXComponentViewEngine>)componentViewEngine;
-(NSMutableArray *)sortedComponentViews;
-(id)componentViewForPoint:(CGPoint)arg1 inComponents:(id)arg2 ;
-(id)componentViewsForRole:(int)arg1 forLayoutBlueprint:(id)arg2 ;
-(void)updateVisibilityStatesForComponentViews:(id)arg1 toState:(long long)arg2 ;
-(CGRect)renderBounds;
-(void)updateVisibilityStatesForComponentViews:(id)arg1 parentComponent:(id)arg2 withOffset:(CGPoint)arg3 ;
-(void)setMappedComponentViews:(NSMutableDictionary *)arg1 ;
-(void)setSortedComponentViews:(NSMutableArray *)arg1 ;
@end | c |
Engine/Include/ComponentSlot.h | AdamSzentesiGrip/MiniECS | 0 | 940933 | #pragma once
namespace Mini
{
struct ComponentSlot
{
public:
bool IsOccupied;
int ComponentIndex;
};
} | c |
shell.h | tartunian/TivaNetworkTester | 0 | 3476210 | /*
* shell.h
*
* Created on: Nov 28, 2021
* Author: tartunian
*/
#ifndef SHELL_H_
#define SHELL_H_
#include <stdint.h>
typedef uint8_t (*command_func_t)(uint8_t, char**);
typedef struct command_t {
char* command_str;
command_func_t func;
char* command_desc;
} command_t;
extern command_t command_table[];
uint8_t parseIPv4(char*, uint8_t*);
void addCommand(command_t);
uint8_t parseCommand(char*, command_t*, char**);
uint8_t getCommandCount();
#endif /* SHELL_H_ */ | c |
Raven.CppClient/AdvancedSessionOperations.h | maximburyak/ravendb-cpp-client | 0 | 4304233 | #pragma once
#include "DocumentSessionImpl.h"
#include "DocumentsChanges.h"
#include "EagerSessionOperations.h"
namespace ravendb::client::documents::session
{
class AdvancedSessionOperations
{
public:
friend class DocumentSession;
private:
std::shared_ptr<DocumentSessionImpl> _session_impl;
explicit AdvancedSessionOperations(std::shared_ptr<DocumentSessionImpl> session_impl);
public:
~AdvancedSessionOperations();
operations::lazy::LazySessionOperations lazily();
operations::lazy::EagerSessionOperations eagerly();
std::reference_wrapper<IDocumentStore> get_document_store() const;
std::unordered_map<std::string, std::shared_ptr<void>>& get_external_state() const;
//TODO ServerNode get_current_session_node() const;
std::shared_ptr<http::RequestExecutor> get_request_executor() const;
bool has_changes() const;
int32_t get_max_number_of_requests_per_session() const;
void set_max_number_of_requests_per_session(int32_t max_requests);
int32_t get_number_of_requests() const;
std::string store_identifier() const;
bool is_use_optimistic_concurrency() const;
void set_use_optimistic_concurrency(bool use_optimistic_concurrency);
void clear();
void defer(const std::vector<std::shared_ptr<commands::batches::CommandDataBase>>& commands);
template<typename T>
void evict(std::shared_ptr<T> entity);
template<typename T>
std::optional<std::string> get_document_id(std::shared_ptr<T> entity);
template<typename T>
std::shared_ptr<IMetadataDictionary> get_metadata_for(std::shared_ptr<T> entity) const;
template<typename T>
std::optional<std::string> get_change_vector_for(std::shared_ptr<T> entity) const;
//TODO template<typename T> std::shared_ptr<IMetadataDictionary> get_counters_for(std::shared_ptr<T> entity)
template<typename T>
std::optional<impl::DateTimeOffset> get_last_modified_for(std::shared_ptr<T> entity) const;
template<typename T>
bool has_changed(std::shared_ptr<T> entity) const;
bool is_loaded(const std::string& id) const;
template<typename T>
void ignore_changes_for(std::shared_ptr<T> entity);
std::unordered_map<std::string, std::vector<DocumentsChanges>> what_changed();
//TODO void wait_for_replication_after_save_changes();
//TODO void wait_for_indexes_after_save_changes();
void set_transaction_mode(TransactionMode mode);
const EntityToJson& get_entity_to_json() const;
template<typename T>
std::shared_ptr<RawDocumentQuery<T>> raw_query(const std::string& query);
template<typename T, typename V>
void patch(std::shared_ptr<T> entity, const std::string& path, const V& value,
std::optional<DocumentInfo::EntityUpdater> update_from_json = {});
template<typename V>
void patch(const std::string& id, const std::string& path, const V& value);
template<typename V>
void patch(const std::string& id, const std::string& path, const V& value,
const DocumentInfo::EntityUpdater& update_from_json);
template<typename T, typename U>
void patch(std::shared_ptr<T> entity, const std::string& path_to_array,
std::function<void(JavaScriptArray<U>&)> array_adder,
std::optional<DocumentInfo::EntityUpdater> update_from_json = {});
template<typename U>
void patch(const std::string& id, const std::string& path_to_array,
const std::function<void(JavaScriptArray<U>&)>& array_adder);
template<typename U>
void patch(const std::string& id, const std::string& path_to_array,
const std::function<void(JavaScriptArray<U>&)>& array_adder,
const DocumentInfo::EntityUpdater& update_from_json);
template<typename T, typename V>
void increment(std::shared_ptr<T> entity, const std::string& path, const V& value_to_add,
std::optional<DocumentInfo::EntityUpdater> update_from_json = {});
template<typename V>
void increment(const std::string& id, const std::string& path, const V& value_to_add);
template<typename V>
void increment(const std::string& id, const std::string& path, const V& value_to_add,
const DocumentInfo::EntityUpdater& update_from_json);
template<typename T>
std::shared_ptr<IDocumentQuery<T, DocumentQuery<T>>> document_query(
std::optional<std::string> index_name,
std::optional<std::string> collection_name,
bool is_map_reduced);
};
template <typename T>
void AdvancedSessionOperations::evict(std::shared_ptr<T> entity)
{
_session_impl->evict(entity);
}
template <typename T>
std::optional<std::string> AdvancedSessionOperations::get_document_id(std::shared_ptr<T> entity)
{
return _session_impl->get_document_id(entity);
}
template <typename T>
std::shared_ptr<IMetadataDictionary> AdvancedSessionOperations::get_metadata_for(std::shared_ptr<T> entity) const
{
return _session_impl->get_metadata_for(entity);
}
template <typename T>
std::optional<std::string> AdvancedSessionOperations::get_change_vector_for(std::shared_ptr<T> entity) const
{
return _session_impl->get_change_vector_for(entity);
}
template <typename T>
std::optional<impl::DateTimeOffset> AdvancedSessionOperations::get_last_modified_for(
std::shared_ptr<T> entity) const
{
return _session_impl->get_last_modified_for(entity);
}
template <typename T>
bool AdvancedSessionOperations::has_changed(std::shared_ptr<T> entity) const
{
return _session_impl->has_changed(entity);
}
template <typename T>
void AdvancedSessionOperations::ignore_changes_for(std::shared_ptr<T> entity)
{
_session_impl->ignore_changes_for(entity);
}
template <typename T>
std::shared_ptr<RawDocumentQuery<T>> AdvancedSessionOperations::raw_query(const std::string& query)
{
return _session_impl->raw_query<T>(query);
}
template <typename T, typename V>
void AdvancedSessionOperations::patch(std::shared_ptr<T> entity, const std::string& path, const V& value,
std::optional<DocumentInfo::EntityUpdater> update_from_json)
{
auto&& metadata = _session_impl->get_metadata_for(entity);
auto id = std::any_cast<std::string>(metadata->get_dictionary().at(constants::documents::metadata::ID));
patch(std::move(id), path, value,
update_from_json ? std::move(update_from_json).value() : DocumentInfo::default_entity_update<T>);
}
template <typename V>
void AdvancedSessionOperations::patch(const std::string& id, const std::string& path, const V& value)
{
_session_impl->patch(id, path, value, {});
}
template <typename T, typename U>
void AdvancedSessionOperations::patch(std::shared_ptr<T> entity, const std::string& path_to_array,
std::function<void(JavaScriptArray<U>&)> array_adder,
std::optional<DocumentInfo::EntityUpdater> update_from_json)
{
auto&& metadata = _session_impl->get_metadata_for(entity);
auto id = std::any_cast<std::string>(metadata->get_dictionary().at(constants::documents::metadata::ID));
patch(std::move(id), path_to_array, array_adder,
update_from_json ? std::move(update_from_json).value() : DocumentInfo::default_entity_update<T>);
}
template <typename U>
void AdvancedSessionOperations::patch(const std::string& id, const std::string& path_to_array,
const std::function<void(JavaScriptArray<U>&)>& array_adder)
{
_session_impl->patch(id, path_to_array, array_adder, {});
}
template <typename U>
void AdvancedSessionOperations::patch(const std::string& id, const std::string& path_to_array,
const std::function<void(JavaScriptArray<U>&)>& array_adder,
const DocumentInfo::EntityUpdater& update_from_json)
{
if (!update_from_json)
{
throw std::invalid_argument("'update_from_json' should have a target");
}
_session_impl->patch(id, path_to_array, array_adder, update_from_json);
}
template <typename V>
void AdvancedSessionOperations::patch(const std::string& id, const std::string& path, const V& value,
const DocumentInfo::EntityUpdater& update_from_json)
{
if (!update_from_json)
{
throw std::invalid_argument("'update_from_json' should have a target");
}
_session_impl->patch(id, path, value, update_from_json);
}
template <typename T, typename V>
void AdvancedSessionOperations::increment(std::shared_ptr<T> entity, const std::string& path, const V& value_to_add,
std::optional<DocumentInfo::EntityUpdater> update_from_json)
{
auto&& metadata = _session_impl->get_metadata_for(entity);
auto id = std::any_cast<std::string>(metadata->get_dictionary().at(constants::documents::metadata::ID));
increment(std::move(id), path, value_to_add,
update_from_json ? std::move(update_from_json).value() : DocumentInfo::default_entity_update<T>);
}
template <typename V>
void AdvancedSessionOperations::increment(const std::string& id, const std::string& path, const V& value_to_add)
{
_session_impl->increment(id, path, value_to_add, {});
}
template <typename V>
void AdvancedSessionOperations::increment(const std::string& id, const std::string& path, const V& value_to_add,
const DocumentInfo::EntityUpdater& update_from_json)
{
if (!update_from_json)
{
throw std::invalid_argument("'update_from_json' should have a target");
}
_session_impl->increment(id, path, value_to_add, update_from_json);
}
template <typename T>
std::shared_ptr<IDocumentQuery<T, DocumentQuery<T>>> AdvancedSessionOperations::document_query(
std::optional<std::string> index_name,
std::optional<std::string> collection_name,
bool is_map_reduced)
{
return _session_impl->document_query<T>(std::move(index_name), std::move(collection_name), is_map_reduced);
}
} | c |
v2.1/src/Common/getpass.c | oldbitpusher/npasswd | 0 | 2699802 | /*
* Copyright 1998, The University of Texas at Austin ("U. T. Austin").
* All rights reserved.
*
* By using this software the USER indicates that he or she has read,
* understood and will comply with the following:
*
* U. T. Austin hereby grants USER permission to use, copy, modify, and
* distribute this software and its documentation for any purpose and
* without fee, provided that:
*
* 1. the above copyright notice appears in all copies of the software
* and its documentation, or portions thereof, and
* 2. a full copy of this notice is included with the software and its
* documentation, or portions thereof, and
* 3. neither the software nor its documentation, nor portions thereof,
* is sold for profit. Any commercial sale or license of this software,
* copies of the software, its associated documentation and/or
* modifications of either is strictly prohibited without the prior
* consent of U. T. Austin.
*
* Title to copyright to this software and its associated documentation
* shall at all times remain with U. T. Austin. No right is granted to
* use in advertising, publicity or otherwise any trademark, service
* mark, or the name of U. T. Austin.
*
* This software and any associated documentation are provided "as is,"
* and U. T. AUSTIN MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESSED OR
* IMPLIED, INCLUDING THOSE OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR
* PURPOSE, OR THAT USE OF THE SOFTWARE, MODIFICATIONS, OR ASSOCIATED
* DOCUMENTATION WILL NOT INFRINGE ANY PATENTS, COPYRIGHTS, TRADEMARKS OR
* OTHER INTELLECTUAL PROPERTY RIGHTS OF A THIRD PARTY. U. T. Austin, The
* University of Texas System, its Regents, officers, and employees shall
* not be liable under any circumstances for any direct, indirect, special,
* incidental, or consequential damages with respect to any claim by USER
* or any third party on account of or arising from the use, or inability
* to use, this software or its associated documentation, even if U. T.
* Austin has been advised of the possibility of those damages.
*
* Submit commercialization requests to: Office of the Executive Vice
* President and Provost, U. T. Austin, 201 Main Bldg., Austin, Texas,
* 78712, ATTN: Technology Licensing Specialist.
*/
/*
* Routines to deal with passwords.
*/
#include "npasswd.h"
#include "pw_svc.h"
#ifndef lint
static char sccsid[] = "$Id: getpass.c,v 1.7 1998/11/17 00:00:00 clyde Exp $ (cc.utexas.edu) %P%";
#endif
/*
* Configuration settings
*/
Config_Value int PasswdMatchTries = PASSWORD_MATCH_TRIES;
Config_Value unsigned int PasswdMatchWait = PASSWORD_MATCH_WAIT;
/*
* get_password
* Read password from user and compare to present
*
* Effects:
* Stores matching plaintext password in <pwd_plain> buffer
*/
public void
get_password(prompt, pwd_crypt, pwd_plain, pwd_psize)
char *prompt, /* Prompt string */
*pwd_crypt, /* Present password (encrypted) */
*pwd_plain; /* New password (plain) */
int pwd_psize; /* Size of pwd_plain */
{
int ntries = 0; /* Attempt counter */
char *pwtemp; /* Password read temp */
for (;;) {
if ((pwtemp = np_getpass(prompt)) == NULL)
die("Password unmatched.\n");
if (*pwtemp == '\0')
continue;
if (password_cmp(pwd_crypt, pwtemp) == 0) {
printf("Password incorrect.\n");
if (PasswdMatchWait > 0)
sleep(PasswdMatchWait);
if (++ntries == PasswdMatchTries) {
if (PasswdMatchWait > 0)
(void) sleep(PasswdMatchWait);
die("Password not matched.\n");
}
continue;
}
break;
}
(void) strncpy(pwd_plain, pwtemp, pwd_psize);
}
/*
* password_cmp
* Compare old and new passwords
*
* Returns:
* 1 if match
* 0 if not
*/
public
password_cmp(current, check)
char *current, /* Current password (encrypted) */
*check; /* Password to compare (plain) */
{
struct pw_svc *svc = get_pwsvc(); /* Passwd service */
if (*current == 0) /* Null password */
return(1);
return (strcmp(current, (*svc->PasswdCrypt)(check, current)) == 0);
}
/*
* np_getpass
* Replacement for libc getpass(3)
* Usage:
* pass = np_getpass(prompt);
* Returns:
* Password string
* NULL if EOF encountered or error
* Comments:
* This routine is used instead of getpass(3):
*
* 1. The system getpass() throws away all but the first 8 characters
* of a password string. On some systems passwords can be longer
* than 8, but getpass(3) hasn't caught up yet.
*
* 2. getpass(3) returns a empty string if the user input was empty
* (blank line), or the /dev/tty read got an EOF or error.
* There *is* a difference between those conditions and I really
* want to know it and behave accordingly. Why make a user
* start over again if they hit RETURN one time too many?
*
* 3. The SunOS 4 getpass(3) returns an empty string if the user
* sent a SIGNIT (control-c). This is stupid behavior.
*
* This code assumes that stdin is the terminal (which has been
* verified upstream), so /dev/tty is NOT used.
* Signals are caught and terminal modes reset upstream.
*/
#define PROMPT_FD 2 /* File descriptor for prompts */
public char *
np_getpass(prompt)
char *prompt; /* Prompt string */
{
struct sigblk blocked; /* Blocked signals */
static char ib[64]; /* Input buffer */
int nr; /* Terminal read return */
ib[0] = 0;
if (XSwitches[Xsw_UseStdin] == 0) { /* Stdin is a tty */
term_echo(0);
(void) write(PROMPT_FD, prompt, strlen(prompt));
block_signals(&blocked, SIGTSTP, 0);
nr = term_read(ib, sizeof(ib));
term_echo(1);
(void) write(PROMPT_FD, "\n", 1);
unblock_signals(&blocked);
} else {
nr = term_read(ib, sizeof(ib));
}
if (nr <= 0) /* EOF or error */
return(NULL);
chop_nl(ib); /* Pitch newline at end */
return(ib);
}
#undef PROMPT_FD
/* End $RCSfile: getpass.c,v $ */ | c |
src/UIImageView.h | mulle-kybernetik-tv/MulleUIKit | 2 | 4171727 | //
// Copyright (c) 2020 Nat!, <NAME>
//
#ifdef __has_include
# if __has_include( "UIView.h")
# import "UIView.h"
# endif
#endif
#import "import.h"
@class UIImage;
@interface UIImageView : UIView
- (instancetype) initWithImage:(UIImage *) image;
@end | c |
System/Library/PrivateFrameworks/WorkflowUI.framework/WFGlyphPickerTabBar.h | zhangkn/iOS14Header | 1 | 1389874 | /*
* This header is generated by classdump-dyld 1.0
* on Sunday, September 27, 2020 at 12:27:04 PM Mountain Standard Time
* Operating System: Version 14.0 (Build 18A373)
* Image Source: /System/Library/PrivateFrameworks/WorkflowUI.framework/WorkflowUI
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by <NAME>.
*/
#import <UIKitCore/UIView.h>
#import <UIKit/UITabBarDelegate.h>
@protocol WFGlyphPickerTabBarDelegate;
@class UITabBar, NSString;
@interface WFGlyphPickerTabBar : UIView <UITabBarDelegate> {
unsigned long long _selectedTabIndex;
id<WFGlyphPickerTabBarDelegate> _delegate;
UITabBar* _tabBar;
}
@property (assign,nonatomic,__weak) UITabBar * tabBar; //@synthesize tabBar=_tabBar - In the implementation block
@property (assign,nonatomic) unsigned long long selectedTabIndex; //@synthesize selectedTabIndex=_selectedTabIndex - In the implementation block
@property (assign,nonatomic,__weak) id<WFGlyphPickerTabBarDelegate> delegate; //@synthesize delegate=_delegate - In the implementation block
@property (readonly) unsigned long long hash;
@property (readonly) Class superclass;
@property (copy,readonly) NSString * description;
@property (copy,readonly) NSString * debugDescription;
-(UITabBar *)tabBar;
-(void)setTabBar:(UITabBar *)arg1 ;
-(void)setDelegate:(id<WFGlyphPickerTabBarDelegate>)arg1 ;
-(void)tabBar:(id)arg1 didSelectItem:(id)arg2 ;
-(id<WFGlyphPickerTabBarDelegate>)delegate;
-(id)initWithTabNames:(id)arg1 tabCharacters:(id)arg2 ;
-(void)setSelectedTabIndex:(unsigned long long)arg1 ;
-(unsigned long long)selectedTabIndex;
@end | c |
include/il2cpp/System/Threading/ThreadAbortException.h | martmists-gh/BDSP | 1 | 3327438 | #pragma once
#include "il2cpp.h"
void System_Threading_ThreadAbortException___ctor (System_Threading_ThreadAbortException_o* __this, const MethodInfo* method_info);
void System_Threading_ThreadAbortException___ctor (System_Threading_ThreadAbortException_o* __this, System_Runtime_Serialization_SerializationInfo_o* info, System_Runtime_Serialization_StreamingContext_o context, const MethodInfo* method_info); | c |
src/backend/prioritize.h | Jelinek-J/INSPiRE | 2 | 7120232 | #pragma once
#include "features.h"
#include <map>
namespace inspire {
namespace backend {
class Prioritizer {
public:
virtual void prioritize(std::string input, std::string output) = 0;
};
class LinearPrioritizer : public Prioritizer {
private:
double relative;
double absolute;
double distance;
double coefficient;
public:
LinearPrioritizer(double relative, double absolute, double distance) {
this->relative = relative;
this->absolute = absolute;
this->distance = distance;
this->coefficient = 1/(absolute+relative+distance);
}
void prioritize(std::string input, std::string output) override {
if (output.empty() || output.back() == common::filesystem::directory_separator) {
size_t i = input.rfind(common::filesystem::directory_separator);
std::string tmp = (i == input.npos ? input : input.substr(i+1));
if (common::string::ends_with(tmp, ".sas")) {
output += tmp.substr(0, tmp.size()-4);
} else {
output += tmp;
}
output += ".pot";
} else if (!common::string::ends_with(output, ".pot")) {
output += ".pot";
}
std::ifstream reader(input);
std::ofstream writer(output);
std::string line;
if (!std::getline(reader, line)) {
throw common::exception::TitledException("Input file '" + input + "' is empty.");
}
std::vector<std::string> headers;
{
std::stringstream parts(line);
while (std::getline(parts,line,':')) {
headers.push_back(line);
}
}
std::string id;
while (std::getline(reader, id)) {
double distance = 0;
std::vector<size_t> counts(headers.size(), 0);
while (std::getline(reader, line) && line.size() > 0) {
std::stringstream parts(line);
std::string level;
if (!std::getline(parts, level, '\t')) {
throw common::exception::TitledException("Unexpected exception during parsing line '" + line + "' for residue #" + id + ".");
}
std::string count;
long long sum = 0;
for (size_t i = 0; i < counts.size(); i++) {
if (!std::getline(parts, count, ':')) {
throw common::exception::TitledException("Incomplete line '" + line + "' for residue #" + id + ": missing numbers.");
}
long cnt = std::stol(count);
sum += cnt;
counts[i] += cnt;
}
// Consider unclassified as optional
if (std::getline(parts, count, ':') && std::getline(parts, count, ':')) {
throw common::exception::TitledException("Invalid line '" + line + "' for residue #" + id + ": too many numbers.");
}
distance += std::stol(level) * sum;
}
{
long long count = 0;
for (size_t i = 0; i < counts.size(); i++) {
count += counts[i];
}
double score = count == 0 ? 0 : this->coefficient*(this->relative*counts[0]/(double)count + this->absolute*(1-1.0/(1+counts[0])) + this->distance/(1+distance/(double)count));
writer << id << '\t' << score << '\n';
}
}
reader.close();
writer.flush();
writer.close();
}
};
}
} | c |
sys/lpc11xx/gps/test/test.c | JJPowelly/u8glib | 1,209 | 6544422 | #include "pq.h"
#include <stdio.h>
#include <assert.h>
pq_t pq_obj;
void test_float(pq_t *pq)
{
gps_float_t f;
pq_Init(pq);
pq_AddStr(pq, "$123.456$");
pq_ResetParser(pq);
pq_GetNext(pq);
pq_GetFloat(pq, &f);
printf("%lf\n", (double)f);
}
void test_str(pq_t *pq)
{
pq_Init(pq);
pq_AddStr(pq, "$ABC$");
pq_ResetParser(pq);
printf("%s\n", pq_GetStr(pq));
}
void test_gprmc(pq_t *pq)
{
pq_Init(pq);
pq_AddStr(pq, "$GPRMC,220516, A,5133.82,N,00042.24 ,W,173.8,231.8,130694,004.2,W*70$");
//pq_AddStr(pq, "$GPRMC,191525,V ,4764.0450,N,00918.3670,E,0.0 ,0.0 ,180409,0.4, E");
//pq_AddStr(pq, "$GPRMC,000204.036,V , , , ,0.00 ,0.00 ,060180,,,X*99$");
pq_ResetParser(pq);
printf("%s\n", pq_GetStr(pq));
if ( pq_ParseGPRMC(pq) == 0 )
{
printf("$GPRMC Error\n");
}
else
{
printf("Latitude: %lf\n", (double)pq->interface.pos.latitude);
printf("Magnet Variation: %lf\n", (double)pq->interface.magnetic_variation);
}
}
void test_gprmc2(pq_t *pq)
{
pq_Init(pq);
pq_AddStr(pq, "$GPRMC,000204.036,V,,,,,0.00,0.00,060180,,,X*99$");
pq_ResetParser(pq);
printf("%s\n", pq_GetStr(pq));
if ( pq_ParseGPRMC(pq) == 0 )
{
printf("2: $GPRMC Error\n");
}
else
{
printf("Latitude: %lf\n", (double)pq->interface.pos.latitude);
printf("Magnet Variation: %lf\n", (double)pq->interface.magnetic_variation);
}
}
void test_gpgga(pq_t *pq)
{
pq_Init(pq);
pq_AddStr(pq, "$GPGGA,191410,4735.5634,N,00739.3538,E,1,04,4.4,351.5,M,48.0,M,,*45$");
pq_ResetParser(pq);
printf("%s\n", pq_GetStr(pq));
if ( pq_ParseGPGGA(pq) == 0 )
{
printf("$GPGGA Error\n");
}
else
{
char s[16];
pg_FloatToDegreeMinutes(pq, pq->interface.pos.latitude);
pg_DegreeMinutesToStr(pq, 1, s);
printf("Latitude: %lf %s\n", (double)pq->interface.pos.latitude, s);
printf("GPS Quality: %d\n", (int)pq->gps_quality);
printf("sat_cnt: %d\n", (int)pq->sat_cnt);
}
}
void test_sentence(pq_t *pq)
{
pq_Init(pq);
pq_AddStr(pq, "$GPRMC,220516,A,5133.82,N,00042.24,W,173.8,231.8,130694,004.2,W*70");
assert ( crb_IsSentenceAvailable(&(pq->crb)) == 0 );
pq_AddStr(pq, "$GPRMC,220516,A,1234.56,N,00042.24,W,173.8,231.8,130694,004.2,W*70");
assert ( crb_IsSentenceAvailable(&(pq->crb)) != 0 );
pq_AddStr(pq, "$GPRMC,220516,A,1234.56,N,00042.24,W,173.8,231.8,130694,004.2,W*70");
assert ( crb_IsSentenceAvailable(&(pq->crb)) != 0 );
pq_ResetParser(pq);
if ( pq_ParseSentence(pq) == 0 )
{
printf("Sentence Error\n");
}
else
{
printf("Latitude: %lf\n", (double)pq->interface.pos.latitude);
printf("Magnet Variation: %lf\n", (double)pq->interface.magnetic_variation);
}
pq_ResetParser(pq);
if ( pq_ParseSentence(pq) == 0 )
{
printf("Sentence Error\n");
}
else
{
printf("Latitude: %lf\n", (double)pq->interface.pos.latitude);
printf("Magnet Variation: %lf\n", (double)pq->interface.magnetic_variation);
}
assert ( crb_IsSentenceAvailable(&(pq->crb)) == 0 );
printf("entry cnt: %d\n", pq->cnt);
printf("Latitude of latest entry: %lf\n", (double)pq_GetLatestEntry(pq)->pos.latitude);
}
int main(void)
{
test_gprmc2(&pq_obj);
test_gpgga(&pq_obj);
test_sentence(&pq_obj);
test_gprmc(&pq_obj);
test_str(&pq_obj);
test_float(&pq_obj);
} | c |
Telegram-2.8/Telegraph/legacy/TL/TL/TLRPCphone_confirmCall.h | DZamataev/TelegramAppKit | 3 | 6129726 | #import <Foundation/Foundation.h>
#import "TLObject.h"
#import "TLMetaRpc.h"
@class TLInputPhoneCall;
@class TLPhoneConnection;
@interface TLRPCphone_confirmCall : TLMetaRpc
@property (nonatomic, retain) TLInputPhoneCall *n_id;
@property (nonatomic, retain) NSData *a_or_b;
- (Class)responseClass;
- (int)impliedResponseSignature;
@end
@interface TLRPCphone_confirmCall$phone_confirmCall : TLRPCphone_confirmCall
@end | c |
libs/signature/src/param_list.c | liutong-cnu/rocketmq-client-cpp | 314 | 1273607 | /*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <string.h>
#include "spas_client.h"
#ifdef __cplusplus
namespace rocketmqSignature {
#endif
extern void *_mem_alloc(unsigned int size);
extern void _mem_free(void *ptr);
static int _nodecmp(SPAS_PARAM_NODE *n1, SPAS_PARAM_NODE *n2) {
int ret = strcmp(n1->name, n2->name);
if (ret == 0) {
ret = strcmp(n1->value, n2->value);
}
return ret;
}
SPAS_PARAM_LIST *create_param_list() {
return (SPAS_PARAM_LIST *)_mem_alloc(sizeof(SPAS_PARAM_LIST));
}
void free_param_list(SPAS_PARAM_LIST *list) {
SPAS_PARAM_NODE *pnode = NULL;
SPAS_PARAM_NODE *pnext = NULL;
if (list == NULL) {
return;
}
pnode = list->phead;
while (pnode != NULL) {
pnext = pnode->pnext;
_mem_free(pnode->name);
_mem_free(pnode->value);
_mem_free(pnode);
pnode = pnext;
}
_mem_free(list);
}
int add_param_to_list(SPAS_PARAM_LIST *list, const char *name,
const char *value) {
SPAS_PARAM_NODE *pnode = NULL;
SPAS_PARAM_NODE *plast = NULL;
int nlen = 0;
int vlen = 0;
if (list == NULL || name == NULL || value == NULL) {
return ERROR_INVALID_PARAM;
}
nlen = strlen(name);
vlen = strlen(value);
pnode = (SPAS_PARAM_NODE *)_mem_alloc(sizeof(SPAS_PARAM_NODE));
if (pnode == NULL) {
return ERROR_MEM_ALLOC;
}
pnode->name = (char *)_mem_alloc(nlen + 1);
if (pnode->name == NULL) {
_mem_free(pnode);
return ERROR_MEM_ALLOC;
}
pnode->value = (char *)_mem_alloc(vlen + 1);
if (pnode->value == NULL) {
_mem_free(pnode->name);
_mem_free(pnode);
return ERROR_MEM_ALLOC;
}
memcpy(pnode->name, name, nlen);
memcpy(pnode->value, value, vlen);
if (list->phead == NULL) {
list->phead = pnode;
} else if (_nodecmp(pnode, list->phead) <= 0) {
pnode->pnext = list->phead;
list->phead = pnode;
} else {
plast = list->phead;
while (plast->pnext != NULL) {
if (_nodecmp(pnode, plast->pnext) <= 0) {
pnode->pnext = plast->pnext;
plast->pnext = pnode;
break;
} else {
plast = plast->pnext;
}
}
if (plast->pnext == NULL) {
plast->pnext = pnode;
}
}
list->length++;
list->size += nlen + vlen + 1; /* 1 overhead for '=' */
return SPAS_NO_ERROR;
}
char *param_list_to_str(const SPAS_PARAM_LIST *list) {
int size = 0;
int pos = 0;
char *buf = NULL;
SPAS_PARAM_NODE *pnode = NULL;
if (list == NULL) {
return NULL;
}
if (list->length == 0) {
return (char *)_mem_alloc(1);
}
size = list->size + list->length - 1; /* overhead for '&' */
buf = (char *)_mem_alloc(size);
if (buf == NULL) {
return NULL;
}
pnode = list->phead;
if (pnode != NULL) {
sprintf(buf, "%s=%s", pnode->name, pnode->value);
pos += strlen(pnode->name) + strlen(pnode->value) + 1;
pnode = pnode->pnext;
}
while (pnode != NULL) {
sprintf(buf + pos, "&%s=%s", pnode->name, pnode->value);
pos += strlen(pnode->name) + strlen(pnode->value) + 2;
pnode = pnode->pnext;
}
return buf;
}
#ifdef __cplusplus
}
#endif | c |
c++Project/lib/Qt/5.8/gcc_64/include/Qt3DQuick/qt3dquickversion.h | mattlas/Computer-Vision | 1 | 4211462 | /* This file was generated by syncqt. */
#ifndef QT_QT3DQUICK_VERSION_H
#define QT_QT3DQUICK_VERSION_H
#define QT3DQUICK_VERSION_STR "5.8.0"
#define QT3DQUICK_VERSION 0x050800
#endif // QT_QT3DQUICK_VERSION_H | c |
src/cc/eval.h | sg777/chips | 5 | 5407664 | #ifndef CC_EVAL_H
#define CC_EVAL_H
#include <cryptoconditions.h>
#include "chain.h"
#include "streams.h"
#include "version.h"
#include "consensus/validation.h"
#include "primitives/transaction.h"
/*
* Eval codes
*
* Add to below macro to generate new code.
*
* If at some point a new interpretation model is introduced,
* there should be a code identifying it. For example,
* a possible code is EVAL_BITCOIN_SCRIPT, where the entire binary
* after the code is interpreted as a bitcoin script.
*/
#define FOREACH_EVAL(EVAL) \
EVAL(EVAL_IMPORTPAYOUT, 0xe1)
typedef uint8_t EvalCode;
class AppVM;
class NotarisationData;
class Eval
{
public:
CValidationState state;
bool Invalid(std::string s) { return state.Invalid(false, 0, s); }
bool Error(std::string s) { return state.Error(s); }
bool Valid() { return true; }
/*
* Test validity of a CC_Eval node
*/
virtual bool Dispatch(const CC *cond, const CTransaction &tx, unsigned int nIn);
/*
* Dispute a payout using a VM
*/
bool DisputePayout(AppVM &vm, std::vector<uint8_t> params, const CTransaction &disputeTx, unsigned int nIn);
/*
* Test an ImportPayout CC Eval condition
*/
bool ImportPayout(std::vector<uint8_t> params, const CTransaction &importTx, unsigned int nIn);
/*
* IO functions
*/
virtual bool GetTxUnconfirmed(const uint256 &hash, CTransactionRef &txOut, uint256 &hashBlock) const;
virtual bool GetTxConfirmed(const uint256 &hash, CTransactionRef &txOut, CBlockIndex &block) const;
virtual unsigned int GetCurrentHeight() const;
virtual bool GetSpendsConfirmed(uint256 hash, std::vector<CTransactionRef> &spends) const;
virtual bool GetBlock(uint256 hash, CBlockIndex& blockIdx) const;
virtual int32_t GetNotaries(uint8_t pubkeys[64][33], int32_t height, uint32_t timestamp) const;
virtual bool GetNotarisationData(uint256 notarisationHash, NotarisationData &data) const;
virtual bool CheckNotaryInputs(const CTransaction &tx, uint32_t height, uint32_t timestamp) const;
};
bool RunCCEval(const CC *cond, const CTransaction &tx, unsigned int nIn);
/*
* Virtual machine to use in the case of on-chain app evaluation
*/
class AppVM
{
public:
/*
* in: header - paramters agreed upon by all players
* in: body - gamestate
* out: length - length of game (longest wins)
* out: payments - vector of CTxOut, always deterministically sorted.
*/
virtual std::pair<int,std::vector<CTxOut>>
evaluate(std::vector<unsigned char> header, std::vector<unsigned char> body) = 0;
};
/*
* Data from notarisation OP_RETURN
*/
class NotarisationData {
public:
uint256 blockHash;
uint32_t height;
uint256 txHash; // Only get this guy in asset chains not in KMD
char symbol[64];
uint256 MoM;
uint32_t MoMDepth;
bool Parse(CScript scriptPubKey);
};
/*
* Eval code utilities.
*/
#define EVAL_GENERATE_DEF(L,I) const uint8_t L = I;
#define EVAL_GENERATE_STRING(L,I) if (c == I) return #L;
FOREACH_EVAL(EVAL_GENERATE_DEF);
std::string EvalToStr(EvalCode c);
/*
* Serialisation boilerplate
*/
#define E_MARSHAL(body) SerializeF([&] (CDataStream &ss) {body;})
template <class T>
std::vector<uint8_t> SerializeF(const T f)
{
CDataStream ss(SER_NETWORK, PROTOCOL_VERSION);
f(ss);
return std::vector<unsigned char>(ss.begin(), ss.end());
}
#define E_UNMARSHAL(params, body) DeserializeF(params, [&] (CDataStream &ss) {body;})
template <class T>
bool DeserializeF(const std::vector<unsigned char> vIn, T f)
{
CDataStream ss(vIn, SER_NETWORK, PROTOCOL_VERSION);
try {
f(ss);
if (ss.eof()) return true;
} catch(...) {}
return false;
}
#endif /* CC_EVAL_H */ | c |
rc4.h | sbourdeauducq/rt2571w | 4 | 3538675 | /*
Ralink RT2501 driver for Violet embedded platforms
(c) 2006 <NAME>
*/
#ifndef _RC4_H
#define _RC4_H_
struct rc4_context {
unsigned int x;
unsigned int y;
unsigned char state[256];
};
void rc4_init(struct rc4_context *rc4, const unsigned char *key, unsigned int length);
unsigned char rc4_byte(struct rc4_context *rc4);
void rc4_cipher(struct rc4_context *rc4, unsigned char *out,
const unsigned char *in, unsigned int length);
#endif /* _RC4_H_ */ | c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.