Rizin
unix-like reverse engineering framework and cli tools
Functions | Variables
hashtable.c File Reference
#include "ins.h"
#include "hashvector.h"
#include <rz_types.h>

Go to the source code of this file.

Functions

st32 get_hashfunc_01 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_02 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_03 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_04 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_05 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_06 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_07 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_08 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_09 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_10 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_11 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_12 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_13 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_14 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_15 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_16 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_17 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_18 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_19 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_20 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_21 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_22 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_23 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_24 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_25 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_26 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_27 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_28 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_29 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_30 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_31 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_32 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_33 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_34 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_35 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_36 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_37 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_38 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_39 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_40 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_41 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_42 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_43 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_44 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_45 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_46 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_47 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_48 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_49 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_50 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_51 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_52 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_53 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_54 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_55 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_56 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_57 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_58 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_59 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_60 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_61 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_62 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_63 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_64 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_65 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_66 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_67 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_68 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_69 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_70 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_71 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_72 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_73 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_74 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_75 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_76 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_77 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_78 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_79 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_80 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_81 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_82 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_83 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_84 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_85 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_86 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_87 (st32 arg1, st32 v2)
 
st32 get_hashfunc_88 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_89 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_90 (st32 arg1, st32 arg2)
 
st32 get_hashfunc_91 (st32 arg1, st32 arg2)
 
st32 get_hash_code (ut32 ins_pos)
 

Variables

static const st32 hash_const_01 = 0x2474f685
 
static const st32 hash_const_02 = 0x42fbc0b8
 
static const st32 hash_const_03 = 0x086a18eb
 
static const st32 hash_const_04 = 0x001d02e8
 
static const st32 hash_const_05 = 0
 
ut8 * ins_buff
 
ut32 ins_buff_len
 
static HASHCODE_ENTRY_T ins_hash []
 

Function Documentation

◆ get_hash_code()

st32 get_hash_code ( ut32  ins_pos)

Definition at line 2801 of file hashtable.c.

2801  {
2802  ut32 len, ins_part1;
2803  ut32 opcode, pos;
2804  st32 (*get_hashcode_func)(st32 arg, st32 arg2);
2805  ut32 ins_len;
2806  st32 arg, ins_part2, hash_code;
2807 
2808  ins_part1 = 0;
2809  ins_part2 = 0;
2810 
2811  opcode = get_ins_part(ins_pos, 1);
2812  ins_len = get_ins_len(opcode);
2813 
2814  if (C55PLUS_DEBUG) {
2815  printf("opcode: 0x%x part: %d\n", opcode, ins_pos);
2816  printf("ins_len: 0x%x\n", ins_len);
2817  }
2818 
2819  if (ins_len > 1) {
2820  len = ins_len - 1;
2821  if (len >= 4) {
2822  len = 4;
2823  }
2824 
2825  ins_part1 = get_ins_part(ins_pos + 1, len) << (8 * (4 - len));
2826  ins_part2 = 0;
2827  if (ins_len > 5) {
2828  ins_part2 = get_ins_part(ins_pos + 5, 1);
2829  }
2830  }
2831 
2832  pos = (2 * opcode | (ins_part1 >> 31));
2833  // arg = *(ut32 *)(((ut8 *)ins_hash)+ pos * 8);
2834  arg = ins_hash[pos].code;
2835 
2836  ins_part2 >>= 7;
2837  ins_part2 |= (ins_part1 * 2);
2838 
2839  // get_hashcode_func = *(ut32 *)(((ut8 *)ins_hash + sizeof(ut32)) + pos * 8);
2840  get_hashcode_func = ins_hash[pos].hash_func;
2841 
2842  if (C55PLUS_DEBUG) {
2843  printf("hashfunc => %p 0x%x\n", get_hashcode_func, pos);
2844  printf("hashargs => 0x%x 0x%x 0x%x\n", (ut32)arg, ins_part1, ins_part2);
2845  }
2846 
2847  hash_code = get_hashcode_func(arg, ins_part2);
2848  if (C55PLUS_DEBUG) {
2849  printf("ret hashcode: 0x%x\n", hash_code);
2850  }
2851 
2852  return hash_code;
2853 }
len
size_t len
Definition: 6502dis.c:15
get_ins_len
ut32 get_ins_len(ut8 opcode)
Definition: ins.c:11
arg
static const char * arg(RzAnalysis *a, csh *handle, cs_insn *insn, char *buf, int n)
Definition: arm_esil32.c:136
printf
_Use_decl_annotations_ int __cdecl printf(const char *const _Format,...)
Definition: cs_driver.c:93
ut32
uint32_t ut32
Definition: demangler_util.h:31
ins_hash
static HASHCODE_ENTRY_T ins_hash[]
Definition: hashtable.c:2285
get_ins_part
ut32 get_ins_part(ut32 pos, ut32 len)
Definition: ins.c:51
C55PLUS_DEBUG
#define C55PLUS_DEBUG
Definition: utils.h:8
st32
#define st32
Definition: rz_types_base.h:12
HASHCODE_ENTRY_T::code
st32 code
Definition: hashvector.h:10
HASHCODE_ENTRY_T::hash_func
st32(* hash_func)(st32 A1, st32 A2)
Definition: hashvector.h:11
pos
int pos
Definition: main.c:11

References arg(), C55PLUS_DEBUG, HASHCODE_ENTRY_T::code, get_ins_len(), get_ins_part(), HASHCODE_ENTRY_T::hash_func, ins_hash, len, pos, printf(), and st32.

Referenced by do_decode().

◆ get_hashfunc_01()

st32 get_hashfunc_01 ( st32  arg1,
st32  arg2 
)

Definition at line 17 of file hashtable.c.

17  {
18  return arg1;
19 }

◆ get_hashfunc_02()

st32 get_hashfunc_02 ( st32  arg1,
st32  arg2 
)

Definition at line 21 of file hashtable.c.

21  {
22  char v4 = 0;
23  st32 v2 = arg2 & 0xFE000000;
24  if ((arg2 & 0xFE000000u) > 0x72000000) {
25  if ((ut32)v2 <= 0xD8000000) {
26  if (v2 != 0xd8000000) {
27  if ((ut32)v2 > 0xC4000000) {
28  if ((ut32)v2 > 0xCE000000) {
29  if ((ut32)v2 > 0xD4000000) {
30  if (v2 == -704643072) {
31  return 95;
32  }
33  return arg1;
34  }
35  if (v2 != -738197504 && v2 != -805306368) {
36  if (v2 == -771751936) {
37  return 95;
38  }
39  return arg1;
40  }
41  } else {
42  if (v2 != -838860800) {
43  if ((ut32)v2 > 0xCA000000) {
44  if (v2 == -872415232) {
45  return 95;
46  }
47  return arg1;
48  }
49  if (v2 != -905969664 && v2 != -973078528) {
50  if (v2 == -939524096) {
51  return 95;
52  }
53  return arg1;
54  }
55  }
56  }
57  } else {
58  if (v2 != -1006632960) {
59  if ((ut32)v2 <= 0x7E000000) {
60  if (v2 != 2113929216) {
61  if ((ut32)v2 > 0x78000000) {
62  if (v2 != 2046820352 && v2 != 2080374784) {
63  return arg1;
64  }
65  } else {
66  if (v2 != 2013265920 && v2 != 1946157056) {
67  if (v2 == 1979711488) {
68  return 226;
69  }
70  return arg1;
71  }
72  }
73  }
74  return 226;
75  }
76  if ((ut32)v2 > 0xC0000000) {
77  if (v2 == -1040187392) {
78  return 95;
79  }
80  return arg1;
81  }
82  if (v2 != 0xC0000000) {
83  if (v2 == -1610612736) {
84  return 540;
85  }
86  if (v2 == -1577058304) {
87  return 541;
88  }
89  return arg1;
90  }
91  }
92  }
93  }
94  return 95;
95  }
96  if ((ut32)v2 > 0xEC000000) {
97  if ((ut32)v2 > 0xF6000000) {
98  if ((ut32)v2 > 0xFC000000) {
99  if (v2 != -33554432) {
100  return arg1;
101  }
102  return 96;
103  }
104  if (v2 == -67108864 || v2 == -134217728) {
105  return 96;
106  }
107  v4 = v2 == -100663296;
108  } else {
109  if (v2 == -167772160) {
110  return 96;
111  }
112  if ((ut32)v2 > 0xF2000000) {
113  v4 = v2 == -201326592;
114  } else {
115  if (v2 == -234881024 || v2 == -301989888) {
116  return 96;
117  }
118  v4 = v2 == -268435456;
119  }
120  }
121  } else {
122  if (v2 == -335544320) {
123  return 96;
124  }
125  if ((ut32)v2 > 0xE2000000) {
126  if ((ut32)v2 > 0xE8000000) {
127  v4 = v2 == -369098752;
128  } else {
129  if (v2 == -402653184 || v2 == -469762048) {
130  return 96;
131  }
132  v4 = v2 == -436207616;
133  }
134  } else {
135  if (v2 == -503316480) {
136  return 96;
137  }
138  if ((ut32)v2 <= 0xDE000000) {
139  if (v2 != -570425344 && v2 != -637534208 && v2 != -603979776) {
140  return arg1;
141  }
142  return 95;
143  }
144  v4 = v2 == -536870912;
145  }
146  }
147  if (!v4) {
148  return arg1;
149  }
150  return 96;
151  }
152  if ((arg2 & 0xFE000000) == 1912602624) {
153  return 226;
154  }
155  if ((ut32)v2 > 0x48000000) {
156  if ((ut32)v2 <= 0x5E000000) {
157  if (v2 != 1577058304) {
158  if ((ut32)v2 > 0x54000000) {
159  if ((ut32)v2 > 0x5A000000) {
160  if (v2 != 1543503872) {
161  return arg1;
162  }
163  } else {
164  if (v2 != 1509949440 && v2 != 1442840576) {
165  if (v2 == 1476395008) {
166  return 178;
167  }
168  return arg1;
169  }
170  }
171  } else {
172  if (v2 != 1409286144) {
173  if ((ut32)v2 > 0x4E000000) {
174  if (v2 != 1342177280) {
175  if (v2 == 1375731712) {
176  return 178;
177  }
178  return arg1;
179  }
180  } else {
181  if (v2 != 1308622848 && v2 != 1241513984) {
182  if (v2 == 1275068416) {
183  return 178;
184  }
185  return arg1;
186  }
187  }
188  }
189  }
190  }
191  return 178;
192  }
193  if ((ut32)v2 > 0x68000000) {
194  if ((ut32)v2 > 0x6E000000) {
195  if (v2 == 1879048192) {
196  return 226;
197  }
198  return arg1;
199  }
200  if (v2 != 1845493760 && v2 != 1778384896) {
201  if (v2 == 1811939328) {
202  return 226;
203  }
204  return arg1;
205  }
206  } else {
207  if (v2 != 1744830464) {
208  if ((ut32)v2 > 0x64000000) {
209  if (v2 == 1711276032) {
210  return 226;
211  }
212  return arg1;
213  }
214  if (v2 != 1677721600 && v2 != 1610612736) {
215  if (v2 == 1644167168) {
216  return 226;
217  }
218  return arg1;
219  }
220  }
221  }
222  return 226;
223  }
224  if (v2 == 1207959552) {
225  return 178;
226  }
227  if ((ut32)v2 <= 0x14000000) {
228  if (v2 != 335544320) {
229  if ((ut32)v2 > 0xA000000) {
230  if ((ut32)v2 > 0x10000000) {
231  if (v2 == 301989888) {
232  return 142;
233  }
234  return arg1;
235  }
236  if (v2 != 268435456 && v2 != 201326592) {
237  if (v2 == 234881024) {
238  return 142;
239  }
240  return arg1;
241  }
242  } else {
243  if (v2 != 167772160) {
244  if ((ut32)v2 > 0x4000000) {
245  if (v2 != 100663296) {
246  if (v2 == 134217728) {
247  return 142;
248  }
249  return arg1;
250  }
251  } else {
252  if (v2 != 67108864 && v2) {
253  if (v2 == 33554432) {
254  return 142;
255  }
256  return arg1;
257  }
258  }
259  }
260  }
261  }
262  return 142;
263  }
264  if ((ut32)v2 > 0x1E000000) {
265  if ((ut32)v2 > 0x44000000) {
266  if (v2 == 1174405120) {
267  return 178;
268  }
269  return arg1;
270  }
271  if (v2 != 1140850688 && v2 != 0x40000000) {
272  if (v2 == 1107296256) {
273  return 178;
274  }
275  return arg1;
276  }
277  return 178;
278  }
279  if (v2 == 503316480) {
280  return 142;
281  }
282  if ((ut32)v2 <= 0x1A000000) {
283  if (v2 != 436207616 && v2 != 369098752) {
284  if (v2 == 402653184) {
285  return 142;
286  }
287  return arg1;
288  }
289  return 142;
290  }
291  if (v2 == 469762048) {
292  return 142;
293  }
294  return arg1;
295 }

References st32.

◆ get_hashfunc_03()

st32 get_hashfunc_03 ( st32  arg1,
st32  arg2 
)

Definition at line 297 of file hashtable.c.

297  {
298  st32 v2 = arg2 & 0xE0000000;
299  if ((arg2 & 0xE0000000u) <= 0x80000000) {
300  if ((arg2 & 0xE0000000) == 0x80000000) {
301  return 102;
302  }
303  if (!v2) {
304  return 485;
305  }
306  if (v2 == 536870912) {
307  return 486;
308  }
309  return arg1;
310  }
311  if (v2 != 0xA0000000) {
312  return arg1;
313  }
314  return 475;
315 }

References st32.

◆ get_hashfunc_04()

st32 get_hashfunc_04 ( st32  arg1,
st32  arg2 
)

Definition at line 317 of file hashtable.c.

317  {
318  st32 result;
319 
320  if (arg2 & 0x80000000) {
321  if ((arg2 & 0x80000000) == 0x80000000) {
322  result = 99;
323  } else {
324  result = arg1;
325  }
326  } else {
327  result = 100;
328  }
329  return result;
330 }

References st32.

◆ get_hashfunc_05()

st32 get_hashfunc_05 ( st32  arg1,
st32  arg2 
)

Definition at line 332 of file hashtable.c.

332  {
333  st32 result;
334 
335  if (arg2 & 0x80000000) {
336  if ((arg2 & 0x80000000) == 0x80000000) {
337  result = 97;
338  } else {
339  result = arg1;
340  }
341  } else {
342  result = 98;
343  }
344  return result;
345 }

References st32.

◆ get_hashfunc_06()

st32 get_hashfunc_06 ( st32  arg1,
st32  arg2 
)

Definition at line 347 of file hashtable.c.

347  {
348  st32 result;
349 
350  if (arg2 & 0x80000000) {
351  if ((st32)(arg2 & 0x80000000) == 0x80000000) {
352  result = 228;
353  } else {
354  result = arg1;
355  }
356  } else {
357  result = 227;
358  }
359  return result;
360 }

References st32.

◆ get_hashfunc_07()

st32 get_hashfunc_07 ( st32  arg1,
st32  arg2 
)

Definition at line 362 of file hashtable.c.

362  {
363  st32 result;
364 
365  if (arg2 & 0x80000000) {
366  if ((arg2 & 0x80000000) == 0x80000000) {
367  result = 52;
368  } else {
369  result = arg1;
370  }
371  } else {
372  result = 140;
373  }
374  return result;
375 }

References st32.

◆ get_hashfunc_08()

st32 get_hashfunc_08 ( st32  arg1,
st32  arg2 
)

Definition at line 377 of file hashtable.c.

377  {
378  st32 tmp;
379 
380  tmp = arg2 & 0xC0000000;
381  if ((arg2 & 0xC0000000u) <= 0x80000000) {
382  if ((arg2 & 0xC0000000) == 0x80000000) {
383  return 87;
384  }
385  if (!tmp) {
386  return 85;
387  }
388  if (tmp == 0x40000000) {
389  return 86;
390  }
391  return arg1;
392  }
393  if (tmp != 0xC0000000) {
394  return arg1;
395  }
396  return 88;
397 }
autogen_x86imm.tmp
tmp
Definition: autogen_x86imm.py:12

References st32, and autogen_x86imm::tmp.

◆ get_hashfunc_09()

st32 get_hashfunc_09 ( st32  arg1,
st32  arg2 
)

Definition at line 399 of file hashtable.c.

399  {
400  st32 v2;
401 
402  v2 = arg2 & 0xC0000000;
403  if ((arg2 & 0xC0000000u) <= 0x80000000) {
404  if ((arg2 & 0xC0000000) == 0x80000000) {
405  return 91;
406  }
407  if (!v2) {
408  return 89;
409  }
410  if (v2 == 0x40000000) {
411  return 90;
412  }
413  return arg1;
414  }
415  if (v2 != 0xC0000000) {
416  return arg1;
417  }
418  return 92;
419 }

References st32.

◆ get_hashfunc_10()

st32 get_hashfunc_10 ( st32  arg1,
st32  arg2 
)

Definition at line 421 of file hashtable.c.

421  {
422  st32 v2;
423  st32 v3;
424 
425  v2 = arg2;
426  v3 = v2 & 0x500000;
427  if ((ut32)v3 <= 0x400000) {
428  if (v3 == 4194304) {
429  return 247;
430  }
431  if (!v3) {
432  return 245;
433  }
434  if (v3 == 1048576) {
435  return 249;
436  }
437  return arg1;
438  }
439  if (v3 != 5242880) {
440  return arg1;
441  }
442  return 248;
443 }

References st32.

◆ get_hashfunc_11()

st32 get_hashfunc_11 ( st32  arg1,
st32  arg2 
)

Definition at line 445 of file hashtable.c.

445  {
446 #if 0
447  // The following code is wrong because it will always produce 244
448  // since `hash_const_05` is always 0 and as result it will always
449  // jump into the else scope.
450  // The code is kept because this is the product of RE.
451  st32 result;
452 
453  if ((ut32)hash_const_05 & arg2) {
454  if (((ut32)hash_const_05 & arg2) == 524288) {
455  result = 460;
456  } else {
457  result = arg1;
458  }
459  } else {
460  result = 244;
461  }
462  return result;
463 #endif
464  return 244;
465 }
hash_const_05
static const st32 hash_const_05
Definition: hashtable.c:12

References hash_const_05, and st32.

◆ get_hashfunc_12()

st32 get_hashfunc_12 ( st32  arg1,
st32  arg2 
)

Definition at line 467 of file hashtable.c.

467  {
468  st32 tmp;
469  st32 v3;
470  st32 result;
471 
472  tmp = arg2;
473  v3 = tmp & 0x400000;
474  if (v3) {
475  if (v3 == 4194304) {
476  result = 521;
477  } else {
478  result = arg1;
479  }
480  } else {
481  result = 374;
482  }
483  return result;
484 }

References st32, and autogen_x86imm::tmp.

◆ get_hashfunc_13()

st32 get_hashfunc_13 ( st32  arg1,
st32  arg2 
)

Definition at line 486 of file hashtable.c.

486  {
487  st32 result;
488 
489  if (arg2 & 0x1000000) {
490  if ((arg2 & 0x1000000) == 16777216) {
491  result = 30;
492  } else {
493  result = arg1;
494  }
495  } else {
496  result = 32;
497  }
498  return result;
499 }

References st32.

◆ get_hashfunc_14()

st32 get_hashfunc_14 ( st32  arg1,
st32  arg2 
)

Definition at line 501 of file hashtable.c.

501  {
502  st32 result;
503 
504  if (arg2 & 0x1000000) {
505  if ((arg2 & 0x1000000) == 0x1000000) {
506  result = 61;
507  } else {
508  result = arg1;
509  }
510  } else {
511  result = 60;
512  }
513  return result;
514 }

References st32.

◆ get_hashfunc_15()

st32 get_hashfunc_15 ( st32  arg1,
st32  arg2 
)

Definition at line 516 of file hashtable.c.

516  {
517  st32 result;
518 
519  if (arg2 & 0x1000000) {
520  if ((arg2 & 0x1000000) == 16777216) {
521  result = 63;
522  } else {
523  result = arg1;
524  }
525  } else {
526  result = 62;
527  }
528  return result;
529 }

References st32.

◆ get_hashfunc_16()

st32 get_hashfunc_16 ( st32  arg1,
st32  arg2 
)

Definition at line 531 of file hashtable.c.

531  {
532  st32 result;
533 
534  if (arg2 & 0x1000000) {
535  if ((arg2 & 0x1000000) == 16777216) {
536  result = 69;
537  } else {
538  result = arg1;
539  }
540  } else {
541  result = 64;
542  }
543  return result;
544 }

References st32.

◆ get_hashfunc_17()

st32 get_hashfunc_17 ( st32  arg1,
st32  arg2 
)

Definition at line 546 of file hashtable.c.

546  {
547  st32 result;
548 
549  if (arg2 & 0x1000000) {
550  if ((arg2 & 0x1000000) == 16777216) {
551  result = 68;
552  } else {
553  result = arg1;
554  }
555  } else {
556  result = 67;
557  }
558  return result;
559 }

References st32.

◆ get_hashfunc_18()

st32 get_hashfunc_18 ( st32  arg1,
st32  arg2 
)

Definition at line 561 of file hashtable.c.

561  {
562  st32 result;
563 
564  if (arg2 & 0x1000000) {
565  if ((arg2 & 0x1000000) == 16777216) {
566  result = 66;
567  } else {
568  result = arg1;
569  }
570  } else {
571  result = 65;
572  }
573  return result;
574 }

References st32.

◆ get_hashfunc_19()

st32 get_hashfunc_19 ( st32  arg1,
st32  arg2 
)

Definition at line 576 of file hashtable.c.

576  {
577  st32 v2;
578 
579  v2 = arg2 & 0xC1000000;
580  if ((arg2 & 0xC1000000u) > 0x40000000) {
581  if (v2 != 0x80000000 && v2 != 0xC0000000) {
582  return arg1;
583  }
584  } else {
585  if ((arg2 & 0xC1000000) != 0x40000000 && v2) {
586  if (v2 == 16777216) {
587  return 469;
588  }
589  return arg1;
590  }
591  }
592  return 59;
593 }

References st32.

◆ get_hashfunc_20()

st32 get_hashfunc_20 ( st32  arg1,
st32  arg2 
)

Definition at line 595 of file hashtable.c.

595  {
596  st32 v2;
597 
598  v2 = arg2 & 0x1400000;
599  if ((arg2 & 0x1400000u) <= 0x1000000) {
600  if ((arg2 & 0x1400000) == 16777216) {
601  return 75;
602  }
603  if (!v2) {
604  return 74;
605  }
606  if (v2 == 4194304) {
607  return 78;
608  }
609  return arg1;
610  }
611  if (v2 != 20971520) {
612  return arg1;
613  }
614  return 77;
615 }

References st32.

◆ get_hashfunc_21()

st32 get_hashfunc_21 ( st32  arg1,
st32  arg2 
)

Definition at line 617 of file hashtable.c.

617  {
618  st32 v2;
619 
620  v2 = arg2 & 0x1400000;
621  if ((arg2 & 0x1400000u) <= 0x1000000) {
622  if ((arg2 & 0x1400000) == 16777216) {
623  return 73;
624  }
625  if (!v2) {
626  return 72;
627  }
628  if (v2 == 4194304) {
629  return 108;
630  }
631  return arg1;
632  }
633  if (v2 != 20971520) {
634  return arg1;
635  }
636  return 109;
637 }

References st32.

◆ get_hashfunc_22()

st32 get_hashfunc_22 ( st32  arg1,
st32  arg2 
)

Definition at line 639 of file hashtable.c.

639  {
640  st32 result;
641 
642  if (arg2 & 0x8200) {
643  if ((unsigned short)(arg2 & 0x8200) == 512) {
644  result = 364;
645  } else {
646  result = arg1;
647  }
648  } else {
649  result = 357;
650  }
651  return result;
652 }

References st32.

◆ get_hashfunc_23()

st32 get_hashfunc_23 ( st32  arg1,
st32  arg2 
)

Definition at line 654 of file hashtable.c.

654  {
655  st32 v2;
656  st32 v3;
657 
658  v2 = arg2;
659  v3 = v2 & 0x41C000;
660  if ((ut32)v3 <= 0x400000) {
661  if (v3 == 4194304) {
662  return 323;
663  }
664  if ((ut32)v3 <= 0xC000) {
665  if (v3 != 49152) {
666  if (!v3) {
667  return 324;
668  }
669  if (v3 == 16384) {
670  return 370;
671  }
672  if (v3 == 32768) {
673  return 325;
674  }
675  return arg1;
676  }
677  return 372;
678  }
679  if (v3 != 65536) {
680  if (v3 != 81920) {
681  if (v3 == 114688) {
682  return 371;
683  }
684  return arg1;
685  }
686  return 373;
687  }
688  return 314;
689  }
690  if ((ut32)v3 <= 0x410000) {
691  if (v3 != 4259840) {
692  if (v3 == 4210688) {
693  return 369;
694  }
695  // if ( (st32 (*)(char))v3 == (char *)hash_const_01 )
696  if (v3 == hash_const_01) {
697  return 325;
698  }
699  if (v3 != 4243456) {
700  return arg1;
701  }
702  return 372;
703  }
704  return 314;
705  }
706  if (v3 != 4276224) {
707  if (v3 == 4308992) {
708  return 371;
709  }
710  return arg1;
711  }
712  return 373;
713 }
hash_const_01
static const st32 hash_const_01
Definition: hashtable.c:8

References hash_const_01, and st32.

◆ get_hashfunc_24()

st32 get_hashfunc_24 ( st32  arg1,
st32  arg2 
)

Definition at line 715 of file hashtable.c.

715  {
716  st32 v2;
717  st32 v3;
718 
719  v2 = arg2;
720  v3 = v2 & 0x418000;
721  if ((ut32)v3 <= 0x400000) {
722  if (v3 == 4194304) {
723  return 330;
724  }
725  if ((ut32)v3 <= 0x10000) {
726  if (v3 != 65536) {
727  if (!v3) {
728  return 329;
729  }
730  if (v3 == 32768) {
731  return 307;
732  }
733  return arg1;
734  }
735  return 480;
736  }
737  if (v3 == 98304) {
738  return 467;
739  }
740  return arg1;
741  }
742  // if ( (st32 (*)(char))v3 != (char *)hash_const_01 ) {
743  if (v3 != hash_const_01) {
744  if (v3 == 4259840) {
745  return 480;
746  }
747  if (v3 == 4292608) {
748  return 467;
749  }
750  return arg1;
751  }
752  return 308;
753 }

References hash_const_01, and st32.

◆ get_hashfunc_25()

st32 get_hashfunc_25 ( st32  arg1,
st32  arg2 
)

Definition at line 755 of file hashtable.c.

755  {
756  ut32 v2;
757 
758  v2 = (ut32)hash_const_02 & arg2;
759  if (((ut32)hash_const_02 & arg2) <= 0x8000) {
760  if (((ut32)hash_const_02 & arg2) != 32768) {
761  if (v2 <= 0x400) {
762  if (v2 != 1024 && v2) {
763  if (v2 == 512) {
764  return 365;
765  }
766  return arg1;
767  }
768  return 365;
769  }
770  if (v2 == 1536) {
771  return 365;
772  }
773  return arg1;
774  }
775  return 382;
776  }
777  if (v2 <= 0x8600) {
778  if (v2 != 34304 && v2 != 33280 && v2 != 33792) {
779  return arg1;
780  }
781  return 382;
782  }
783  // if ( (st32 (*)(char))v2 != (char *)hash_const_01 )
784  if (v2 != hash_const_01) {
785  return arg1;
786  }
787  return 380;
788 }
hash_const_02
static const st32 hash_const_02
Definition: hashtable.c:9

References hash_const_01, and hash_const_02.

◆ get_hashfunc_26()

st32 get_hashfunc_26 ( st32  arg1,
st32  arg2 
)

Definition at line 790 of file hashtable.c.

790  {
791  st32 v2;
792  st32 v3;
793 
794  v2 = arg2;
795  v3 = v2 & 0x41C000;
796  if ((ut32)v3 <= 0x404000) {
797  if (v3 == 4210688 || v3 == 16384) {
798  return 310;
799  }
800  if (v3 != 49152) {
801  if (v3 == 4194304) {
802  return 312;
803  }
804  return arg1;
805  }
806  return 311;
807  }
808  // if ( (st32 (*)(char))v3 != (st32 (*)(char))hash_const_01 ) {
809  if (v3 != hash_const_01) {
810  if (v3 != 4243456) {
811  return arg1;
812  }
813  return 311;
814  }
815  return 313;
816 }

References hash_const_01, and st32.

◆ get_hashfunc_27()

st32 get_hashfunc_27 ( st32  arg1,
st32  arg2 
)

Definition at line 818 of file hashtable.c.

818  {
819  st32 v2;
820  st32 v3;
821  st32 result;
822 
823  v2 = arg2;
824  v3 = v2 & 0x18000;
825  if (v3) {
826  if (v3 == 32768) {
827  result = 376;
828  } else {
829  if (v3 == 65536) {
830  result = 377;
831  } else {
832  result = arg1;
833  }
834  }
835  } else {
836  result = 375;
837  }
838  return result;
839 }

References st32.

◆ get_hashfunc_28()

st32 get_hashfunc_28 ( st32  arg1,
st32  arg2 
)

Definition at line 841 of file hashtable.c.

841  {
842  st32 v2;
843  st32 v3;
844  char v5;
845 
846  v2 = arg2;
847  v3 = v2 & 0x1F800;
848  if ((ut32)v3 <= 0xA000) {
849  if (v3 != 40960) {
850  if ((ut32)v3 <= 0x3000) {
851  if (v3 == 12288) {
852  return 384;
853  }
854  if ((ut32)v3 <= 0x1800) {
855  if (v3 != 6144 && v3 && v3 != 2048) {
856  if (v3 == 4096) {
857  return 384;
858  }
859  return arg1;
860  }
861  return 384;
862  }
863  if (v3 == 8192 || v3 == 10240) {
864  return 384;
865  }
866  return arg1;
867  }
868  if ((ut32)v3 > 0x8800) {
869  if (v3 != 36864) {
870  if (v3 == 38912) {
871  return 385;
872  }
873  return arg1;
874  }
875  } else {
876  if (v3 != 34816) {
877  if (v3 != 14336) {
878  if (v3 == 24576) {
879  return 388;
880  }
881  if (v3 == 32768) {
882  return 385;
883  }
884  return arg1;
885  }
886  return 384;
887  }
888  }
889  }
890  return 385;
891  }
892  if ((ut32)v3 <= 0x11000) {
893  if (v3 == 69632) {
894  return 386;
895  }
896  if ((ut32)v3 <= 0xE000) {
897  if (v3 == 57344) {
898  return 387;
899  }
900  if (v3 != 43008 && v3 != 45056 && v3 != 47104) {
901  return arg1;
902  }
903  return 385;
904  }
905  if (v3 == 65536) {
906  return 386;
907  }
908  v5 = v3 == 67584;
909  LABEL_35:
910  if (!v5) {
911  return arg1;
912  }
913  return 386;
914  }
915  if ((ut32)v3 <= 0x13000) {
916  if (v3 == 77824 || v3 == 71680 || v3 == 73728) {
917  return 386;
918  }
919  v5 = v3 == 75776;
920  goto LABEL_35;
921  }
922  if (v3 == 79872) {
923  return 386;
924  }
925  if (v3 != 90112) {
926  return arg1;
927  }
928  return 389;
929 }

References st32.

◆ get_hashfunc_29()

st32 get_hashfunc_29 ( st32  arg1,
st32  arg2 
)

Definition at line 931 of file hashtable.c.

931  {
932  st32 v2;
933  st32 v3;
934 
935  v2 = arg2;
936  v3 = v2 & 0x40F800;
937  if (v3 <= (ut32)hash_const_03) {
938  // if ( (st32 (*)(int, int, int))v3 == (st32 (*)(int, int, int))hash_const_03)
939  if (v3 == hash_const_03) {
940  return 305;
941  }
942  if (v3 == 40960) {
943  return 306;
944  }
945  if (v3 == 57344) {
946  return 391;
947  }
948  return arg1;
949  }
950  if (v3 != 4218880) {
951  return arg1;
952  }
953  return 390;
954 }
hash_const_03
static const st32 hash_const_03
Definition: hashtable.c:10

References hash_const_03, and st32.

◆ get_hashfunc_30()

st32 get_hashfunc_30 ( st32  arg1,
st32  arg2 
)

Definition at line 956 of file hashtable.c.

956  {
957  st32 v2;
958  st32 v3;
959  st32 result;
960 
961  v2 = arg2;
962  v3 = v2 & 0x18000;
963  if (v3) {
964  if (v3 == 32768) {
965  result = 303;
966  } else {
967  if (v3 == 65536) {
968  result = 304;
969  } else {
970  result = arg1;
971  }
972  }
973  } else {
974  result = 302;
975  }
976  return result;
977 }

References st32.

◆ get_hashfunc_31()

st32 get_hashfunc_31 ( st32  arg1,
st32  arg2 
)

Definition at line 979 of file hashtable.c.

979  {
980  st32 result;
981  st32 v3 = arg2 & 0x380000;
982 
983  if ((ut32)v3 <= 0x200000) {
984  if (v3 == 2097152) {
985  return 271;
986  }
987  if ((ut32)v3 > 0x100000) {
988  if (v3 == 1572864) {
989  return 534;
990  }
991  } else {
992  if (v3 == 1048576) {
993  return 317;
994  }
995  if (!v3) {
996  return 319;
997  }
998  if (v3 == 524288) {
999  return 533;
1000  }
1001  }
1002  return arg1;
1003  }
1004  if (v3 == 2621440) {
1005  result = 535;
1006  } else {
1007  if (v3 == 3145728) {
1008  result = 321;
1009  } else {
1010  if (v3 != 3670016) {
1011  return arg1;
1012  }
1013  result = 536;
1014  }
1015  }
1016  return result;
1017 }

References st32.

◆ get_hashfunc_32()

st32 get_hashfunc_32 ( st32  arg1,
st32  arg2 
)

Definition at line 1019 of file hashtable.c.

1019  {
1020  st32 v2;
1021  st32 v3;
1022  st32 result;
1023 
1024  v2 = arg2;
1025  v3 = v2 & 0x18000;
1026  if (v3) {
1027  if (v3 == 32768) {
1028  result = 258;
1029  } else {
1030  if (v3 == 65536) {
1031  result = 259;
1032  } else {
1033  result = arg1;
1034  }
1035  }
1036  } else {
1037  result = 261;
1038  }
1039  return result;
1040 }

References st32.

◆ get_hashfunc_33()

st32 get_hashfunc_33 ( st32  arg1,
st32  arg2 
)

Definition at line 1042 of file hashtable.c.

1042  {
1043  st32 result;
1044 
1045  if (arg2 & 0x8000) {
1046  if ((unsigned short)(arg2 & 0x8000) == 32768) {
1047  result = 327;
1048  } else {
1049  result = arg1;
1050  }
1051  } else {
1052  result = 326;
1053  }
1054  return result;
1055 }

References st32.

◆ get_hashfunc_34()

st32 get_hashfunc_34 ( st32  arg1,
st32  arg2 
)

Definition at line 1057 of file hashtable.c.

1057  {
1058  st32 result;
1059  st32 v2 = arg2;
1060  st32 v3 = v2 & 0x580000;
1061  if ((ut32)v3 <= 0x180000) {
1062  if (v3 == 1572864) {
1063  return 471;
1064  }
1065  if (!v3) {
1066  return 392;
1067  }
1068  if (v3 == 524288) {
1069  return 470;
1070  }
1071  if (v3 == 1048576) {
1072  return 393;
1073  }
1074  return arg1;
1075  }
1076  if (v3 == 4194304) {
1077  result = 394;
1078  } else {
1079  if (v3 != 5242880) {
1080  return arg1;
1081  }
1082  result = 395;
1083  }
1084  return result;
1085 }

References st32.

◆ get_hashfunc_35()

st32 get_hashfunc_35 ( st32  arg1,
st32  arg2 
)

Definition at line 1087 of file hashtable.c.

1087  {
1088  st32 result;
1089 
1090  if (arg2 & 0x1000000) {
1091  if ((arg2 & 0x1000000) == 16777216) {
1092  result = 189;
1093  } else {
1094  result = arg1;
1095  }
1096  } else {
1097  result = 186;
1098  }
1099  return result;
1100 }

References st32.

◆ get_hashfunc_36()

st32 get_hashfunc_36 ( st32  arg1,
st32  arg2 
)

Definition at line 1102 of file hashtable.c.

1102  {
1103  st32 result;
1104 
1105  if (arg2 & 0x1C00000) {
1106  if ((arg2 & 0x1C00000) == 16777216) {
1107  result = 188;
1108  } else {
1109  result = arg1;
1110  }
1111  } else {
1112  result = 187;
1113  }
1114  return result;
1115 }

References st32.

◆ get_hashfunc_37()

st32 get_hashfunc_37 ( st32  arg1,
st32  arg2 
)

Definition at line 1117 of file hashtable.c.

1117  {
1118  st32 result;
1119 
1120  if ((arg2 & 0x1800000) == 8388608) {
1121  result = 473;
1122  } else {
1123  if ((arg2 & 0x1800000) == 25165824) {
1124  result = 474;
1125  } else {
1126  result = arg1;
1127  }
1128  }
1129  return result;
1130 }

References st32.

◆ get_hashfunc_38()

st32 get_hashfunc_38 ( st32  arg1,
st32  arg2 
)

Definition at line 1132 of file hashtable.c.

1132  {
1133  st32 v2 = arg2 & 0x1010000;
1134  if ((arg2 & 0x1010000u) <= 0x1000000) {
1135  if ((arg2 & 0x1010000) == 16777216) {
1136  return 472;
1137  }
1138  if (!v2) {
1139  return 23;
1140  }
1141  if (v2 == 65536) {
1142  return 24;
1143  }
1144  return arg1;
1145  }
1146  if (v2 != 16842752) {
1147  return arg1;
1148  }
1149  return 26;
1150 }

References st32.

◆ get_hashfunc_39()

st32 get_hashfunc_39 ( st32  arg1,
st32  arg2 
)

Definition at line 1152 of file hashtable.c.

1152  {
1153  st32 result;
1154 
1155  if ((arg2 & 0x1010000) == 65536) {
1156  result = 25;
1157  } else {
1158  if ((arg2 & 0x1010000) == 16842752) {
1159  result = 27;
1160  } else {
1161  result = arg1;
1162  }
1163  }
1164  return result;
1165 }

References st32.

◆ get_hashfunc_40()

st32 get_hashfunc_40 ( st32  arg1,
st32  arg2 
)

Definition at line 1167 of file hashtable.c.

1167  {
1168  st32 result;
1169 
1170  if (arg2 & 0x1010000) {
1171  if ((arg2 & 0x1010000) == 16777216) {
1172  result = 135;
1173  } else {
1174  result = arg1;
1175  }
1176  } else {
1177  result = 134;
1178  }
1179  return result;
1180 }

References st32.

◆ get_hashfunc_41()

st32 get_hashfunc_41 ( st32  arg1,
st32  arg2 
)

Definition at line 1182 of file hashtable.c.

1182  {
1183  st32 result;
1184  st32 v2 = arg2 & 0x1010000;
1185  if (arg2 & 0x1010000) {
1186  if (v2 == 16777216) {
1187  result = 138;
1188  } else {
1189  if (v2 == 16842752) {
1190  result = 139;
1191  } else {
1192  result = arg1;
1193  }
1194  }
1195  } else {
1196  result = 137;
1197  }
1198  return result;
1199 }

References st32.

◆ get_hashfunc_42()

st32 get_hashfunc_42 ( st32  arg1,
st32  arg2 
)

Definition at line 1201 of file hashtable.c.

1201  {
1202  st32 v2 = arg2 & 0x1010000;
1203  if ((arg2 & 0x1010000u) <= 0x1000000) {
1204  if ((arg2 & 0x1010000) == 16777216) {
1205  return 12;
1206  }
1207  if (!v2) {
1208  return 11;
1209  }
1210  if (v2 == 65536) {
1211  return 8;
1212  }
1213  return arg1;
1214  }
1215  if (v2 != 16842752) {
1216  return arg1;
1217  }
1218  return 9;
1219 }

References st32.

◆ get_hashfunc_43()

st32 get_hashfunc_43 ( st32  arg1,
st32  arg2 
)

Definition at line 1221 of file hashtable.c.

1221  {
1222  st32 v2;
1223 
1224  v2 = arg2 & 0x1010000;
1225  if ((arg2 & 0x1010000u) <= 0x1000000) {
1226  if ((arg2 & 0x1010000) == 16777216) {
1227  return 13;
1228  }
1229  if (!v2) {
1230  return 15;
1231  }
1232  if (v2 == 65536) {
1233  return 10;
1234  }
1235  return arg1;
1236  }
1237  if (v2 != 16842752) {
1238  return arg1;
1239  }
1240  return 14;
1241 }

References st32.

◆ get_hashfunc_44()

st32 get_hashfunc_44 ( st32  arg1,
st32  arg2 
)

Definition at line 1243 of file hashtable.c.

1243  {
1244  st32 result;
1245 
1246  if (arg2 & 0x1000000) {
1247  if ((arg2 & 0x1000000) == 16777216) {
1248  result = 29;
1249  } else {
1250  result = arg1;
1251  }
1252  } else {
1253  result = 28;
1254  }
1255  return result;
1256 }

References st32.

◆ get_hashfunc_45()

st32 get_hashfunc_45 ( st32  arg1,
st32  arg2 
)

Definition at line 1258 of file hashtable.c.

1258  {
1259  st32 result;
1260 
1261  if (arg2 & 0x1000000) {
1262  if ((arg2 & 0x1000000) == 16777216) {
1263  result = 17;
1264  } else {
1265  result = arg1;
1266  }
1267  } else {
1268  result = 16;
1269  }
1270  return result;
1271 }

References st32.

◆ get_hashfunc_46()

st32 get_hashfunc_46 ( st32  arg1,
st32  arg2 
)

Definition at line 1273 of file hashtable.c.

1273  {
1274  st32 v2;
1275 
1276  v2 = arg2 & 0xC1000000;
1277  if ((arg2 & 0xC1000000u) > 0x40000000) {
1278  if (v2 != 0x80000000 && v2 != 0xC0000000) {
1279  return arg1;
1280  }
1281  } else {
1282  if ((arg2 & 0xC1000000) != 0x40000000 && v2) {
1283  if (v2 == 16777216) {
1284  return 136;
1285  }
1286  return arg1;
1287  }
1288  }
1289  return 18;
1290 }

References st32.

◆ get_hashfunc_47()

st32 get_hashfunc_47 ( st32  arg1,
st32  arg2 
)

Definition at line 1292 of file hashtable.c.

1292  {
1293  st32 result;
1294 
1295  if (arg2 & 0x1000000) {
1296  if ((arg2 & 0x1000000) == 16777216) {
1297  result = 130;
1298  } else {
1299  result = arg1;
1300  }
1301  } else {
1302  result = 132;
1303  }
1304  return result;
1305 }

References st32.

◆ get_hashfunc_48()

st32 get_hashfunc_48 ( st32  arg1,
st32  arg2 
)

Definition at line 1307 of file hashtable.c.

1307  {
1308  st32 result;
1309 
1310  if (arg2 & 0x1000000) {
1311  if ((arg2 & 0x1000000) == 16777216) {
1312  result = 133;
1313  } else {
1314  result = arg1;
1315  }
1316  } else {
1317  result = 131;
1318  }
1319  return result;
1320 }

References st32.

◆ get_hashfunc_49()

st32 get_hashfunc_49 ( st32  arg1,
st32  arg2 
)

Definition at line 1322 of file hashtable.c.

1322  {
1323  st32 result;
1324 
1325  if (arg2 & 0x80000000) {
1326  if ((arg2 & 0x80000000) == 0x80000000) {
1327  result = 33;
1328  } else {
1329  result = arg1;
1330  }
1331  } else {
1332  result = 35;
1333  }
1334  return result;
1335 }

References st32.

◆ get_hashfunc_50()

st32 get_hashfunc_50 ( st32  arg1,
st32  arg2 
)

Definition at line 1337 of file hashtable.c.

1337  {
1338  st32 v3 = arg2 & 0x780000;
1339  if ((ut32)v3 <= 0x400000) {
1340  if (v3 == 4194304) {
1341  return 522;
1342  }
1343  if ((ut32)v3 > 0x180000) {
1344  if (v3 == 2621440) {
1345  return 402;
1346  }
1347  if (v3 == 3145728) {
1348  return 411;
1349  }
1350  } else {
1351  if (v3 == 1572864) {
1352  return 401;
1353  }
1354  if (!v3) {
1355  return 403;
1356  }
1357  if (v3 == 524288) {
1358  return 400;
1359  }
1360  }
1361  return arg1;
1362  }
1363  if ((ut32)v3 <= 0x680000) {
1364  if (v3 == 0x680000) {
1365  return 526;
1366  }
1367  if (v3 == hash_const_05) {
1368  return 524;
1369  }
1370  if (v3 == 0x580000) {
1371  return 525;
1372  }
1373  return arg1;
1374  }
1375  if (v3 != 7340032) {
1376  return arg1;
1377  }
1378  return 523;
1379 }

References hash_const_05, and st32.

◆ get_hashfunc_51()

st32 get_hashfunc_51 ( st32  arg1,
st32  arg2 
)

Definition at line 1381 of file hashtable.c.

1381  {
1382  st32 v3 = arg2 & 0x180000;
1383  if ((ut32)v3 > 0x100000) {
1384  if (v3 != 1572864) {
1385  return arg1;
1386  }
1387  } else {
1388  if (v3 != 1048576) {
1389  if (!v3) {
1390  return 396;
1391  }
1392  if (v3 == 524288) {
1393  return 532;
1394  }
1395  return arg1;
1396  }
1397  }
1398  return 398;
1399 }

References st32.

◆ get_hashfunc_52()

st32 get_hashfunc_52 ( st32  arg1,
st32  arg2 
)

Definition at line 1401 of file hashtable.c.

1401  {
1402  st32 v3 = arg2 & 0x18000;
1403  if ((ut32)v3 <= 0x10000) {
1404  if (v3 == 0x10000) {
1405  return 296;
1406  }
1407  if (v3 == 0x8000) {
1408  return 300;
1409  }
1410  if (!v3) {
1411  return 298;
1412  }
1413  return arg1;
1414  }
1415  if (v3 != 0x18000) {
1416  return arg1;
1417  }
1418  return 301;
1419 }

References st32.

◆ get_hashfunc_53()

st32 get_hashfunc_53 ( st32  arg1,
st32  arg2 
)

Definition at line 1421 of file hashtable.c.

1421  {
1422  st32 v2 = arg2 & 0x8200;
1423  st32 result;
1424 
1425  if (arg2 & 0x8200) {
1426  if (v2 == 512) {
1427  result = 530;
1428  } else {
1429  result = (v2 == 0x8000) ? 297 : arg1;
1430  }
1431  } else {
1432  result = 355;
1433  }
1434  return result;
1435 }

References st32.

◆ get_hashfunc_54()

st32 get_hashfunc_54 ( st32  arg1,
st32  arg2 
)

Definition at line 1437 of file hashtable.c.

1437  {
1438  st32 v2 = arg2 & 0x8200;
1439  if ((ut32)v2 <= 0x8000) {
1440  if (v2 == 32768) {
1441  return 316;
1442  }
1443  if (!(arg2 & 0x8200)) {
1444  return 410;
1445  }
1446  if (v2 == 512) {
1447  return 531;
1448  }
1449  return arg1;
1450  }
1451  if (v2 != 33280) {
1452  return arg1;
1453  }
1454  return 315;
1455 }

References st32.

◆ get_hashfunc_55()

st32 get_hashfunc_55 ( st32  arg1,
st32  arg2 
)

Definition at line 1457 of file hashtable.c.

1457  {
1458  st32 result;
1459  if ((arg2 & 0x8000)) {
1460  if ((unsigned short)(arg2 & 0x8000) == 32768) {
1461  result = 295;
1462  } else {
1463  result = arg1;
1464  }
1465  } else {
1466  result = 294;
1467  }
1468  return result;
1469 }

References st32.

◆ get_hashfunc_56()

st32 get_hashfunc_56 ( st32  arg1,
st32  arg2 
)

Definition at line 1471 of file hashtable.c.

1471  {
1472  st32 result;
1473  st32 v3 = arg2 & 0x18180;
1474  if ((ut32)v3 <= 0x8080) {
1475  if (v3 == 32896) {
1476  return 528;
1477  }
1478  if (!v3) {
1479  return 406;
1480  }
1481  if (v3 == 128) {
1482  return 527;
1483  }
1484  if (v3 == 32768) {
1485  return 407;
1486  }
1487  return arg1;
1488  }
1489  if (v3 == 98304) {
1490  result = 408;
1491  } else {
1492  if (v3 != 98432) {
1493  return arg1;
1494  }
1495  result = 529;
1496  }
1497  return result;
1498 }

References st32.

◆ get_hashfunc_57()

st32 get_hashfunc_57 ( st32  arg1,
st32  arg2 
)

Definition at line 1500 of file hashtable.c.

1500  {
1501  st32 result;
1502 
1503  if (arg2 & 0x8000) {
1504  if ((unsigned short)(arg2 & 0x8000) == 32768) {
1505  result = 405;
1506  } else {
1507  result = arg1;
1508  }
1509  } else {
1510  result = 404;
1511  }
1512  return result;
1513 }

References st32.

◆ get_hashfunc_58()

st32 get_hashfunc_58 ( st32  arg1,
st32  arg2 
)

Definition at line 1515 of file hashtable.c.

1515  {
1516  st32 v2;
1517  st32 v3;
1518  st32 result;
1519 
1520  v2 = arg2;
1521  v3 = v2 & 0x18000;
1522  if (v3) {
1523  if (v3 == 32768) {
1524  result = 263;
1525  } else {
1526  if (v3 == 65536) {
1527  result = 264;
1528  } else {
1529  result = arg1;
1530  }
1531  }
1532  } else {
1533  result = 262;
1534  }
1535  return result;
1536 }

References st32.

◆ get_hashfunc_59()

st32 get_hashfunc_59 ( st32  arg1,
st32  arg2 
)

Definition at line 1538 of file hashtable.c.

1538  {
1539  st32 result;
1540  st32 v2 = arg2 & 0x8180;
1541  if ((ut32)v2 <= 0x100) {
1542  if (v2 == 256) {
1543  return 505;
1544  }
1545  if (!(arg2 & 0x8180)) {
1546  return 503;
1547  }
1548  if (v2 == 128) {
1549  return 504;
1550  }
1551  return arg1;
1552  }
1553  if (v2 == 384) {
1554  result = 506;
1555  } else {
1556  if (v2 != 32768) {
1557  return arg1;
1558  }
1559  result = 507;
1560  }
1561  return result;
1562 }

References st32.

◆ get_hashfunc_60()

st32 get_hashfunc_60 ( st32  arg1,
st32  arg2 
)

Definition at line 1564 of file hashtable.c.

1564  {
1565  st32 result;
1566 
1567  if (arg2 & 0x1000000) {
1568  if ((arg2 & 0x1000000) == 16777216) {
1569  result = 173;
1570  } else {
1571  result = arg1;
1572  }
1573  } else {
1574  result = 172;
1575  }
1576  return result;
1577 }

References st32.

◆ get_hashfunc_61()

st32 get_hashfunc_61 ( st32  arg1,
st32  arg2 
)

Definition at line 1579 of file hashtable.c.

1579  {
1580  st32 result;
1581 
1582  if (arg2 & 0x1000000) {
1583  if ((arg2 & 0x1000000) == 16777216) {
1584  result = 175;
1585  } else {
1586  result = arg1;
1587  }
1588  } else {
1589  result = 174;
1590  }
1591  return result;
1592 }

References st32.

◆ get_hashfunc_62()

st32 get_hashfunc_62 ( st32  arg1,
st32  arg2 
)

Definition at line 1594 of file hashtable.c.

1594  {
1595  st32 result;
1596 
1597  if (arg2 & 0x1000000) {
1598  if ((arg2 & 0x1000000) == 16777216) {
1599  result = 152;
1600  } else {
1601  result = arg1;
1602  }
1603  } else {
1604  result = 151;
1605  }
1606  return result;
1607 }

References st32.

◆ get_hashfunc_63()

st32 get_hashfunc_63 ( st32  arg1,
st32  arg2 
)

Definition at line 1609 of file hashtable.c.

1609  {
1610  st32 result;
1611 
1612  if (arg2 & 0x1000000) {
1613  if ((arg2 & 0x1000000) == 16777216) {
1614  result = 154;
1615  } else {
1616  result = arg1;
1617  }
1618  } else {
1619  result = 153;
1620  }
1621  return result;
1622 }

References st32.

◆ get_hashfunc_64()

st32 get_hashfunc_64 ( st32  arg1,
st32  arg2 
)

Definition at line 1624 of file hashtable.c.

1624  {
1625  st32 result;
1626 
1627  if (arg2 & 0x1000000) {
1628  if ((arg2 & 0x1000000) == 16777216) {
1629  result = 180;
1630  } else {
1631  result = arg1;
1632  }
1633  } else {
1634  result = 179;
1635  }
1636  return result;
1637 }

References st32.

◆ get_hashfunc_65()

st32 get_hashfunc_65 ( st32  arg1,
st32  arg2 
)

Definition at line 1639 of file hashtable.c.

1639  {
1640  st32 result;
1641 
1642  if (arg2 & 0x1000000) {
1643  if ((arg2 & 0x1000000) == 16777216) {
1644  result = 182;
1645  } else {
1646  result = arg1;
1647  }
1648  } else {
1649  result = 181;
1650  }
1651  return result;
1652 }

References st32.

◆ get_hashfunc_66()

st32 get_hashfunc_66 ( st32  arg1,
st32  arg2 
)

Definition at line 1654 of file hashtable.c.

1654  {
1655  st32 result;
1656 
1657  if ((arg2 & 0x1C00000) == 12582912) {
1658  result = 157;
1659  } else {
1660  if ((arg2 & 0x1C00000) == 29360128) {
1661  result = 158;
1662  } else {
1663  result = arg1;
1664  }
1665  }
1666  return result;
1667 }

References st32.

◆ get_hashfunc_67()

st32 get_hashfunc_67 ( st32  arg1,
st32  arg2 
)

Definition at line 1669 of file hashtable.c.

1669  {
1670  st32 result;
1671 
1672  if (arg2 & 0x1000000) {
1673  if ((arg2 & 0x1000000) == 16777216) {
1674  result = 57;
1675  } else {
1676  result = arg1;
1677  }
1678  } else {
1679  result = 56;
1680  }
1681  return result;
1682 }

References st32.

◆ get_hashfunc_68()

st32 get_hashfunc_68 ( st32  arg1,
st32  arg2 
)

Definition at line 1684 of file hashtable.c.

1684  {
1685  st32 result;
1686 
1687  if (arg2 & 0x1000000) {
1688  if ((arg2 & 0x1000000) == 16777216) {
1689  result = 208;
1690  } else {
1691  result = arg1;
1692  }
1693  } else {
1694  result = 207;
1695  }
1696  return result;
1697 }

References st32.

◆ get_hashfunc_69()

st32 get_hashfunc_69 ( st32  arg1,
st32  arg2 
)

Definition at line 1699 of file hashtable.c.

1699  {
1700  st32 result;
1701 
1702  if (arg2 & 0x1000000) {
1703  if ((arg2 & 0x1000000) == 16777216) {
1704  result = 209;
1705  } else {
1706  result = arg1;
1707  }
1708  } else {
1709  result = 210;
1710  }
1711  return result;
1712 }

References st32.

◆ get_hashfunc_70()

st32 get_hashfunc_70 ( st32  arg1,
st32  arg2 
)

Definition at line 1714 of file hashtable.c.

1714  {
1715  st32 v2;
1716  st32 result;
1717 
1718  v2 = arg2 & 0x1400000;
1719  if (arg2 & 0x1400000) {
1720  if (v2 == 16777216) {
1721  result = 217;
1722  } else {
1723  if (v2 == 20971520) {
1724  result = 212;
1725  } else {
1726  result = arg1;
1727  }
1728  }
1729  } else {
1730  result = 216;
1731  }
1732  return result;
1733 }

References st32.

◆ get_hashfunc_71()

st32 get_hashfunc_71 ( st32  arg1,
st32  arg2 
)

Definition at line 1735 of file hashtable.c.

1735  {
1736  st32 result;
1737 
1738  if (arg2 & 0x1400000) {
1739  if ((arg2 & 0x1400000) == 4194304) {
1740  result = 211;
1741  } else {
1742  result = arg1;
1743  }
1744  } else {
1745  result = 218;
1746  }
1747  return result;
1748 }

References st32.

◆ get_hashfunc_72()

st32 get_hashfunc_72 ( st32  arg1,
st32  arg2 
)

Definition at line 1750 of file hashtable.c.

1750  {
1751  st32 result;
1752 
1753  if (arg2 & 0x1000000) {
1754  if ((arg2 & 0x1000000) == 16777216) {
1755  result = 221;
1756  } else {
1757  result = arg1;
1758  }
1759  } else {
1760  result = 220;
1761  }
1762  return result;
1763 }

References st32.

◆ get_hashfunc_73()

st32 get_hashfunc_73 ( st32  arg1,
st32  arg2 
)

Definition at line 1765 of file hashtable.c.

1765  {
1766  st32 result;
1767 
1768  if (arg2 & 0x1010000) {
1769  if ((arg2 & 0x1010000) == 16777216) {
1770  result = 215;
1771  } else {
1772  result = arg1;
1773  }
1774  } else {
1775  result = 214;
1776  }
1777  return result;
1778 }

References st32.

◆ get_hashfunc_74()

st32 get_hashfunc_74 ( st32  arg1,
st32  arg2 
)

Definition at line 1780 of file hashtable.c.

1780  {
1781  st32 result;
1782 
1783  if ((arg2 & 0x1010000) == 65536) {
1784  result = 213;
1785  } else {
1786  if ((arg2 & 0x1010000) == 16842752) {
1787  result = 426;
1788  } else {
1789  result = arg1;
1790  }
1791  }
1792  return result;
1793 }

References st32.

◆ get_hashfunc_75()

st32 get_hashfunc_75 ( st32  arg1,
st32  arg2 
)

Definition at line 1795 of file hashtable.c.

1795  {
1796  st32 result;
1797 
1798  if (arg2 & 0x80000000) {
1799  if ((arg2 & 0x80000000) == 0x80000000) {
1800  result = 457;
1801  } else {
1802  result = arg1;
1803  }
1804  } else {
1805  result = 459;
1806  }
1807  return result;
1808 }

References st32.

◆ get_hashfunc_76()

st32 get_hashfunc_76 ( st32  arg1,
st32  arg2 
)

Definition at line 1810 of file hashtable.c.

1810  {
1811  st32 result;
1812 
1813  if (arg2 & 0x1000000) {
1814  if ((arg2 & 0x1000000) == 16777216) {
1815  result = 21;
1816  } else {
1817  result = arg1;
1818  }
1819  } else {
1820  result = 19;
1821  }
1822  return result;
1823 }

References st32.

◆ get_hashfunc_77()

st32 get_hashfunc_77 ( st32  arg1,
st32  arg2 
)

Definition at line 1825 of file hashtable.c.

1825  {
1826  st32 result;
1827 
1828  if (arg2 & 0x1000000) {
1829  if ((arg2 & 0x1000000) == 16777216) {
1830  result = 22;
1831  } else {
1832  result = arg1;
1833  }
1834  } else {
1835  result = 20;
1836  }
1837  return result;
1838 }

References st32.

◆ get_hashfunc_78()

st32 get_hashfunc_78 ( st32  arg1,
st32  arg2 
)

Definition at line 1840 of file hashtable.c.

1840  {
1841  st32 v3 = arg2 & 0x18000;
1842  if ((ut32)v3 <= 0x10000) {
1843  if (v3 == 65536) {
1844  return 429;
1845  }
1846  if (!v3) {
1847  return 427;
1848  }
1849  if (v3 == 32768) {
1850  return 428;
1851  }
1852 
1853  return arg1;
1854  }
1855  if (v3 != 98304) {
1856  return arg1;
1857  }
1858  return 252;
1859 }

References st32.

◆ get_hashfunc_79()

st32 get_hashfunc_79 ( st32  arg1,
st32  arg2 
)

Definition at line 1861 of file hashtable.c.

1861  {
1862  st32 v2;
1863  st32 v3;
1864  st32 result;
1865 
1866  v2 = arg2;
1867  v3 = v2 & 0x18180;
1868  if ((ut32)v3 <= 0x8100) {
1869  if (v3 == 33024) {
1870  return 437;
1871  }
1872  if ((ut32)v3 > 0x180) {
1873  if (v3 == 32768) {
1874  return 431;
1875  }
1876  if (v3 == 32896) {
1877  return 435;
1878  }
1879  } else {
1880  if (v3 == 384) {
1881  return 440;
1882  }
1883  if (!v3) {
1884  return 430;
1885  }
1886  if (v3 == 128) {
1887  return 432;
1888  }
1889  if (v3 == 256) {
1890  return 434;
1891  }
1892  }
1893  return arg1;
1894  }
1895  if ((ut32)v3 <= 0x10100) {
1896  if (v3 == 65792) {
1897  return 442;
1898  }
1899  if (v3 == 33152) {
1900  return 441;
1901  }
1902  if (v3 == 65536) {
1903  return 433;
1904  }
1905  if (v3 == 65664) {
1906  return 436;
1907  }
1908  return arg1;
1909  }
1910  if (v3 == 65920) {
1911  result = 439;
1912  } else {
1913  if (v3 != 98688) {
1914  return arg1;
1915  }
1916  result = 438;
1917  }
1918  return result;
1919 }

References st32.

◆ get_hashfunc_80()

st32 get_hashfunc_80 ( st32  arg1,
st32  arg2 
)

Definition at line 1921 of file hashtable.c.

1921  {
1922  st32 v2;
1923  st32 v3;
1924  st32 result;
1925 
1926  v2 = arg2;
1927  v3 = v2 & 0x18180;
1928  if ((ut32)v3 <= 0x8100) {
1929  if (v3 == 33024) {
1930  return 450;
1931  }
1932  if ((ut32)v3 > 0x180) {
1933  if (v3 == 32768) {
1934  return 444;
1935  }
1936  if (v3 == 32896) {
1937  return 448;
1938  }
1939  } else {
1940  if (v3 == 384) {
1941  return 453;
1942  }
1943  if (!v3) {
1944  return 443;
1945  }
1946  if (v3 == 128) {
1947  return 445;
1948  }
1949  if (v3 == 256) {
1950  return 447;
1951  }
1952  }
1953  return arg1;
1954  }
1955  if ((ut32)v3 <= 0x10100) {
1956  if (v3 == 65792) {
1957  return 455;
1958  }
1959  if (v3 == 33152) {
1960  return 454;
1961  }
1962  if (v3 == 65536) {
1963  return 446;
1964  }
1965  if (v3 == 65664) {
1966  return 449;
1967  }
1968  return arg1;
1969  }
1970  if (v3 == 65920) {
1971  result = 452;
1972  } else {
1973  if (v3 != 98688) {
1974  return arg1;
1975  }
1976  result = 451;
1977  }
1978  return result;
1979 }

References st32.

◆ get_hashfunc_81()

st32 get_hashfunc_81 ( st32  arg1,
st32  arg2 
)

Definition at line 1981 of file hashtable.c.

1981  {
1982  st32 result;
1983  st32 v2 = arg2 & 0x1000180;
1984  if ((arg2 & 0x1000180u) <= 0x1000000) {
1985  if ((arg2 & 0x1000180) == 16777216) {
1986  return 191;
1987  }
1988  if ((ut32)v2 > 0x100) {
1989  if (v2 == 384) {
1990  return 200;
1991  }
1992  } else {
1993  if (v2 == 256) {
1994  return 538;
1995  }
1996  if (!v2) {
1997  return 190;
1998  }
1999  if (v2 == 128) {
2000  return 537;
2001  }
2002  }
2003  return arg1;
2004  }
2005  if (v2 == 16777344) {
2006  result = 194;
2007  } else {
2008  if (v2 == 16777472) {
2009  result = 539;
2010  } else {
2011  if (v2 != 16777600) {
2012  return arg1;
2013  }
2014  result = 201;
2015  }
2016  }
2017  return result;
2018 }

References st32.

◆ get_hashfunc_82()

st32 get_hashfunc_82 ( st32  arg1,
st32  arg2 
)

Definition at line 2020 of file hashtable.c.

2020  {
2021  st32 v2;
2022  st32 result;
2023 
2024  v2 = arg2 & 0x1000180;
2025  if ((arg2 & 0x1000180u) <= 0x100) {
2026  if ((arg2 & 0x1000180) == 256) {
2027  return 203;
2028  }
2029  if (!v2) {
2030  return 192;
2031  }
2032  if (v2 == 128) {
2033  return 195;
2034  }
2035  return arg1;
2036  }
2037  if (v2 == 384) {
2038  result = 198;
2039  } else {
2040  if (v2 != 16777600) {
2041  return arg1;
2042  }
2043  result = 196;
2044  }
2045  return result;
2046 }

References st32.

◆ get_hashfunc_83()

st32 get_hashfunc_83 ( st32  arg1,
st32  arg2 
)

Definition at line 2048 of file hashtable.c.

2048  {
2049  st32 v2;
2050  st32 result;
2051  char v4;
2052 
2053  v2 = arg2 & 0x1810180;
2054  if ((arg2 & 0x1810180u) <= 0x800080) {
2055  if ((arg2 & 0x1810180) != 8388736) {
2056  if ((ut32)v2 <= 0x10000) {
2057  if (v2 == 65536) {
2058  return 193;
2059  }
2060  if ((ut32)v2 <= 0x100) {
2061  if (v2 != 256) {
2062  if (v2) {
2063  if (v2 == 128) {
2064  return 197;
2065  }
2066  return arg1;
2067  }
2068  return 193;
2069  }
2070  return 202;
2071  }
2072  v4 = v2 == 384;
2073  LABEL_11:
2074  if (v4) {
2075  return 199;
2076  }
2077  return arg1;
2078  }
2079  if ((ut32)v2 > 0x10180) {
2080  if (v2 == 8388608) {
2081  return 193;
2082  }
2083  return arg1;
2084  }
2085  if (v2 == 65920) {
2086  return 199;
2087  }
2088  if (v2 != 65664) {
2089  if (v2 == 65792) {
2090  return 202;
2091  }
2092  return arg1;
2093  }
2094  }
2095  return 197;
2096  }
2097  if ((ut32)v2 <= 0x810100) {
2098  if (v2 == 8454400) {
2099  return 202;
2100  }
2101  if ((ut32)v2 <= 0x810000) {
2102  if (v2 == 8454144) {
2103  return 193;
2104  }
2105  if (v2 == 8388864) {
2106  return 202;
2107  }
2108  v4 = v2 == 8388992;
2109  goto LABEL_11;
2110  }
2111  if (v2 != 8454272) {
2112  return arg1;
2113  }
2114  return 197;
2115  }
2116  if (v2 == 8454528) {
2117  return 199;
2118  }
2119  if (v2 == 16777216) {
2120  result = 205;
2121  } else {
2122  if (v2 != 16777344) {
2123  return arg1;
2124  }
2125  result = 206;
2126  }
2127  return result;
2128 }

References st32.

◆ get_hashfunc_84()

st32 get_hashfunc_84 ( st32  arg1,
st32  arg2 
)

Definition at line 2130 of file hashtable.c.

2130  {
2131  st32 result;
2132  st32 v2 = arg2 & 0x1000180;
2133  if (arg2 & 0x1000180) {
2134  if (v2 == 16777344) {
2135  result = 509;
2136  } else {
2137  if (v2 == 16777472) {
2138  result = 510;
2139  } else {
2140  result = arg1;
2141  }
2142  }
2143  } else {
2144  result = 508;
2145  }
2146  return result;
2147 }

References st32.

◆ get_hashfunc_85()

st32 get_hashfunc_85 ( st32  arg1,
st32  arg2 
)

Definition at line 2149 of file hashtable.c.

2149  {
2150  st32 result;
2151 
2152  if ((arg2 & 0x1000180) == 128) {
2153  result = 511;
2154  } else {
2155  if ((arg2 & 0x1000180) == 256) {
2156  result = 512;
2157  } else {
2158  result = arg1;
2159  }
2160  }
2161  return result;
2162 }

References st32.

◆ get_hashfunc_86()

st32 get_hashfunc_86 ( st32  arg1,
st32  arg2 
)

Definition at line 2164 of file hashtable.c.

2164  {
2165  st32 result;
2166 
2167  if (arg2 & 0x1000000) {
2168  if ((arg2 & 0x1000000) == 16777216) {
2169  result = 171;
2170  } else {
2171  result = arg1;
2172  }
2173  } else {
2174  result = 170;
2175  }
2176  return result;
2177 }

References st32.

◆ get_hashfunc_87()

st32 get_hashfunc_87 ( st32  arg1,
st32  v2 
)

Definition at line 2179 of file hashtable.c.

2179  {
2180  st32 result;
2181  st32 v3 = v2 & 0x79B981;
2182  if (v3 == 33024 || v3 == 4227328) {
2183  result = 490;
2184  } else {
2185  result = (v3 == 4260097) ? 491 : arg1;
2186  }
2187  return result;
2188 }

References st32.

◆ get_hashfunc_88()

st32 get_hashfunc_88 ( st32  arg1,
st32  arg2 
)

Definition at line 2190 of file hashtable.c.

2190  {
2191  st32 v2 = arg2;
2192  st32 v3 = v2 & 0x79B981;
2193  if ((ut32)v3 <= 0x410101) {
2194  if (v3 == 0x410101) {
2195  return 493;
2196  }
2197  if (v3 == 0x8100 || v3 == 0x408100) {
2198  return 492;
2199  }
2200  return arg1;
2201  }
2202  if (v3 != hash_const_04) {
2203  return arg1;
2204  }
2205  return 494;
2206 }
hash_const_04
static const st32 hash_const_04
Definition: hashtable.c:11

References hash_const_04, and st32.

◆ get_hashfunc_89()

st32 get_hashfunc_89 ( st32  arg1,
st32  arg2 
)

Definition at line 2208 of file hashtable.c.

2208  {
2209  st32 result;
2210 
2211  if ((arg2 & 0x1B901B9) == 16777600) {
2212  result = 488;
2213  } else {
2214  if ((arg2 & 0x1B901B9) == 25231616) {
2215  result = 495;
2216  } else {
2217  result = arg1;
2218  }
2219  }
2220  return result;
2221 }

References st32.

◆ get_hashfunc_90()

st32 get_hashfunc_90 ( st32  arg1,
st32  arg2 
)

Definition at line 2223 of file hashtable.c.

2223  {
2224  st32 v2;
2225  st32 v4;
2226  st32 v5;
2227 
2228  v2 = arg2 & 0x1F901B9;
2229  if ((arg2 & 0x1F901B9u) <= 0x1810101) {
2230  if ((arg2 & 0x1F901B9) == 25231617) {
2231  return 498;
2232  }
2233  if ((ut32)v2 <= 0x1000180) {
2234  if (v2 != 16777600) {
2235  if (v2 == 8454401) {
2236  return 497;
2237  }
2238  if (v2 == 8454529) {
2239  return 499;
2240  }
2241  return arg1;
2242  }
2243  return 489;
2244  }
2245  if (v2 == 20971904) {
2246  return 489;
2247  }
2248  return arg1;
2249  }
2250  v4 = v2 - 25231744;
2251  if (v4) {
2252  v5 = v4 - 1;
2253  if (!v5) {
2254  return 500;
2255  }
2256 
2257  /* FIX */
2258  v5 -= 0x3FFFFF;
2259  if (v5 != 0) {
2260  return arg1;
2261  }
2262  /*
2263  if ( (_UNKNOWN *)v5 != &unk_3FFFFF )
2264  return arg1;
2265  */
2266  }
2267  return 496;
2268 }

References st32.

◆ get_hashfunc_91()

st32 get_hashfunc_91 ( st32  arg1,
st32  arg2 
)

Definition at line 2270 of file hashtable.c.

2270  {
2271  st32 result;
2272 
2273  if ((arg2 & 0x1F901BF) == 8454145) {
2274  result = 501;
2275  } else {
2276  if ((arg2 & 0x1F901BF) == 25231361) {
2277  result = 502;
2278  } else {
2279  result = arg1;
2280  }
2281  }
2282  return result;
2283 }

References st32.

Variable Documentation

◆ hash_const_01

const st32 hash_const_01 = 0x2474f685
static

Definition at line 8 of file hashtable.c.

Referenced by get_hashfunc_23(), get_hashfunc_24(), get_hashfunc_25(), and get_hashfunc_26().

◆ hash_const_02

const st32 hash_const_02 = 0x42fbc0b8
static

Definition at line 9 of file hashtable.c.

Referenced by get_hashfunc_25().

◆ hash_const_03

const st32 hash_const_03 = 0x086a18eb
static

Definition at line 10 of file hashtable.c.

Referenced by get_hashfunc_29().

◆ hash_const_04

const st32 hash_const_04 = 0x001d02e8
static

Definition at line 11 of file hashtable.c.

Referenced by get_hashfunc_88().

◆ hash_const_05

const st32 hash_const_05 = 0
static

Definition at line 12 of file hashtable.c.

Referenced by get_hashfunc_11(), and get_hashfunc_50().

◆ ins_buff

ut8* ins_buff
extern

Definition at line 6 of file ins.c.

Referenced by get_ins_part().

◆ ins_buff_len

ut32 ins_buff_len
extern

Definition at line 7 of file ins.c.

Referenced by get_ins_part().

◆ ins_hash

HASHCODE_ENTRY_T ins_hash[]
static

Definition at line 2285 of file hashtable.c.

Referenced by get_hash_code().